chromeos: Add settings to control power management prefs.

chrome/browser/resources/settings/device_page/power.js

 // Copyright 2017 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.
 
 /**
  * @fileoverview
  * 'settings-power' is the settings subpage for power settings.
  */
 
 Polymer({
   is: 'settings-power',
 
   behaviors: [
     I18nBehavior,
     WebUIListenerBehavior,
   ],
 
   properties: {
     enablePowerSettings: Boolean,
 
     /** @private {string} ID of the selected power source, or ''. */
     selectedPowerSourceId_: String,
 
     /** @private {!settings.BatteryStatus|undefined} */
     batteryStatus_: Object,
 
     /** @private {boolean} Whether a low-power (USB) charger is being used. */
     lowPowerCharger_: Boolean,
 
+    /** @private {boolean} Whether the idle behavior is managed. */
+    idleManaged_: Boolean,
+
+    /** @private {boolean} Whether the lid-closed behavior is managed. */
+    lidClosedManaged_: Boolean,
+
+    /** @private {boolean} Whether the system posesses a lid. */
+    hasLid_: Boolean,
+
     /**
      * List of available dual-role power sources, if enablePowerSettings is on.
      * @private {!Array<!settings.PowerSource>|undefined}
      */
     powerSources_: Array,
 
     /** @private */
     powerSourceLabel_: {
       type: String,
       computed:
           'computePowerSourceLabel_(powerSources_, batteryStatus_.calculating)',
     },
 
     /** @private */
     showPowerSourceDropdown_: {
       type: Boolean,
       computed: 'computeShowPowerSourceDropdown_(powerSources_)',
       value: false,
     },
 
     /**
      * The name of the dedicated charging device being used, if present.
      * @private {string}
      */
     powerSourceName_: {
       type: String,
       computed: 'computePowerSourceName_(powerSources_, lowPowerCharger_)',
     },
+
+    /** @private */
+    idleOptions_: {
+      type: Array,
+      computed: 'computeIdleOptions_(idleManaged_)',
+    },
+
+    /** @private */
+    lidClosedOptions_: {
+      type: Array,
+      computed: 'computeLidClosedOptions_(lidClosedManaged_)',
+    },
   },
 
   /** @override */
   ready: function() {
     // enablePowerSettings comes from loadTimeData, so it will always be set
     // before attached() is called.
     if (!this.enablePowerSettings)
       settings.navigateToPreviousRoute();
   },
 
   /** @override */
   attached: function() {
     this.addWebUIListener(
         'battery-status-changed', this.set.bind(this, 'batteryStatus_'));
     this.addWebUIListener(
         'power-sources-changed', this.powerSourcesChanged_.bind(this));
     settings.DevicePageBrowserProxyImpl.getInstance().updatePowerStatus();
+
+    this.addWebUIListener(
+        'power-management-settings-changed',
+        this.powerManagementSettingsChanged_.bind(this));
+    settings.DevicePageBrowserProxyImpl.getInstance()
+        .requestPowerManagementSettings();
   },
 
   /**
    * @param {!Array<!settings.PowerSource>|undefined} powerSources
    * @param {boolean} calculating
    * @return {string} The primary label for the power source row.
    * @private
    */
   computePowerSourceLabel_: function(powerSources, calculating) {
     return this.i18n(
@@ skipping 21 matching lines @@
    * @private
    */
   computePowerSourceName_: function(powerSources, lowPowerCharger) {
     if (lowPowerCharger)
       return this.i18n('powerSourceLowPowerCharger');
     if (powerSources.length)
       return this.i18n('powerSourceAcAdapter');
     return '';
   },
 
-  onPowerSourceChange_: function() {
-    settings.DevicePageBrowserProxyImpl.getInstance().setPowerSource(
-        this.$$('#powerSource').value);
+  /**
+   * @param {boolean} idleManaged
+   * @return {!Array<!{value: settings.IdleBehavior, name: string}>} Options to
+   *     display in idle-behavior select.
+   * @private
+   */
+  computeIdleOptions_: function(idleManaged) {
+    var options = [
+      {
+        value: settings.IdleBehavior.DISPLAY_OFF_SLEEP,
+        name: loadTimeData.getString('powerIdleDisplayOffSleep'),
+      },
+      {
+        value: settings.IdleBehavior.DISPLAY_OFF_STAY_AWAKE,
+        name: loadTimeData.getString('powerIdleDisplayOffStayAwake'),
+      },
+      {
+        value: settings.IdleBehavior.DISPLAY_ON,
+        name: loadTimeData.getString('powerIdleDisplayOn'),
+      },
+    ];
+    if (idleManaged) {
+      options.push({
+        value: settings.IdleBehavior.OTHER,
+        name: loadTimeData.getString('powerIdleOther'),
+      });
+    }
+    return options;
   },
 
   /**
+   * @param {boolean} lidClosedManaged
+   * @return {!Array<!{value: settings.LidClosedBehavior, name: string}>}
+   *     Options to display in lid-closed-behavior select.
+   * @private
+   */
+  computeLidClosedOptions_: function(lidClosedManaged) {
+    var options = [
+      {
+        value: settings.LidClosedBehavior.SUSPEND,
+        name: loadTimeData.getString('powerLidClosedSleep'),
+      },
+      {
+        value: settings.LidClosedBehavior.DO_NOTHING,
+        name: loadTimeData.getString('powerLidClosedStayAwake'),
+      },
+    ];
+    if (lidClosedManaged) {
+      // Some options are only settable via policy.
+      options.push({
+        value: settings.LidClosedBehavior.STOP_SESSION,
+        name: loadTimeData.getString('powerLidClosedSignOut'),
+      }, {
+        value: settings.LidClosedBehavior.SHUT_DOWN,
+        name: loadTimeData.getString('powerLidClosedShutDown'),
+      });
+    }
+    return options;
+  },
+
+  /** @private */
+  onPowerSourceChange_: function() {
+    settings.DevicePageBrowserProxyImpl.getInstance().setPowerSource(
+        this.$.powerSource.value);
+  },
+
+  /** @private */
+  onIdleSelectChange_: function() {
+    var behavior = /** @type {settings.IdleBehavior} */
+        (parseInt(this.$.idleSelect.value, 10));
+    settings.DevicePageBrowserProxyImpl.getInstance().setIdleBehavior(behavior);
+  },
+
+  /** @private */
+  onLidClosedSelectChange_: function() {
+    var behavior = /** @type {settings.LidClosedBehavior} */
+        (parseInt(this.$.lidClosedSelect.value, 10));
+    settings.DevicePageBrowserProxyImpl.getInstance().setLidClosedBehavior(
+        behavior);
+  },
+
+  /**
    * @param {!Array<settings.PowerSource>} sources External power sources.
    * @param {string} selectedId The ID of the currently used power source.
    * @param {boolean} lowPowerCharger Whether the currently used power source
    *     is a low-powered USB charger.
    * @private
    */
   powerSourcesChanged_: function(sources, selectedId, lowPowerCharger) {
     this.powerSources_ = sources;
     this.selectedPowerSourceId_ = selectedId;
     this.lowPowerCharger_ = lowPowerCharger;
   },
 
   /**
+   * @param {!settings.PowerManagementSettings} settings Current power
+   *     management settings.
+   * @private
+   */
+  powerManagementSettingsChanged_: function(settings) {
+    this.idleManaged_ = settings.idleManaged;
+    this.lidClosedManaged_ = settings.lidClosedManaged;
+    this.hasLid_ = settings.hasLid;
+
+    // The select elements include "Other" options when managed but omit them
+    // otherwise. Make sure that the options are there before we potentially try
+    // to select them.
+    Polymer.dom.flush();

[michaelpg, 2017/06/16 01:35:00]

use this.async(function() {...}); instead of forcing the flush, because forcing
the flush could force a bunch of other updates we don't want to block on

[Daniel Erat, 2017/06/16 02:34:24]

hmm. i had this.async earlier (after you suggested it, i think), but it doesn't
seem to get along well with the tests that i added. here's what i see after
using async() here and flushing in the test; it looks like the function passed
to async() isn't running before the subsequent assertions:

[4693:4693:0615/203055.092960:ERROR:web_ui_test_handler.cc(77)] Failed:
RUN_TEST_F("CrSettingsDevicePageTest","PowerTest")
AssertionError: expected '0' to equal '2'
    at Function.assert.strictEqual (chai.js:2277:32)
    at assertEquals (test_api.js:892:17)
    at test_api.js:1019:20
    at Context.<anonymous> (device_page_tests.js:803:11)
    at callFn (mocha.js:4471:21)
    at Test.Runnable.run (mocha.js:4464:7)
    at Runner.runTest (mocha.js:4934:10)
    at mocha.js:5040:12
    at next (mocha.js:4854:14)
    at mocha.js:4864:7Failed: RUN_TEST_F("CrSettingsDevicePageTest","PowerTest")
AssertionError: expected '0' to equal '3'
    at Function.assert.strictEqual (chai.js:2277:32)
    at assertEquals (test_api.js:892:17)
    at test_api.js:1019:20
    at Context.<anonymous> (device_page_tests.js:807:11)
    at callFn (mocha.js:4471:21)
    at Test.Runnable.run (mocha.js:4464:7)
    at Runner.runTest (mocha.js:4934:10)
    at mocha.js:5040:12
    at next (mocha.js:4854:14)
    at mocha.js:4864:7Failed: RUN_TEST_F("CrSettingsDevicePageTest","PowerTest")
AssertionError: expected '0' to equal '1'
    at Function.assert.strictEqual (chai.js:2277:32)
    at assertEquals (test_api.js:892:17)
    at test_api.js:1019:20
    at Context.<anonymous> (device_page_tests.js:817:11)
    at callFn (mocha.js:4471:21)
    at Test.Runnable.run (mocha.js:4464:7)
    at Runner.runTest (mocha.js:4934:10)
    at mocha.js:5040:12
    at next (mocha.js:4854:14)
    at mocha.js:4864:7Failed: RUN_TEST_F("CrSettingsDevicePageTest","PowerTest")
AssertionError: expected '0' to equal '3'
    at Function.assert.strictEqual (chai.js:2277:32)
    at assertEquals (test_api.js:892:17)
    at test_api.js:1019:20
    at Context.<anonymous> (device_page_tests.js:834:11)
    at callFn (mocha.js:4471:21)
    at Test.Runnable.run (mocha.js:4464:7)
    at Runner.runTest (mocha.js:4934:10)
    at mocha.js:5040:12
    at next (mocha.js:4854:14)
    at mocha.js:4864:7Failed: RUN_TEST_F("CrSettingsDevicePageTest","PowerTest")
AssertionError: expected null to not equal null
    at Function.assert.notStrictEqual (chai.js:2295:36)
    at assertNotEquals (test_api.js:932:17)
    at test_api.js:1019:20
    at Context.<anonymous> (device_page_tests.js:837:11)
    at callFn (mocha.js:4471:21)
    at Test.Runnable.run (mocha.js:4464:7)
    at Runner.runTest (mocha.js:4934:10)
    at mocha.js:5040:12
    at next (mocha.js:4854:14)
    at mocha.js:4864:7
gen/chrome/test/data/webui/settings/cr_settings_browsertest-gen.cc:1706: Failure
Value of: RunJavascriptTestF( true, "CrSettingsDevicePageTest", "PowerTest")
  Actual: false
Expected: true

i've seen some async() calls with non-zero delays in test code, but that feels
pretty hacky.

+    this.$.idleSelect.value = settings.idleBehavior;
+    this.$.lidClosedSelect.value = settings.lidClosedBehavior;
+  },
+
+  /**
    * @param {*} lhs
    * @param {*} rhs
    * @return {boolean}
    * @private
    */
   isEqual_: function(lhs, rhs) {
     return lhs === rhs;
   },
 });