ChromeOS: implement per-user time zone preferences.

chrome/test/data/webui/settings/date_time_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.
 
 (function() {
   function getFakePrefs() {
     return {
       cros: {
         system: {
           timezone: {
             key: 'cros.system.timezone',
             type: chrome.settingsPrivate.PrefType.STRING,
             value: 'Westeros/Kings_Landing',
           },
         },
+        flags: {
+          per_user_timezone_enabled: {

[michaelpg, 2017/05/30 22:21:23]

what is this?

[Alexander Alekseev, 2017/07/06 06:30:29]

This flag is generated in
chrome/browser/chromeos/settings/system_settings_provider.cc

(I don't understand why this file is not in this patchset, but it is included in
the last one.)

Also I don't know how to run all the tests here for both values of this flag,
but at least I tested that it works manually. ;)

[michaelpg, 2017/07/10 19:29:37]

that's not a bad idea though. add a TODO here to run the tests once for each
value, and I'll follow up later with you and dpapad about it later.

[Alexander Alekseev, 2017/07/14 03:32:46]

Done.

+            key: 'cros.flags.per_user_timezone_enabled',
+            type: chrome.settingsPrivate.PrefType.BOOLEAN,
+            value: true,
+          },
+        },
       },
       settings: {
         clock: {
           use_24hour_clock: {
             key: 'settings.clock.use_24hour_clock',
             type: chrome.settingsPrivate.PrefType.BOOLEAN,
             value: false,
           },
         },
         resolve_timezone_by_geolocation: {
           key: 'settings.resolve_timezone_by_geolocation',
           type: chrome.settingsPrivate.PrefType.BOOLEAN,
           value: true,
         },
+        timezone: {
+          key: 'settings.timezone',
+          type: chrome.settingsPrivate.PrefType.STRING,
+          value: 'Westeros/Kings_Landing',
+        },
       },
     };
   }
 
+  function updatePrefsWithPolicy(prefs, managed, valueFromPolicy) {
+    var prefsCopy = JSON.parse(JSON.stringify(prefs));
+    if (managed) {
+      prefsCopy.settings.resolve_timezone_by_geolocation.controlledBy =
+          'USER_POLICY';

[michaelpg, 2017/05/30 22:21:24]

chrome.settingsPrivate.ControlledBy.USER_POLICY, etc.

[Alexander Alekseev, 2017/07/06 06:30:29]

Done.

+      prefsCopy.settings.resolve_timezone_by_geolocation.enforcement =
+          'ENFORCED';
+      prefsCopy.settings.resolve_timezone_by_geolocation.value =
+          valueFromPolicy;
+      prefsCopy.settings.timezone.controlledBy = 'USER_POLICY';
+      prefsCopy.settings.timezone.enforcement = 'ENFORCED';
+    } else {
+      prefsCopy.settings.resolve_timezone_by_geolocation.controlledBy =
+          undefined;
+      prefsCopy.settings.resolve_timezone_by_geolocation.enforcement =
+          undefined;
+      // Auto-resolve defaults to true.
+      prefsCopy.settings.resolve_timezone_by_geolocation.value = true;
+      prefsCopy.settings.timezone.controlledBy = undefined;
+      prefsCopy.settings.timezone.enforcement = undefined;
+    }
+    return prefsCopy;
+  }
+
   /**
    * Sets up fakes and creates the date time element.
    * @param {!Object} prefs
    * @param {boolean} hasPolicy
    * @param {boolean=} opt_autoDetectPolicyValue
    * @return {!SettingsDateTimePage}
    */
   function initializeDateTime(prefs, hasPolicy, opt_autoDetectPolicyValue) {
     // Find the desired initial time zone by ID.
     var timeZone = assert(fakeTimeZones.find(function(timeZonePair) {
       return timeZonePair[0] == prefs.cros.system.timezone.value;
     }));
 
     var data = {
       timeZoneID: timeZone[0],
       timeZoneName: timeZone[1],
       controlledSettingPolicy: 'This setting is enforced by your administrator',
     };
 
     if (hasPolicy)
       data.timeZoneAutoDetectValueFromPolicy = opt_autoDetectPolicyValue;
 
     window.loadTimeData = new LoadTimeData;
     loadTimeData.data = data;
 
     var dateTime = document.createElement('settings-date-time-page');
-    dateTime.prefs = prefs;
+    dateTime.prefs =
+        updatePrefsWithPolicy(prefs, hasPolicy, opt_autoDetectPolicyValue);
     CrSettingsPrefs.setInitialized();
 
     document.body.appendChild(dateTime);
+    cr.webUIListenerCallback(
+        'time-zone-auto-detect-policy', hasPolicy, opt_autoDetectPolicyValue);
     return dateTime;
   }
 
   // CrOS sends time zones as [id, friendly name] pairs.
   var fakeTimeZones = [
     ['Westeros/Highgarden', '(KNG-2:00) The Reach Time (Highgarden)'],
     ['Westeros/Winterfell', '(KNG-1:00) The North Time (Winterfell)'],
     ['Westeros/Kings_Landing',
      '(KNG+0:00) Westeros Standard Time (King\'s Landing)'],
     ['Westeros/TheEyrie', '(KNG+1:00) The Vale Time (The Eyrie)'],
@@ skipping 29 matching lines @@
       });
     });
 
     suiteTeardown(function() {
       // TODO(michaelpg): Removes the element before exiting, because the
       // <paper-tooltip> in <cr-policy-indicator> somehow causes warnings
       // and/or script errors in axs_testing.js.
       PolymerTest.clearBody();
     });
 
-    function verifyAutoDetectSetting(autoDetect) {
-      assertEquals(autoDetect, dateTime.$$('settings-dropdown-menu').disabled);
-      assertEquals(autoDetect, dateTime.$.timeZoneAutoDetect.checked);
+    function verifyAutoDetectSetting(autoDetect, managed) {
+      Polymer.dom.flush();
+      var selector = dateTime.$$('#userTimeZoneSelector');
+      var selectorHidden = selector ? selector.hidden : true;
+      assertEquals(managed || autoDetect, selectorHidden);
+
+      var checkButton = dateTime.$$('#timeZoneAutoDetect');
+      var checkButtonChecked = checkButton ? checkButton.checked : false;
+      if (!managed)
+        assertEquals(autoDetect, checkButtonChecked);
     }
 
     function verifyPolicy(policy) {
       Polymer.dom.flush();
-      var indicator = dateTime.$$('cr-policy-indicator');
+      var indicator =
+          dateTime.$$('#timeZoneAutoDetect').$$('cr-policy-pref-indicator');
+      if (indicator && indicator.style.display == 'none')
+        indicator = null;
 
       if (policy) {
         assertTrue(!!indicator);
         assertTrue(indicator.indicatorVisible);
       } else {
         // Indicator should be missing dom-ifed out.
         assertFalse(!!indicator);
       }
 
-      assertEquals(policy, dateTime.$.timeZoneAutoDetect.disabled);
+      assertEquals(
+          policy, dateTime.$$('#timeZoneAutoDetect').$$('#control').disabled);
     }
 
     function verifyTimeZonesPopulated(populated) {
-      var dropdown = dateTime.$$('settings-dropdown-menu');
+      Polymer.dom.flush();
+      var userTimezoneDropdown = dateTime.$$('#userTimeZoneSelector');
+      var systemTimezoneDropdown = dateTime.$$('#systemTimezoneSelector');
+
+      var dropdown =
+          userTimezoneDropdown ? userTimezoneDropdown : systemTimezoneDropdown;
       if (populated)
         assertEquals(fakeTimeZones.length, dropdown.menuOptions.length);
       else
         assertEquals(1, dropdown.menuOptions.length);
     }
 
+    function updatePolicy(dateTime, managed, valueFromPolicy) {
+      dateTime.prefs =
+          updatePrefsWithPolicy(dateTime.prefs, managed, valueFromPolicy);
+      cr.webUIListenerCallback(
+          'time-zone-auto-detect-policy', managed, valueFromPolicy);
+      Polymer.dom.flush();
+    }
+
     test('auto-detect on', function(done) {
       var prefs = getFakePrefs();
       dateTime = initializeDateTime(prefs, false);
 
       assertTrue(dateTimePageReadyCalled);
       assertFalse(getTimeZonesCalled);
 
-      verifyAutoDetectSetting(true);
+      verifyAutoDetectSetting(true, false);
       verifyTimeZonesPopulated(false);
       verifyPolicy(false);
 
       // Disable auto-detect.
-      MockInteractions.tap(dateTime.$.timeZoneAutoDetect);
-      verifyAutoDetectSetting(false);
+      MockInteractions.tap(dateTime.$$('#timeZoneAutoDetect').$$('#control'));
+      verifyAutoDetectSetting(false, false);
       assertTrue(getTimeZonesCalled);
 
       setTimeout(function() {
         verifyTimeZonesPopulated(true);
         done();
       });
     });
 
     test('auto-detect off', function(done) {
-      var prefs = getFakePrefs();
-      prefs.settings.resolve_timezone_by_geolocation.value = false;
-      dateTime = initializeDateTime(prefs, false);
-      cr.webUIListenerCallback('time-zone-auto-detect-policy', false);
+      dateTime = initializeDateTime(getFakePrefs(), false);
+      dateTime.set(
+          'prefs.settings.resolve_timezone_by_geolocation.value', false);
 
       assertTrue(dateTimePageReadyCalled);
       assertTrue(getTimeZonesCalled);
 
-      verifyAutoDetectSetting(false);
+      verifyAutoDetectSetting(false, false);
       verifyPolicy(false);
 
       setTimeout(function() {
         verifyTimeZonesPopulated(true);
 
         // Enable auto-detect.
-        MockInteractions.tap(dateTime.$.timeZoneAutoDetect);
+        MockInteractions.tap(dateTime.$$('#timeZoneAutoDetect').$$('#control'));
         verifyAutoDetectSetting(true);
         done();
       });
     });
 
     test('auto-detect forced on', function(done) {
       var prefs = getFakePrefs();
-      prefs.settings.resolve_timezone_by_geolocation.value = false;
       dateTime = initializeDateTime(prefs, true, true);
-      cr.webUIListenerCallback('time-zone-auto-detect-policy', true, true);
+      dateTime.set(
+          'prefs.settings.resolve_timezone_by_geolocation.value', false);
 
       assertTrue(dateTimePageReadyCalled);
       assertFalse(getTimeZonesCalled);
 
-      verifyAutoDetectSetting(true);
+      verifyAutoDetectSetting(true, true);
       verifyTimeZonesPopulated(false);
       verifyPolicy(true);
 
       // Cannot disable auto-detect.
-      MockInteractions.tap(dateTime.$.timeZoneAutoDetect);
-      verifyAutoDetectSetting(true);
+      MockInteractions.tap(dateTime.$$('#timeZoneAutoDetect').$$('#control'));
+      verifyAutoDetectSetting(true, true);
       assertFalse(getTimeZonesCalled);
 
       // Update the policy: force auto-detect off.
-      cr.webUIListenerCallback('time-zone-auto-detect-policy', true, false);
-      verifyAutoDetectSetting(false);
+      updatePolicy(dateTime, true, false);
+      verifyAutoDetectSetting(false, true);
       verifyPolicy(true);
 
       assertTrue(getTimeZonesCalled);
       setTimeout(function() {
         verifyTimeZonesPopulated(true);
         done();
       });
     });
 
     test('auto-detect forced off', function(done) {
       var prefs = getFakePrefs();
       dateTime = initializeDateTime(prefs, true, false);
-      cr.webUIListenerCallback('time-zone-auto-detect-policy', true, false);
 
       assertTrue(dateTimePageReadyCalled);
       assertTrue(getTimeZonesCalled);
 
-      verifyAutoDetectSetting(false);
+      verifyAutoDetectSetting(false, true);
       verifyPolicy(true);
 
       setTimeout(function() {
         verifyTimeZonesPopulated(true);
 
         // Remove the policy so user's preference takes effect.
-        cr.webUIListenerCallback('time-zone-auto-detect-policy', false);
-        verifyAutoDetectSetting(true);
+        updatePolicy(dateTime, false);
+        verifyAutoDetectSetting(true, false);
         verifyPolicy(false);
 
         // User can disable auto-detect.
-        MockInteractions.tap(dateTime.$.timeZoneAutoDetect);
-        verifyAutoDetectSetting(false);
+        MockInteractions.tap(dateTime.$$('#timeZoneAutoDetect').$$('#control'));
+        verifyAutoDetectSetting(false, false);
         done();
       });
     });
 
     test('set date and time button', function() {
       dateTime = initializeDateTime(getFakePrefs(), false);
-      cr.webUIListenerCallback('time-zone-auto-detect-policy', false);
 
       var showSetDateTimeUICalled = false;
       registerMessageCallback('showSetDateTimeUI', null, function() {
         assertFalse(showSetDateTimeUICalled);
         showSetDateTimeUICalled = true;
       });
 
-      var setDateTimeButton = dateTime.$.setDateTime;
+      var setDateTimeButton = dateTime.$$('#setDateTime');
       assertEquals(0, setDateTimeButton.offsetHeight);
 
       // Make the date and time editable.
       cr.webUIListenerCallback('can-set-date-time-changed', true);
       assertGT(setDateTimeButton.offsetHeight, 0);
 
       assertFalse(showSetDateTimeUICalled);
       MockInteractions.tap(setDateTimeButton);
       assertTrue(showSetDateTimeUICalled);
 
       // Make the date and time not editable.
       cr.webUIListenerCallback('can-set-date-time-changed', false);
       assertEquals(setDateTimeButton.offsetHeight, 0);
     });
   });
 })();