tree d1094b2241f46fa80225bb173f1d3de78c055dda
parent 6834cba4242b0dabe7ef75c7658c9a24136fbd58
author Zhuohao Lee <zhuohao@chromium.org> 1523415737 +0800
committer chrome-bot <chrome-bot@chromium.org> 1523545190 -0700

cros_update_firmware: Restore the started working packages

When using cros_update_firmware, it will try to cros_workon start
three packages without considering the working packages status.
After using cros_update_firmware, the three packages will be started.
That might be different to original environment.
This patch is used to check the working packages status and restore
the started packages afterwards.

BUG=none
TEST=run cros_update_firmware on Coral with 4 combination.
     chromeos-config-bsp-${board}-private chromeos-firmware-${board}
 1.           start                            start
 2.           start                            stop
 3.           stop                             start
 4.           stop                             stop

Change-Id: I499430c7e88608e0acf063b814d7aeed0ed8305d
Signed-off-by: Zhuohao Lee <zhuohao@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/1004838
Commit-Ready: YH Lin <yueherngl@chromium.org>
Reviewed-by: Jason Clinton <jclinton@chromium.org>
Reviewed-by: YH Lin <yueherngl@chromium.org>
