[cros] Add checkbox for toggling data roaming setting.

chrome/browser/chromeos/user_cros_settings_provider.cc

 // Copyright (c) 2010 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/chromeos/user_cros_settings_provider.h"
 
 #include <map>
 #include <set>
 
 #include "base/hash_tables.h"
@@ skipping 15 matching lines @@
 namespace chromeos {
 
 namespace {
 
 const char kTrueIncantation[] = "true";
 const char kFalseIncantation[] = "false";
 const char kTrustedSuffix[] = "/trusted";
 
 // For all our boolean settings following is applicable:
 // true is default permissive value and false is safe prohibitic value.
+// Exception: kSignedDataRoamingEnabled which has default value of false.
 const char* kBooleanSettings[] = {
   kAccountsPrefAllowNewUser,
   kAccountsPrefAllowGuest,
-  kAccountsPrefShowUserNamesOnSignIn
+  kAccountsPrefShowUserNamesOnSignIn,
+  kSignedDataRoamingEnabled,
 };
 
 const char* kStringSettings[] = {
   kDeviceOwner
 };
 
 const char* kListSettings[] = {
   kAccountsPrefUsers
 };
 
 bool IsControlledBooleanSetting(const std::string& pref_path) {
-  return std::find(kBooleanSettings,
-                   kBooleanSettings + arraysize(kBooleanSettings),
-                   pref_path) !=
-      kBooleanSettings + arraysize(kBooleanSettings);
+  // TODO(nkostylev): Using std::find for 4 value array generates this warning
+  // in chroot stl_algo.h:231: error: array subscript is above array bounds.
+  // GCC 4.4.3
+  return (pref_path == kAccountsPrefAllowNewUser) ||
+         (pref_path == kAccountsPrefAllowGuest) ||
+         (pref_path == kAccountsPrefShowUserNamesOnSignIn) ||
+         (pref_path == kSignedDataRoamingEnabled);
 }
 
 bool IsControlledStringSetting(const std::string& pref_path) {
   return std::find(kStringSettings,
                    kStringSettings + arraysize(kStringSettings),
                    pref_path) !=
       kStringSettings + arraysize(kStringSettings);
 }
 
 bool IsControlledListSetting(const std::string& pref_path) {
   return std::find(kListSettings,
                    kListSettings + arraysize(kListSettings),
                    pref_path) !=
       kListSettings + arraysize(kListSettings);
 }
 
 void RegisterSetting(PrefService* local_state, const std::string& pref_path) {
   local_state->RegisterBooleanPref((pref_path + kTrustedSuffix).c_str(),
                                    false);
   if (IsControlledBooleanSetting(pref_path)) {
-    local_state->RegisterBooleanPref(pref_path.c_str(), true);
+    if (pref_path == kSignedDataRoamingEnabled)
+      local_state->RegisterBooleanPref(pref_path.c_str(), false);
+    else
+      local_state->RegisterBooleanPref(pref_path.c_str(), true);
   } else if (IsControlledStringSetting(pref_path)) {
     local_state->RegisterStringPref(pref_path.c_str(), "");
   } else {
     DCHECK(IsControlledListSetting(pref_path));
     local_state->RegisterListPref(pref_path.c_str());
   }
 }
 
 Value* CreateSettingsBooleanValue(bool value, bool managed) {
   DictionaryValue* dict = new DictionaryValue;
@@ skipping 185 matching lines @@
       case SignedSettings::NOT_FOUND:
       case SignedSettings::KEY_UNAVAILABLE: {
         bool fallback_to_default = !is_owned
             || (code == SignedSettings::NOT_FOUND);
         DCHECK(fallback_to_default || code == SignedSettings::SUCCESS);
         if (fallback_to_default)
           VLOG(1) << "Going default for cros setting " << name;
         else
           VLOG(1) << "Retrieved cros setting " << name << "=" << value;
         if (IsControlledBooleanSetting(name)) {
-          // We assume our boolean settings are true before explicitly set.
           UpdateCacheBool(name, (value == kTrueIncantation),
               fallback_to_default ? USE_VALUE_DEFAULT : USE_VALUE_SUPPLIED);
         } else if (IsControlledStringSetting(name)) {
           UpdateCacheString(name, value,
               fallback_to_default ? USE_VALUE_DEFAULT : USE_VALUE_SUPPLIED);
         }
         break;
       }
       case SignedSettings::OPERATION_FAILED:
       default: {
@@ skipping 109 matching lines @@
 bool UserCrosSettingsProvider::RequestTrustedAllowNewUser(Task* callback) {
   return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
       kAccountsPrefAllowNewUser, callback);
 }
 
 bool UserCrosSettingsProvider::RequestTrustedShowUsersOnSignin(Task* callback) {
   return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
       kAccountsPrefShowUserNamesOnSignIn, callback);
 }
 
+bool UserCrosSettingsProvider::RequestTrustedDataRoamingEnabled(
+    Task* callback) {
+  return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
+      kSignedDataRoamingEnabled, callback);
+}
+
 bool UserCrosSettingsProvider::RequestTrustedOwner(Task* callback) {
   return UserCrosSettingsTrust::GetInstance()->RequestTrustedEntity(
       kDeviceOwner, callback);
 }
 
 // static
 bool UserCrosSettingsProvider::cached_allow_guest() {
   // Trigger prefetching if singleton object still does not exist.
   UserCrosSettingsTrust::GetInstance();
   return g_browser_process->local_state()->GetBoolean(kAccountsPrefAllowGuest);
 }
 
 // static
 bool UserCrosSettingsProvider::cached_allow_new_user() {
   // Trigger prefetching if singleton object still does not exist.
   UserCrosSettingsTrust::GetInstance();
   return g_browser_process->local_state()->GetBoolean(
-    kAccountsPrefAllowNewUser);
+      kAccountsPrefAllowNewUser);
 }
 
 // static
+bool UserCrosSettingsProvider::cached_data_roaming_enabled() {
+  // Trigger prefetching if singleton object still does not exist.
+  UserCrosSettingsTrust::GetInstance();
+  return g_browser_process->local_state()->GetBoolean(
+      kSignedDataRoamingEnabled);
+}
+
+// static
 bool UserCrosSettingsProvider::cached_show_users_on_signin() {
   // Trigger prefetching if singleton object still does not exist.
   UserCrosSettingsTrust::GetInstance();
   return g_browser_process->local_state()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn);
 }
 
 // static
 const ListValue* UserCrosSettingsProvider::cached_whitelist() {
   PrefService* prefs = g_browser_process->local_state();
@@ skipping 54 matching lines @@
     ListValue* user_list = new ListValue;
     GetUserWhitelist(user_list);
     *out_value = user_list;
     return true;
   }
 
   return false;
 }
 
 bool UserCrosSettingsProvider::HandlesSetting(const std::string& path) {
-  return ::StartsWithASCII(path, "cros.accounts.", true);
+  return ::StartsWithASCII(path, "cros.accounts.", true) ||
+      ::StartsWithASCII(path, "cros.signed.", true);
 }
 
 void UserCrosSettingsProvider::WhitelistUser(const std::string& email) {
   SignedSettingsHelper::Get()->StartWhitelistOp(
       email, true, UserCrosSettingsTrust::GetInstance());
   PrefService* prefs = g_browser_process->local_state();
   ListValue* cached_whitelist = prefs->GetMutableList(kAccountsPrefUsers);
   cached_whitelist->Append(Value::CreateStringValue(email));
   prefs->ScheduleSavePersistentPrefs();
 }
 
 void UserCrosSettingsProvider::UnwhitelistUser(const std::string& email) {
   SignedSettingsHelper::Get()->StartWhitelistOp(
       email, false, UserCrosSettingsTrust::GetInstance());
 
   PrefService* prefs = g_browser_process->local_state();
   ListValue* cached_whitelist = prefs->GetMutableList(kAccountsPrefUsers);
   StringValue email_value(email);
   if (cached_whitelist->Remove(email_value) != -1)
     prefs->ScheduleSavePersistentPrefs();
 }
 
 // static
 void UserCrosSettingsProvider::UpdateCachedOwner(const std::string& email) {
   UpdateCacheString(kDeviceOwner, email, USE_VALUE_SUPPLIED);
 }
 
 }  // namespace chromeos