Fixed "Relaunch and Powerwash" button on a chrome://help page.

chrome/browser/resources/help/help_page.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 cr.define('help', function() {
   var Page = cr.ui.pageManager.Page;
   var PageManager = cr.ui.pageManager.PageManager;
 
   /**
    * Encapsulated handling of the About page. Called 'help' internally to avoid
    * confusion with generic AboutUI (about:memory, about:sandbox, etc.).
    */
   function HelpPage() {
     var id = loadTimeData.valueExists('aboutOverlayTabTitle') ?
       'aboutOverlayTabTitle' : 'aboutTitle';
     Page.call(this, 'help', loadTimeData.getString(id), 'help-page');
   }
 
   cr.addSingletonGetter(HelpPage);
 
   HelpPage.prototype = {
     __proto__: Page.prototype,
 
     /**
-     * True if after update powerwash button should be displayed.
-     * @private
-     */
-    powerwashAfterUpdate_: false,
-
-    /**
-     * List of the channel names.
+     * List of the channel names. Should be ordered in increasing level of
+     * stability.
      * @private
      */
     channelList_: ['dev-channel', 'beta-channel', 'stable-channel'],
 
     /**
      * Name of the channel the device is currently on.
      * @private
      */
     currentChannel_: null,
 
     /**
      * Name of the channel the device is supposed to be on.
      * @private
      */
     targetChannel_: null,
 
+    /**
+     * Last status received from the version updater.
+     * @private
+     */
+    status_: null,
+
+    /**
+     * Last message received from the version updater.
+     * @private
+     */
+    message_: null,
+
     /** @override */
     initializePage: function() {
       Page.prototype.initializePage.call(this);
 
       $('product-license').innerHTML = loadTimeData.getString('productLicense');
       if (cr.isChromeOS) {
         $('product-os-license').innerHTML =
             loadTimeData.getString('productOsLicense');
       }
 
@@ skipping 159 matching lines @@
      *     not equal.
      * @private
      */
     channelsDiffer_: function() {
       var current = this.currentChannel_;
       var target = this.targetChannel_;
       return (current != null && target != null && current != target);
     },
 
     /**
+     * @return {boolean} True if target channel is more stable than the current
+     *     one, and false otherwise.
+     * @private
+     */
+    targetChannelIsMoreStable_: function() {
+      var current = this.currentChannel_;
+      var target = this.targetChannel_;
+      if (current == null || target == null)
+        return false;
+      var currentIndex = this.channelList_.indexOf(current);
+      var targetIndex = this.channelList_.indexOf(target);
+      if (currentIndex < 0 || targetIndex < 0)
+        return false;
+      return currentIndex < targetIndex;
+    },
+
+    /**
      * @param {string} status The status of the update.
      * @param {string} message Failure message to display.
      * @private
      */
     setUpdateStatus_: function(status, message) {
+      this.status_ = status;
+      this.message_ = message;
+
+      this.updateUI_();
+    },
+
+    /**
+      * Updates UI elements on the page according to current state.
+      * @private
+      */
+    updateUI_: function() {
+      var status = this.status_;
+      var message = this.message_;
+      var channel = this.targetChannel_;
+
+      if (this.channelList_.indexOf(channel) >= 0) {
+        $('current-channel').textContent = loadTimeData.getStringF(
+            'currentChannel', this.channelTable_[channel].label);
+        this.updateChannelChangePageContainerVisibility_();
+      }
+
+      if (status == null)
+        return;
+
       if (cr.isMac &&
           $('update-status-message') &&
           $('update-status-message').hidden) {
         // Chrome has reached the end of the line on this system. The
         // update-obsolete-system message is displayed. No other auto-update
         // status should be displayed.
         return;
       }
 
-      var channel = this.targetChannel_;
       if (status == 'checking') {
         this.setUpdateImage_('working');
         $('update-status-message').innerHTML =
             loadTimeData.getString('updateCheckStarted');
       } else if (status == 'updating') {
         this.setUpdateImage_('working');
         if (this.channelsDiffer_()) {
           $('update-status-message').innerHTML =
               loadTimeData.getStringF('updatingChannelSwitch',
                                       this.channelTable_[channel].label);
@@ skipping 20 matching lines @@
       }
 
       // Following invariant must be established at the end of this function:
       // { ~$('relaunch_and_powerwash').hidden -> $('relaunch').hidden }
       var relaunchAndPowerwashHidden = true;
       if ($('relaunch-and-powerwash')) {
         // It's allowed to do powerwash only for customer devices,
         // when user explicitly decides to update to a more stable
         // channel.
         relaunchAndPowerwashHidden =
-            !this.powerwashAfterUpdate_ || status != 'nearly_updated';
+            !this.targetChannelIsMoreStable_() || status != 'nearly_updated';
         $('relaunch-and-powerwash').hidden = relaunchAndPowerwashHidden;
       }
 
       if (cr.isChromeOS) {
         // Only enable the update button if it hasn't been used yet or the
         // status isn't 'updated'.
         if (!$('request-update').disabled || status != 'updated') {
           // Disable the button if an update is already in progress.
           $('request-update').disabled =
             ['checking', 'updating', 'nearly_updated'].indexOf(status) > -1;
@@ skipping 107 matching lines @@
      */
     setOSFirmware_: function(firmware) {
       if (!cr.isChromeOS)
         console.error('OS firmware unsupported on non-CrOS');
 
       $('firmware').parentNode.hidden = (firmware == '');
       $('firmware').textContent = firmware;
     },
 
     /**
+     * Updates page UI according to device owhership policy.
+     * @param {boolean} isEnterpriseManaged True if the device is
+     *     enterprise managed.
+     * @private
+     */
+    updateIsEnterpriseManaged_: function(isEnterpriseManaged) {
+      help.ChannelChangePage.updateIsEnterpriseManaged(isEnterpriseManaged);
+      this.updateUI_();
+    },
+
+    /**
      * Updates name of the current channel, i.e. the name of the
      * channel the device is currently on.
      * @param {string} channel The name of the current channel.
      * @private
      */
     updateCurrentChannel_: function(channel) {
       if (this.channelList_.indexOf(channel) < 0)
         return;
-      $('current-channel').textContent = loadTimeData.getStringF(
-          'currentChannel', this.channelTable_[channel].label);
       this.currentChannel_ = channel;
       help.ChannelChangePage.updateCurrentChannel(channel);
+      this.updateUI_();
     },
 
     /**
+     * Updates name of the target channel, i.e. the name of the
+     * channel the device is supposed to be.
+     * @param {string} channel The name of the target channel.
+     * @private
+     */
+    updateTargetChannel_: function(channel) {
+      if (this.channelList_.indexOf(channel) < 0)
+        return;
+      this.targetChannel_ = channel;
+      help.ChannelChangePage.updateTargetChannel(channel);
+      this.updateUI_();
+    },
+
+    /**
      * @param {boolean} enabled True if the release channel can be enabled.
      * @private
      */
     updateEnableReleaseChannel_: function(enabled) {
       this.updateChannelChangerContainerVisibility_(enabled);
       $('change-channel').disabled = !enabled;
       $('channel-change-disallowed-icon').hidden = enabled;
     },
 
     /**
      * Sets the device target channel.
      * @param {string} channel The name of the target channel.
      * @param {boolean} isPowerwashAllowed True iff powerwash is allowed.
      * @private
      */
     setChannel_: function(channel, isPowerwashAllowed) {
-      this.powerwashAfterUpdate_ = isPowerwashAllowed;
-      this.targetChannel_ = channel;
       chrome.send('setChannel', [channel, isPowerwashAllowed]);
       $('channel-change-confirmation').hidden = false;
       $('channel-change-confirmation').textContent = loadTimeData.getStringF(
           'channel-changed', this.channelTable_[channel].name);
+      this.updateTargetChannel_(channel);
     },
 
     /**
      * Sets the value of the "Build Date" field of the "More Info" section.
      * @param {string} buildDate The date of the build.
      * @private
      */
     setBuildDate_: function(buildDate) {
       $('build-date-container').classList.remove('empty');
       $('build-date').textContent = buildDate;
@@ skipping 62 matching lines @@
     HelpPage.getInstance().setOSVersion_(version);
   };
 
   HelpPage.setOSFirmware = function(firmware) {
     HelpPage.getInstance().setOSFirmware_(firmware);
   };
 
   HelpPage.updateIsEnterpriseManaged = function(isEnterpriseManaged) {
     if (!cr.isChromeOS)
       return;
-    help.ChannelChangePage.updateIsEnterpriseManaged(isEnterpriseManaged);
+    HelpPage.getInstance().updateIsEnterpriseManaged_(isEnterpriseManaged);
   };
 
   HelpPage.updateCurrentChannel = function(channel) {
     if (!cr.isChromeOS)
       return;
     HelpPage.getInstance().updateCurrentChannel_(channel);
   };
 
   HelpPage.updateTargetChannel = function(channel) {
     if (!cr.isChromeOS)
       return;
-    help.ChannelChangePage.updateTargetChannel(channel);
+    HelpPage.getInstance().updateTargetChannel_(channel);
   };
 
   HelpPage.updateEnableReleaseChannel = function(enabled) {
     HelpPage.getInstance().updateEnableReleaseChannel_(enabled);
   };
 
   HelpPage.setChannel = function(channel, isPowerwashAllowed) {
     HelpPage.getInstance().setChannel_(channel, isPowerwashAllowed);
   };
 
   HelpPage.setBuildDate = function(buildDate) {
     HelpPage.getInstance().setBuildDate_(buildDate);
   };
 
-  HelpPage.updateChannelChangePageContainerVisibility = function() {
-    HelpPage.getInstance().updateChannelChangePageContainerVisibility_();
-  };
-
   // Export
   return {
     HelpPage: HelpPage
   };
 });