Receive powerwash after update from update engine

Currently, chrome deals with powerwash after an update (e.g. on channel
downgrade) itself, from computing whether it should happen, to actually
issuing a powerwash which is never executed because the update engine
takes care of it.

After this change and the corresponding changes in the update engine,
chrome will rely on the update engine sending a flag indicating whether
a powerwash will happen after the update.

The system notifications will be addressed in a separate CL because
adapting the code there also requires properly dealing with the
rollback flag.

Depends on https://crrev.com/c/2187672

Bug: 2187671
Change-Id: I2aa7024fb7978c21e6396e366f9876d42a72e873
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2187635
Commit-Queue: Miriam Polzer <mpolzer@google.com>
Reviewed-by: Esmael Elmoslimany <aee@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#771503}

chrome/browser/resources/settings/chromeos/os_about_page/os_about_page.html

@@ -127,14 +127,10 @@
             </div>
             <div class="separator" hidden="[[!showButtonContainer_]]"></div>
             <span id="buttonContainer" hidden="[[!showButtonContainer_]]">
-              <cr-button id="relaunch" hidden="[[!showRelaunch_]]"
-                  on-click="onRelaunchClick_">
-                $i18n{aboutRelaunch}
-              </cr-button>
-              <cr-button id="relaunchAndPowerwash"
-                  hidden="[[!showRelaunchAndPowerwash_]]"
-                  on-click="onRelaunchAndPowerwashClick_">
-                $i18n{aboutRelaunchAndPowerwash}
+              <cr-button id="relaunch" hidden$="[[!showRelaunch_]]"
+                         on-click="onRelaunchClick_">
+                  [[getRelaunchButtonText_(
+                                  currentUpdateStatusEvent_)]]
               </cr-button>
               <cr-button id="checkForUpdates" hidden="[[!showCheckUpdates_]]"
                   on-click="onCheckUpdatesClick_">

chrome/browser/resources/settings/chromeos/os_about_page/os_about_page.js

@@ -25,6 +25,7 @@ Polymer({
         message: '',
         progress: 0,
         rollback: false,
+        powerwash: false,
         status: UpdateStatus.DISABLED
       },
     },
@@ -102,14 +103,7 @@ Polymer({
     showRelaunch_: {
       type: Boolean,
       value: false,
-    },
-
-    /** @private */
-    showRelaunchAndPowerwash_: {
-      type: Boolean,
-      value: false,
-      computed: 'computeShowRelaunchAndPowerwash_(' +
-          'currentUpdateStatusEvent_, targetChannel_, currentChannel_)',
+      computed: 'computeShowRelaunch_(currentUpdateStatusEvent_)',
     },
 
     /** @private */
@@ -156,10 +150,8 @@ Polymer({
     'updateShowUpdateStatus_(' +
         'hasEndOfLife_, currentUpdateStatusEvent_,' +
         'hasCheckedForUpdates_)',
-    'updateShowRelaunch_(currentUpdateStatusEvent_, targetChannel_,' +
-        'currentChannel_)',
     'updateShowButtonContainer_(' +
-        'showRelaunch_, showRelaunchAndPowerwash_, showCheckUpdates_)',
+        'showRelaunch_, showCheckUpdates_)',
     'handleCrostiniEnabledChanged_(prefs.crostini.enabled.value)',
   ],
 
@@ -301,14 +293,12 @@ Polymer({
    * @private
    */
   updateShowButtonContainer_() {
-    this.showButtonContainer_ = this.showRelaunch_ ||
-        this.showRelaunchAndPowerwash_ || this.showCheckUpdates_;
+    this.showButtonContainer_ = this.showRelaunch_ || this.showCheckUpdates_;
   },
 
   /** @private */
-  updateShowRelaunch_() {
-    this.showRelaunch_ =
-        this.checkStatus_(UpdateStatus.NEARLY_UPDATED) && !this.isRollback_();
+  computeShowRelaunch_() {
+    return this.checkStatus_(UpdateStatus.NEARLY_UPDATED);
   },
 
   /**
@@ -445,15 +435,8 @@ Polymer({
    * @return {boolean}
    * @private
    */
-  isRollback_() {
-    assert(this.currentChannel_.length > 0);
-    assert(this.targetChannel_.length > 0);
-    if (this.currentUpdateStatusEvent_.rollback) {
-      return true;
-    }
-    // Channel switch to a more stable channel is also a rollback
-    return settings.isTargetChannelMoreStable(
-        this.currentChannel_, this.targetChannel_);
+  isPowerwash_() {
+    return this.currentUpdateStatusEvent_.powerwash;
   },
 
   /** @private */
@@ -462,24 +445,18 @@ Polymer({
         settings.routes.DETAILED_BUILD_INFO);
   },
 
-  /** @private */
-  onRelaunchAndPowerwashClick_() {
-    settings.recordSettingChange();
-    if (this.currentUpdateStatusEvent_.rollback) {
-      // Wipe already initiated, simply relaunch.
-      this.lifetimeBrowserProxy_.relaunch();
-    } else {
-      this.lifetimeBrowserProxy_.factoryReset(
-          /* requestTpmFirmwareUpdate= */ false);
-    }
-  },
-
   /**
-   * @return {boolean}
+   * @return {string}
    * @private
    */
-  computeShowRelaunchAndPowerwash_() {
-    return this.checkStatus_(UpdateStatus.NEARLY_UPDATED) && this.isRollback_();
+  getRelaunchButtonText_() {
+    if (this.checkStatus_(UpdateStatus.NEARLY_UPDATED)) {
+      if (this.isPowerwash_()) {
+        return this.i18nAdvanced('aboutRelaunchAndPowerwash');
+      } else {
+        return this.i18nAdvanced('aboutRelaunch');
+      }
+    }
   },
 
   /** @private */

chrome/browser/ui/webui/help/test_version_updater.cc

@@ -10,5 +10,6 @@ TestVersionUpdater::~TestVersionUpdater() = default;
 
 void TestVersionUpdater::CheckForUpdate(const StatusCallback& callback,
                                         const PromoteCallback&) {
-  callback.Run(status_, progress_, rollback_, version_, update_size_, message_);
+  callback.Run(status_, progress_, rollback_, powerwash_, version_,
+               update_size_, message_);
 }

chrome/browser/ui/webui/help/test_version_updater.h

@@ -42,6 +42,7 @@ class TestVersionUpdater : public VersionUpdater {
   Status status_ = Status::UPDATED;
   int progress_ = 0;
   bool rollback_ = false;
+  bool powerwash_ = false;
   std::string version_;
   int64_t update_size_ = 0;
   base::string16 message_;

chrome/browser/ui/webui/help/version_updater.h

@@ -58,6 +58,7 @@ class VersionUpdater {
   // |progress| should only be non-zero for the UPDATING state.
   // |rollback| indicates whether the update is actually a rollback, which
   //     requires wiping the device upon reboot.
+  // |powerwash| indicates whether the device will be wiped on reboot.
   // |version| is the version of the available update and should be empty string
   //     when update is not available.
   // |update_size| is the size of the available update in bytes and should be 0
@@ -66,6 +67,7 @@ class VersionUpdater {
   typedef base::Callback<void(Status status,
                               int progress,
                               bool rollback,
+                              bool powerwash,
                               const std::string& version,
                               int64_t update_size,
                               const base::string16& message)>

chrome/browser/ui/webui/help/version_updater_basic.cc

@@ -13,7 +13,8 @@ void VersionUpdaterBasic::CheckForUpdate(
   const Status status = UpgradeDetector::GetInstance()->notify_upgrade()
                             ? NEARLY_UPDATED
                             : DISABLED;
-  status_callback.Run(status, 0, false, std::string(), 0, base::string16());
+  status_callback.Run(status, 0, false, false, std::string(), 0,
+                      base::string16());
 }
 
 VersionUpdater* VersionUpdater::Create(content::WebContents* web_contents) {

chrome/browser/ui/webui/help/version_updater_chromeos.cc

@@ -100,7 +100,8 @@ base::string16 GetConnectionTypeAsUTF16(const chromeos::NetworkState* network,
 bool EnsureCanUpdate(bool interactive,
                      const VersionUpdater::StatusCallback& callback) {
   if (IsAutoUpdateDisabled()) {
-    callback.Run(VersionUpdater::DISABLED_BY_ADMIN, 0, false, std::string(), 0,
+    callback.Run(VersionUpdater::DISABLED_BY_ADMIN, 0, false, false,
+                 std::string(), 0,
                  l10n_util::GetStringUTF16(IDS_UPGRADE_DISABLED_BY_POLICY));
     return false;
   }
@@ -114,14 +115,14 @@ bool EnsureCanUpdate(bool interactive,
   // to a network for which updates are disallowed.
   NetworkStatus status = GetNetworkStatus(interactive, network, metered);
   if (status == NETWORK_STATUS_OFFLINE) {
-    callback.Run(VersionUpdater::FAILED_OFFLINE, 0, false, std::string(), 0,
-                 l10n_util::GetStringUTF16(IDS_UPGRADE_OFFLINE));
+    callback.Run(VersionUpdater::FAILED_OFFLINE, 0, false, false, std::string(),
+                 0, l10n_util::GetStringUTF16(IDS_UPGRADE_OFFLINE));
     return false;
   } else if (status == NETWORK_STATUS_DISALLOWED) {
     base::string16 message = l10n_util::GetStringFUTF16(
         IDS_UPGRADE_DISALLOWED, GetConnectionTypeAsUTF16(network, metered));
     callback.Run(VersionUpdater::FAILED_CONNECTION_TYPE_DISALLOWED, 0, false,
-                 std::string(), 0, message);
+                 false, std::string(), 0, message);
     return false;
   }
 
@@ -215,7 +216,7 @@ void VersionUpdaterCros::OnSetUpdateOverCellularOneTimePermission(
     // TODO(https://crbug.com/927452): invoke callback to signal about page to
     // show appropriate error message.
     LOG(ERROR) << "Error setting update over cellular one time permission.";
-    callback_.Run(VersionUpdater::FAILED, 0, false, std::string(), 0,
+    callback_.Run(VersionUpdater::FAILED, 0, false, false, std::string(), 0,
                   base::string16());
   }
 }
@@ -319,8 +320,8 @@ void VersionUpdaterCros::UpdateStatusChanged(
       NOTREACHED();
   }
 
-  callback_.Run(my_status, progress, status.is_enterprise_rollback(), version,
-                size, message);
+  callback_.Run(my_status, progress, status.is_enterprise_rollback(),
+                status.will_powerwash_after_reboot(), version, size, message);
   last_operation_ = status.current_operation();
 
   if (check_for_update_when_idle_ &&
@@ -334,5 +335,5 @@ void VersionUpdaterCros::OnUpdateCheck(
   // If version updating is not implemented, this binary is the most up-to-date
   // possible with respect to automatic updating.
   if (result == UpdateEngineClient::UPDATE_RESULT_NOTIMPLEMENTED)
-    callback_.Run(UPDATED, 0, false, std::string(), 0, base::string16());
+    callback_.Run(UPDATED, 0, false, false, std::string(), 0, base::string16());
 }

chrome/browser/ui/webui/help/version_updater_chromeos_unittest.cc

@@ -33,6 +33,7 @@ namespace {
 void CheckNotification(VersionUpdater::Status /* status */,
                        int /* progress */,
                        bool /* rollback */,
+                       bool /* powerwash */,
                        const std::string& /* version */,
                        int64_t /* size */,
                        const base::string16& /* message */) {}

chrome/browser/ui/webui/help/version_updater_mac.mm

@@ -108,7 +108,7 @@ void VersionUpdaterMac::CheckForUpdate(
   } else {
     // There is no glue, or the application is on a read-only filesystem.
     // Updates and promotions are impossible.
-    status_callback_.Run(DISABLED, 0, false, std::string(), 0,
+    status_callback_.Run(DISABLED, 0, false, false, std::string(), 0,
                          base::string16());
   }
 }
@@ -231,7 +231,7 @@ void VersionUpdaterMac::UpdateStatus(NSDictionary* dictionary) {
   }
 
   if (!status_callback_.is_null())
-    status_callback_.Run(status, 0, false, std::string(), 0, message);
+    status_callback_.Run(status, 0, false, false, std::string(), 0, message);
 
   PromotionState promotion_state;
   if (!promote_callback_.is_null()) {

chrome/browser/ui/webui/help/version_updater_win.cc

@@ -31,7 +31,7 @@ void VersionUpdaterWin::CheckForUpdate(const StatusCallback& callback,
   // There is no supported integration with Google Update for Chromium.
   callback_ = callback;
 
-  callback_.Run(CHECKING, 0, false, std::string(), 0, base::string16());
+  callback_.Run(CHECKING, 0, false, false, std::string(), 0, base::string16());
   DoBeginUpdateCheck(false /* !install_update_if_possible */);
 }
 
@@ -52,18 +52,20 @@ void VersionUpdaterWin::OnUpdateCheckComplete(
 
   // Notify the caller that the update is now beginning and initiate it.
   DoBeginUpdateCheck(true /* install_update_if_possible */);
-  callback_.Run(UPDATING, 0, false, std::string(), 0, base::string16());
+  callback_.Run(UPDATING, 0, false, false, std::string(), 0, base::string16());
 }
 
 void VersionUpdaterWin::OnUpgradeProgress(int progress,
                                           const base::string16& new_version) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  callback_.Run(UPDATING, progress, false, std::string(), 0, base::string16());
+  callback_.Run(UPDATING, progress, false, false, std::string(), 0,
+                base::string16());
 }
 
 void VersionUpdaterWin::OnUpgradeComplete(const base::string16& new_version) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  callback_.Run(NEARLY_UPDATED, 0, false, std::string(), 0, base::string16());
+  callback_.Run(NEARLY_UPDATED, 0, false, false, std::string(), 0,
+                base::string16());
 }
 
 void VersionUpdaterWin::OnError(GoogleUpdateErrorCode error_code,
@@ -94,7 +96,7 @@ void VersionUpdaterWin::OnError(GoogleUpdateErrorCode error_code,
       }
       break;
   }
-  callback_.Run(status, 0, false, std::string(), 0, message);
+  callback_.Run(status, 0, false, false, std::string(), 0, message);
 }
 
 void VersionUpdaterWin::DoBeginUpdateCheck(bool install_update_if_possible) {
@@ -107,7 +109,7 @@ void VersionUpdaterWin::DoBeginUpdateCheck(bool install_update_if_possible) {
 
 void VersionUpdaterWin::OnPendingRestartCheck(bool is_update_pending_restart) {
   callback_.Run(is_update_pending_restart ? NEARLY_UPDATED : UPDATED, 0, false,
-                std::string(), 0, base::string16());
+                false, std::string(), 0, base::string16());
 }
 
 VersionUpdater* VersionUpdater::Create(content::WebContents* web_contents) {

chrome/browser/ui/webui/settings/about_handler.cc

@@ -649,6 +649,7 @@ void AboutHandler::RequestUpdate() {
 void AboutHandler::SetUpdateStatus(VersionUpdater::Status status,
                                    int progress,
                                    bool rollback,
+                                   bool powerwash,
                                    const std::string& version,
                                    int64_t size,
                                    const base::string16& message) {
@@ -660,6 +661,7 @@ void AboutHandler::SetUpdateStatus(VersionUpdater::Status status,
   event->SetString("message", message);
   event->SetInteger("progress", progress);
   event->SetBoolean("rollback", rollback);
+  event->SetBoolean("powerwash", powerwash);
   event->SetString("version", version);
   // DictionaryValue does not support int64_t, so convert to string.
   event->SetString("size", base::NumberToString(size));

chrome/browser/ui/webui/settings/about_handler.h

@@ -135,6 +135,7 @@ class AboutHandler : public settings::SettingsPageUIHandler,
   void SetUpdateStatus(VersionUpdater::Status status,
                        int progress,
                        bool rollback,
+                       bool powerwash,
                        const std::string& version,
                        int64_t size,
                        const base::string16& fail_message);

chrome/browser/ui/webui/settings/safety_check_handler.cc

@@ -569,6 +569,7 @@ void SafetyCheckHandler::DetermineIfNoPasswordsOrSafe(
 void SafetyCheckHandler::OnVersionUpdaterResult(VersionUpdater::Status status,
                                                 int progress,
                                                 bool rollback,
+                                                bool powerwash,
                                                 const std::string& version,
                                                 int64_t update_size,
                                                 const base::string16& message) {

chrome/browser/ui/webui/settings/safety_check_handler.h

@@ -193,6 +193,7 @@ class SafetyCheckHandler
   void OnVersionUpdaterResult(VersionUpdater::Status status,
                               int progress,
                               bool rollback,
+                              bool powerwash,
                               const std::string& version,
                               int64_t update_size,
                               const base::string16& message);

chrome/test/data/webui/settings/chromeos/os_about_page_tests.js

@@ -9,6 +9,8 @@ cr.define('settings_about_page', function() {
      * @param {{
      *   progress: number|undefined,
      *   message: string|undefined
+     *   rollback: bool|undefined
+     *   powerwash: bool|undefined
      * }} opt_options
      */
     function fireStatusChanged(status, opt_options) {
@@ -17,6 +19,8 @@ cr.define('settings_about_page', function() {
         progress: options.progress === undefined ? 1 : options.progress,
         message: options.message,
         status: status,
+        rollback: options.rollback,
+        powerwash: options.powerwash,
       });
     }
 
@@ -155,16 +159,14 @@ cr.define('settings_about_page', function() {
        * channel are the same.
        */
       test('ButtonsUpdate_SameChannel', function() {
-        const {checkForUpdates, relaunch, relaunchAndPowerwash} = page.$;
+        const {checkForUpdates, relaunch} = page.$;
 
         assertTrue(!!relaunch);
-        assertTrue(!!relaunchAndPowerwash);
         assertTrue(!!checkForUpdates);
 
         function assertAllHidden() {
           assertTrue(checkForUpdates.hidden);
           assertTrue(relaunch.hidden);
-          assertTrue(relaunchAndPowerwash.hidden);
           // Ensure that when all buttons are hidden, the container is also
           // hidden.
           assertTrue(page.$.buttonContainer.hidden);
@@ -175,7 +177,6 @@ cr.define('settings_about_page', function() {
         fireStatusChanged(UpdateStatus.UPDATED);
         assertFalse(checkForUpdates.hidden);
         assertTrue(relaunch.hidden);
-        assertTrue(relaunchAndPowerwash.hidden);
 
         // Check that the "Check for updates" button gets hidden for certain
         // UpdateStatus values, even if the CHECKING state was never
@@ -186,7 +187,6 @@ cr.define('settings_about_page', function() {
         fireStatusChanged(UpdateStatus.NEARLY_UPDATED);
         assertTrue(checkForUpdates.hidden);
         assertFalse(relaunch.hidden);
-        assertTrue(relaunchAndPowerwash.hidden);
 
         fireStatusChanged(UpdateStatus.CHECKING);
         assertAllHidden();
@@ -197,7 +197,6 @@ cr.define('settings_about_page', function() {
         fireStatusChanged(UpdateStatus.NEARLY_UPDATED);
         assertTrue(checkForUpdates.hidden);
         assertFalse(relaunch.hidden);
-        assertTrue(relaunchAndPowerwash.hidden);
 
         fireStatusChanged(UpdateStatus.UPDATED);
         assertAllHidden();
@@ -205,7 +204,6 @@ cr.define('settings_about_page', function() {
         fireStatusChanged(UpdateStatus.FAILED);
         assertFalse(checkForUpdates.hidden);
         assertTrue(relaunch.hidden);
-        assertTrue(relaunchAndPowerwash.hidden);
 
         fireStatusChanged(UpdateStatus.DISABLED);
         assertAllHidden();
@@ -217,24 +215,24 @@ cr.define('settings_about_page', function() {
       /**
        * Test that buttons update according to incoming
        * 'update-status-changed' events for the case where the target channel
-       * is more stable than current channel.
+       * is more stable than current channel and update will powerwash.
        */
       test('ButtonsUpdate_BetaToStable', async () => {
         aboutBrowserProxy.setChannels(
             BrowserChannel.BETA, BrowserChannel.STABLE);
-        aboutBrowserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
-
         await initNewPage();
+
+        fireStatusChanged(UpdateStatus.NEARLY_UPDATED, {powerwash: true});
+
         assertTrue(!!page.$.relaunch);
-        assertTrue(!!page.$.relaunchAndPowerwash);
+        assertFalse(page.$.relaunch.hidden);
 
-        assertTrue(page.$.relaunch.hidden);
-        assertFalse(page.$.relaunchAndPowerwash.hidden);
+        assertEquals(
+            page.$.relaunch.innerText,
+            loadTimeData.getString('aboutRelaunchAndPowerwash'));
 
-        page.$.relaunchAndPowerwash.click();
-        const requestTpmFirmwareUpdate =
-            await lifetimeBrowserProxy.whenCalled('factoryReset');
-        assertFalse(requestTpmFirmwareUpdate);
+        page.$.relaunch.click();
+        await lifetimeBrowserProxy.whenCalled('relaunch');
       });
 
       /**
@@ -245,39 +243,38 @@ cr.define('settings_about_page', function() {
       test('ButtonsUpdate_StableToBeta', async () => {
         aboutBrowserProxy.setChannels(
             BrowserChannel.STABLE, BrowserChannel.BETA);
-        aboutBrowserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
-
         await initNewPage();
-        assertTrue(!!page.$.relaunch);
-        assertTrue(!!page.$.relaunchAndPowerwash);
 
+        fireStatusChanged(UpdateStatus.NEARLY_UPDATED, {powerwash: false});
+
+        assertTrue(!!page.$.relaunch);
         assertFalse(page.$.relaunch.hidden);
-        assertTrue(page.$.relaunchAndPowerwash.hidden);
+
+        assertEquals(
+            page.$.relaunch.innerText, loadTimeData.getString('aboutRelaunch'));
 
         page.$.relaunch.click();
         await lifetimeBrowserProxy.whenCalled('relaunch');
       });
 
       /**
-       * Test that buttons update as a result of receiving a
-       * 'target-channel-changed' event (normally fired from
-       * <settings-channel-switcher-dialog>).
+       * The relaunch and powerwash button is shown if the powerwash flag is set
+       * in the update status.
        */
-      test('ButtonsUpdate_TargetChannelChangedEvent', async () => {
-        aboutBrowserProxy.setChannels(BrowserChannel.BETA, BrowserChannel.BETA);
-        aboutBrowserProxy.setUpdateStatus(UpdateStatus.NEARLY_UPDATED);
-
+      test('ButtonsUpdate_Powerwash', async () => {
         await initNewPage();
-        assertFalse(page.$.relaunch.hidden);
-        assertTrue(page.$.relaunchAndPowerwash.hidden);
 
-        page.fire('target-channel-changed', BrowserChannel.DEV);
+        fireStatusChanged(UpdateStatus.NEARLY_UPDATED, {powerwash: true});
+
+        assertTrue(!!page.$.relaunch);
         assertFalse(page.$.relaunch.hidden);
-        assertTrue(page.$.relaunchAndPowerwash.hidden);
 
-        page.fire('target-channel-changed', BrowserChannel.STABLE);
-        assertTrue(page.$.relaunch.hidden);
-        assertFalse(page.$.relaunchAndPowerwash.hidden);
+        assertEquals(
+            page.$.relaunch.innerText,
+            loadTimeData.getString('aboutRelaunchAndPowerwash'));
+
+        page.$.relaunch.click();
+        await lifetimeBrowserProxy.whenCalled('relaunch');
       });
 
       /**