Consistently decorate pref values sent to the settings UI code

chrome/browser/ui/webui/options2/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/options2/chromeos/core_chromeos_options_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
@@ skipping 26 matching lines @@
 const char* kNonOwnerSettings[] = {
     kSystemTimezone
 };
 
 // Returns true if |pref| should be only available to the owner.
 bool IsSettingOwnerOnly(const std::string& pref) {
   const char** end = kNonOwnerSettings + arraysize(kNonOwnerSettings);
   return std::find(kNonOwnerSettings, end, pref) == end;
 }
 
-// Create a settings value with "managed" and "disabled" property.
-// "managed" property is true if the setting is managed by administrator.
-// "disabled" property is true if the UI for the setting should be disabled.
-base::Value* CreateSettingsValue(base::Value *value,
-                                 bool managed,
-                                 bool disabled) {
-  DictionaryValue* dict = new DictionaryValue;
-  dict->Set("value", value);
-  dict->Set("managed", base::Value::CreateBooleanValue(managed));
-  dict->Set("disabled", base::Value::CreateBooleanValue(disabled));
-  return dict;
-}
-
 // Returns true if |username| is the logged-in owner.
 bool IsLoggedInOwner(const std::string& username) {
   UserManager* user_manager = UserManager::Get();
   return user_manager->IsCurrentUserOwner() &&
       user_manager->GetLoggedInUser().email() == username;
 }
 
 // Creates a user info dictionary to be stored in the |ListValue| that is
 // passed to Javascript for the |kAccountsPrefUsers| preference.
 base::DictionaryValue* CreateUserInfo(const std::string& username,
@@ skipping 80 matching lines @@
           pref_service->FindPreference(prefs::kProxy);
       return CreateValueForPref(pref, controlling_pref);
     }
     return ::options2::CoreOptionsHandler::FetchPref(pref_name);
   }
 
   const base::Value* pref_value = CrosSettings::Get()->GetPref(pref_name);
   if (!pref_value)
     return base::Value::CreateNullValue();
 
-  // Lists don't get the standard pref decoration.
-  if (pref_value->GetType() == base::Value::TYPE_LIST) {
-    if (pref_name == kAccountsPrefUsers)
-      return CreateUsersWhitelist(pref_value);
-    // Return a copy because the UI will take ownership of this object.
-    return pref_value->DeepCopy();
-  }
-  // All other prefs are decorated the same way.
-  bool enabled = (UserManager::Get()->IsCurrentUserOwner() ||
-                  !IsSettingOwnerOnly(pref_name));
-  return CreateSettingsValue(
-      pref_value->DeepCopy(),  // The copy will be owned by the dictionary.
-      g_browser_process->browser_policy_connector()->IsEnterpriseManaged(),
-      !enabled);
+  // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
+  DictionaryValue* dict = new DictionaryValue;
+  if (pref_name == kAccountsPrefUsers)
+    dict->Set("value", CreateUsersWhitelist(pref_value));
+  else
+    dict->Set("value", pref_value->DeepCopy());
+  if (g_browser_process->browser_policy_connector()->IsEnterpriseManaged())
+    dict->SetString("controlledBy", "policy");
+  dict->SetBoolean("disabled",
+                   IsSettingOwnerOnly(pref_name) &&
+                       !UserManager::Get()->IsCurrentUserOwner());
+  return 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 ::options2::CoreOptionsHandler::ObservePref(pref_name);
   CrosSettings::Get()->AddSettingsObserver(pref_name.c_str(), this);
@@ skipping 76 matching lines @@
     proxy_cros_settings_parser::GetProxyPrefValue(
         Profile::FromWebUI(web_ui()), kProxySettings[i], &value);
     DCHECK(value);
     scoped_ptr<base::Value> ptr(value);
     DispatchPrefChangeNotification(kProxySettings[i], ptr.Pass());
   }
 }
 
 }  // namespace options2
 }  // namespace chromeos