tree 0f7b6510e7a9cb871945ec5b52b90e648c70510d
parent 6e13952269ad729594f2670b889bd806e9b0f3b3
author Steve Fung <stevefung@chromium.org> 1423812680 -0800
committer ChromeOS Commit Bot <chromeos-commit-bot@chromium.org> 1424076236 +0000

crash: Fix session manager D-Bus call service name

The D-Bus call to session manager was using the incorrect service
name field, causing the crash reporter session lookup to fail and
fallback to placing the crash in /home/chronos/crash.  Fix the
D-Bus call so that crashes are put in the right place.

Also, fixing this exposed an error with processing the results.
The previous D-Bus code treated an empty session response the
same as a D-Bus connection error, with the new code D-Bus errors
are handled separately, so also check whether the returned array
is empty.

BUG=chromium:458330
TEST=triggered crash with 'chrome://crash' page; crash files are
     placed in /home/chronos/user/crash
TEST=`test_that -b panther <IP> logging_UserCrash` passes

Change-Id: I77733adc5e4287d9eae83a749818d9cc38398c80
Reviewed-on: https://chromium-review.googlesource.com/249800
Reviewed-by: Dan Erat <derat@chromium.org>
Tested-by: Steve Fung <stevefung@chromium.org>
Commit-Queue: Steve Fung <stevefung@chromium.org>
