chromeos: Add settings to control power management prefs.

chrome/test/data/webui/settings/device_page_tests.js

 // Copyright 2016 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('device_page_tests', function() {
   /** @enum {string} */
   var TestNames = {
     DevicePage: 'device page',
     Display: 'display',
     Keyboard: 'keyboard',
     Pointers: 'pointers',
     Power: 'power',
     Stylus: 'stylus',
   };
 
   /**
    * @constructor
    * @implements {settings.DevicePageBrowserProxy}
    */
   function TestDevicePageBrowserProxy() {
     this.keyboardShortcutsOverlayShown_ = 0;
     this.updatePowerStatusCalled_ = 0;
+    this.requestPowerManagementSettingsCalled_ = 0;
     this.onNoteTakingAppsUpdated_ = null;
     this.requestNoteTakingApps_ = 0;
     this.setPreferredNoteTakingApp_ = '';
   }
 
   TestDevicePageBrowserProxy.prototype = {
     /** override */
     initializePointers: function() {
       // Enable mouse and touchpad.
       cr.webUIListenerCallback('has-mouse-changed', true);
@@ skipping 26 matching lines @@
     updatePowerStatus: function() {
       this.updatePowerStatusCalled_++;
     },
 
     /** @override */
     setPowerSource: function(powerSourceId) {
       this.powerSourceId_ = powerSourceId;
     },
 
     /** @override */
+    requestPowerManagementSettings: function() {
+      this.requestPowerManagementSettingsCalled_++;
+    },
+
+    /** @override */
+    setIdleBehavior: function(behavior) {
+      this.idleBehavior_ = behavior;
+    },
+
+    /** @override */
+    setLidClosedBehavior: function(behavior) {
+      this.lidClosedBehavior_ = behavior;
+    },
+
+    /** @override */
     setNoteTakingAppsUpdatedCallback: function(callback) {
       this.onNoteTakingAppsUpdated_ = callback;
     },
 
     /** @override */
     requestNoteTakingApps: function() {
       this.requestNoteTakingApps_++;
     },
 
     /** @override */
@@ skipping 156 matching lines @@
             'neon-animation-finish', resolve);
         MockInteractions.tap(row);
       }).then(function() {
         assertEquals(expectedRoute, settings.getCurrentRoute());
         var page = devicePage.$$('settings-' + subpage);
         return assert(page);
       });
     };
 
     /**
+     * @param {settings.IdleBehavior} idleBehavior
+     * @param {boolean} idleManaged
+     * @param {settings.LidClosedBehavior} lidClosedBehavior
+     * @param {boolean} lidClosedManaged
+     * @param {boolean} hasLid
+     */
+    function sendPowerManagementSettings(idleBehavior, idleManaged,
+                                         lidClosedBehavior, lidClosedManaged,
+                                         hasLid) {
+      cr.webUIListenerCallback(
+          'power-management-settings-changed',
+          {
+            idleBehavior: idleBehavior,
+            idleManaged: idleManaged,
+            lidClosedBehavior: lidClosedBehavior,
+            lidClosedManaged: lidClosedManaged,
+            hasLid: hasLid,
+          });

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

after changing the handler to this.async (prior comment), add a
Polymer.dom.flush here, or use Polymer.dom.flush after calling from test methods

+    };
+
+    /**
      * @param {!HTMLElement} pointersPage
      * @param {boolean} expected
      */
     function expectNaturalScrollValue(pointersPage, expected) {
       var naturalScrollOff =
           pointersPage.$$('paper-radio-button[name="false"]');
       var naturalScrollOn =
           pointersPage.$$('paper-radio-button[name="true"]');
       assertTrue(!!naturalScrollOff);
       assertTrue(!!naturalScrollOn);
@@ skipping 331 matching lines @@
        */
       function setPowerSources(sources, powerSourceId, isLowPowerCharger) {
         var sourcesCopy = sources.map(function(source) {
           return Object.assign({}, source);
         });
         cr.webUIListenerCallback('power-sources-changed',
             sourcesCopy, powerSourceId, isLowPowerCharger);
       }
 
       suite('no power settings', function() {
+        suiteSetup(function() {
+          // Never show power settings.
+          loadTimeData.overrideValues({
+            enablePowerSettings: false,
+          });
+        });
+
         test('power row hidden', function() {
           assertEquals(null, devicePage.$$('#powerRow'));
           assertEquals(0,
               settings.DevicePageBrowserProxyImpl.getInstance()
               .updatePowerStatusCalled_);
         });
       });
 
       suite('power settings', function() {
         var powerPage;
         var powerSourceRow;
         var powerSourceWrapper;
         var powerSourceSelect;
+        var idleSelect;
+        var lidClosedSelect;
 
         suiteSetup(function() {
           // Always show power settings.
           loadTimeData.overrideValues({
             enablePowerSettings: true,
           });
         });
 
         setup(function() {
           return showAndGetDeviceSubpage('power', settings.Route.POWER)
               .then(function(page) {
                 powerPage = page;
                 powerSourceRow = assert(powerPage.$$('#powerSourceRow'));
                 powerSourceWrapper =
                     assert(powerSourceRow.querySelector('.md-select-wrapper'));
                 powerSourceSelect = assert(powerPage.$$('#powerSource'));
                 assertEquals(
                     1,
                     settings.DevicePageBrowserProxyImpl.getInstance()
                         .updatePowerStatusCalled_);
+
+                idleSelect = assert(powerPage.$$('#idleSelect'));
+                lidClosedSelect = assert(powerPage.$$('#lidClosedSelect'));
+
+                assertEquals(
+                    1,
+                    settings.DevicePageBrowserProxyImpl.getInstance()
+                    .requestPowerManagementSettingsCalled_);

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

nit: make this not private (no underscore), or add a getter. But I see you're
using an existing pattern sooo meh.

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

Acknowledged.

+                sendPowerManagementSettings(
+                    settings.IdleBehavior.DISPLAY_OFF_SLEEP, false,

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

nit: add comments for parameter names for these bools as in the c++ unit test

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

Done.

+                    settings.LidClosedBehavior.SUSPEND, false, true);
               });
         });
 
         test('power sources', function() {
           var batteryStatus = {
             charging: false,
             calculating: false,
             percent: 50,
             statusText: '5 hours left',
           };
@@ skipping 54 matching lines @@
           Polymer.dom.flush();
 
           // Select the device.
           powerSourceSelect.value = powerSourceSelect.children[1].value;
           powerSourceSelect.dispatchEvent(new CustomEvent('change'));
           Polymer.dom.flush();
           expectEquals(
               powerSource.id,
               settings.DevicePageBrowserProxyImpl.getInstance().powerSourceId_);
         });
+
+        test('set idle behavior', function() {
+          idleSelect.value = settings.IdleBehavior.DISPLAY_ON;
+          idleSelect.dispatchEvent(new CustomEvent('change'));

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

maybe make a helper function selectValue(selectId, value)

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

Done.

+          Polymer.dom.flush();
+          expectEquals(
+              settings.IdleBehavior.DISPLAY_ON,
+              settings.DevicePageBrowserProxyImpl.getInstance().idleBehavior_);
+
+          idleSelect.value = settings.IdleBehavior.DISPLAY_OFF_STAY_AWAKE;
+          idleSelect.dispatchEvent(new CustomEvent('change'));
+          Polymer.dom.flush();
+          expectEquals(
+              settings.IdleBehavior.DISPLAY_OFF_STAY_AWAKE,
+              settings.DevicePageBrowserProxyImpl.getInstance().idleBehavior_);
+        });
+
+        test('set lid behavior', function() {
+          lidClosedSelect.value = settings.LidClosedBehavior.DO_NOTHING;
+          lidClosedSelect.dispatchEvent(new CustomEvent('change'));
+          Polymer.dom.flush();
+          expectEquals(
+              settings.LidClosedBehavior.DO_NOTHING,
+              settings.DevicePageBrowserProxyImpl.getInstance()
+                  .lidClosedBehavior_);
+
+          lidClosedSelect.value = settings.LidClosedBehavior.SUSPEND;
+          lidClosedSelect.dispatchEvent(new CustomEvent('change'));
+          Polymer.dom.flush();
+          expectEquals(
+              settings.LidClosedBehavior.SUSPEND,
+              settings.DevicePageBrowserProxyImpl.getInstance()
+                  .lidClosedBehavior_);
+        });
+
+        test('display idle and lid behavior', function() {
+          sendPowerManagementSettings(
+              settings.IdleBehavior.DISPLAY_ON, false,
+              settings.LidClosedBehavior.DO_NOTHING, false, true);
+          expectEquals(
+              settings.IdleBehavior.DISPLAY_ON.toString(), idleSelect.value);
+          expectFalse(idleSelect.disabled);
+          expectEquals(null, powerPage.$$('#idleManagedIndicator'));
+          expectEquals(
+              settings.LidClosedBehavior.DO_NOTHING.toString(),
+              lidClosedSelect.value);
+          expectFalse(lidClosedSelect.disabled);
+          expectEquals(null, powerPage.$$('#lidClosedManagedIndicator'));
+
+          sendPowerManagementSettings(
+              settings.IdleBehavior.DISPLAY_OFF_STAY_AWAKE, false,
+              settings.LidClosedBehavior.SUSPEND, false, true);
+          expectEquals(
+              settings.IdleBehavior.DISPLAY_OFF_STAY_AWAKE.toString(),
+              idleSelect.value);
+          expectFalse(idleSelect.disabled);
+          expectEquals(null, powerPage.$$('#idleManagedIndicator'));
+          expectEquals(
+              settings.LidClosedBehavior.SUSPEND.toString(),
+              lidClosedSelect.value);
+          expectFalse(lidClosedSelect.disabled);
+          expectEquals(null, powerPage.$$('#lidClosedManagedIndicator'));
+
+          // When settings are managed, the selects should be disabled and the
+          // indicators should be shown.
+          sendPowerManagementSettings(
+              settings.IdleBehavior.OTHER, true,
+              settings.LidClosedBehavior.SUSPEND, true, true);
+          expectEquals(
+              settings.IdleBehavior.OTHER.toString(), idleSelect.value);
+          expectTrue(idleSelect.disabled);
+          expectTrue(powerPage.$$('#idleManagedIndicator') != null);

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

expectNotEquals (or often we just expectTrue(!!foo))

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

Done.

+          expectEquals(
+              settings.LidClosedBehavior.SUSPEND.toString(),
+              lidClosedSelect.value);
+          expectTrue(lidClosedSelect.disabled);
+          expectTrue(powerPage.$$('#lidClosedManagedIndicator') != null);
+        });
       });
     });
 
     suite(assert(TestNames.Stylus), function() {
       var stylusPage;
       var appSelector;
       var browserProxy;
       var noAppsDiv;
       var waitingDiv;
       var selectAppDiv;
@@ skipping 264 matching lines @@
                   .value);
         });
       });
     });
   });
 
   return {
     TestNames: TestNames
   };
 });