ChromeOS: implement per-user time zone preferences.

chrome/browser/ui/webui/options/chromeos/core_chromeos_options_handler.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/ui/webui/options/chromeos/core_chromeos_options_handler.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 30 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 namespace options {
 
 namespace {
 
 // List of settings that should be changeable by all users.
-const char* kNonPrivilegedSettings[] = {
+const char* kReadOnlySettings[] = {
     kSystemTimezone
 };
 
 // List of settings that should only be changeable by the primary user.
 const char* kPrimaryUserSettings[] = {
     prefs::kWakeOnWifiDarkConnect,
+    prefs::kUserTimezone,
+    prefs::kResolveTimezoneByGeolocation
 };
 
 // Returns true if |pref| can be controlled (e.g. by policy or owner).
-bool IsSettingPrivileged(const std::string& pref) {
-  const char** end = kNonPrivilegedSettings + arraysize(kNonPrivilegedSettings);
-  return std::find(kNonPrivilegedSettings, end, pref) == end;
+bool IsSettingWritable(const std::string& pref) {
+  const char** end = kReadOnlySettings + arraysize(kReadOnlySettings);
+  return std::find(kReadOnlySettings, end, pref) == end;
 }
 
 // Returns true if |pref| is shared (controlled by the primary user).
 bool IsSettingShared(const std::string& pref) {
   const char** end = kPrimaryUserSettings + arraysize(kPrimaryUserSettings);
   return std::find(kPrimaryUserSettings, end, pref) != end;
 }
 
 // Creates a user info dictionary to be stored in the |ListValue| that is
 // passed to Javascript for the |kAccountsPrefUsers| preference.
@@ skipping 119 matching lines @@
       return value;
     base::DictionaryValue* dict;
     if (!value->GetAsDictionary(&dict) || dict->HasKey("controlledBy"))
       return value;
     Profile* primary_profile = ProfileHelper::Get()->GetProfileByUser(
         user_manager::UserManager::Get()->GetPrimaryUser());
     if (!primary_profile)
       return value;
     dict->SetString("controlledBy", "shared");
     dict->SetBoolean("disabled", true);
-    dict->SetBoolean("value", primary_profile->GetPrefs()->GetBoolean(
-        pref_name));
+    const PrefService::Preference* pref =
+        primary_profile->GetPrefs()->FindPreference(pref_name);
+    dict->Set("value", base::MakeUnique<base::Value>(*pref->GetValue()));
     return value;
   }
 
   const base::Value* pref_value = CrosSettings::Get()->GetPref(pref_name);
   if (!pref_value)
     return base::MakeUnique<base::Value>();
 
   // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
   // TODO(estade): seems that this should replicate CreateValueForPref less.
   auto dict = base::MakeUnique<base::DictionaryValue>();
   if (pref_name == kAccountsPrefUsers)
     dict->Set("value", CreateUsersWhitelist(pref_value));
   else
     dict->Set("value", base::MakeUnique<base::Value>(*pref_value));
 
   std::string controlled_by;
-  if (IsSettingPrivileged(pref_name)) {
-    policy::BrowserPolicyConnectorChromeOS* connector =
-        g_browser_process->platform_part()->browser_policy_connector_chromeos();
-    if (connector->IsEnterpriseManaged())
-      controlled_by = "policy";
-    else if (!ProfileHelper::IsOwnerProfile(profile))
-      controlled_by = "owner";
-  }
-  dict->SetBoolean("disabled", !controlled_by.empty());
+  policy::BrowserPolicyConnectorChromeOS* connector =
+      g_browser_process->platform_part()->browser_policy_connector_chromeos();
+  if (connector->IsEnterpriseManaged())
+    controlled_by = "policy";
+  else if (!ProfileHelper::IsOwnerProfile(profile))
+    controlled_by = "owner";
   if (!controlled_by.empty())
     dict->SetString("controlledBy", controlled_by);
+
+  // Read-only setting is always disabled.
+  dict->SetBoolean("disabled",
+                   !controlled_by.empty() || !IsSettingWritable(pref_name));
   return std::move(dict);
 }
 
 void CoreChromeOSOptionsHandler::ObservePref(const std::string& pref_name) {
   if (proxy_cros_settings_parser::IsProxyPref(pref_name)) {
     // We observe those all the time.
     return;
   }
   if (!CrosSettings::IsCrosSettings(pref_name))
     return ::options::CoreOptionsHandler::ObservePref(pref_name);
@@ skipping 14 matching lines @@
     proxy_cros_settings_parser::SetProxyPrefValue(
         network_guid_, pref_name, value, GetUiProxyConfigService());
     base::Value proxy_type(pref_name);
     web_ui()->CallJavascriptFunctionUnsafe(
         "options.internet.DetailsInternetPage.updateProxySettings", proxy_type);
     ProcessUserMetric(value, metric);
     return;
   }
   if (!CrosSettings::IsCrosSettings(pref_name))
     return ::options::CoreOptionsHandler::SetPref(pref_name, value, metric);
+  if (!IsSettingWritable(pref_name)) {
+    NOTREACHED() << pref_name;
+    return;
+  }
   OwnerSettingsServiceChromeOS* service =
       OwnerSettingsServiceChromeOS::FromWebUI(web_ui());
   if (service && service->HandlesSetting(pref_name))
     service->Set(pref_name, *value);
   else
     CrosSettings::Get()->Set(pref_name, *value);
 
   ProcessUserMetric(value, metric);
 }
 
@@ skipping 142 matching lines @@
         network_guid_, proxy_cros_settings_parser::kProxySettings[i],
         GetUiProxyConfigService(), &value);
     DCHECK(value);
     DispatchPrefChangeNotification(
         proxy_cros_settings_parser::kProxySettings[i], std::move(value));
   }
 }
 
 }  // namespace options
 }  // namespace chromeos