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>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/system/timezone_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/ash/session_controller_client.h"
 #include "chrome/browser/ui/webui/chromeos/ui_account_tweaks.h"
 #include "chrome/browser/ui/webui/options/chromeos/accounts_options_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/proxy/ui_proxy_config_service.h"
 #include "components/onc/onc_pref_names.h"
 #include "components/prefs/pref_change_registrar.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "components/user_manager/user_manager.h"
 #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[] = {
+// List of settings that are not changeable by users.
+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;
+  if (!chromeos::system::PerUserTimezoneEnabled()) {
+    return pref != kSystemTimezone;
+  }
+  // All the other Cros Settings are controlled.
+  return true;
+}
+
+// Returns true if |pref| is modifiable from UI.
+bool IsSettingWritable(const std::string& pref) {
+  if (!system::PerUserTimezoneEnabled())
+    return true;
+
+  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));
+    if (system::PerUserTimezoneEnabled()) {
+      const PrefService::Preference* pref =
+          primary_profile->GetPrefs()->FindPreference(pref_name);
+      dict->Set("value", base::MakeUnique<base::Value>(*pref->GetValue()));
+    } else {
+      dict->SetBoolean("value",
+                       primary_profile->GetPrefs()->GetBoolean(pref_name));
+    }
     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)) {
+  if (system::PerUserTimezoneEnabled() || 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());
   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 13 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