redesign and reimplement proxy config service and tracker, revise proxy ui on cros

chrome/browser/ui/webui/options/core_options_handler.cc

 // Copyright (c) 2011 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/core_options_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/net/url_fixer_upper.h"
-#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/user_metrics.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_types.h"
 #include "googleurl/src/gurl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
-namespace {
-
-DictionaryValue* CreateValueForPref(const PrefService* pref_service,
-                                    const PrefService::Preference* pref) {
-  DictionaryValue* dict = new DictionaryValue;
-  dict->Set("value", pref->GetValue()->DeepCopy());
-  const PrefService::Preference* controlling_pref = pref;
-#if defined(OS_CHROMEOS)
-  // For use-shared-proxies pref, the proxy pref determines if the former is
-  // modifiable or managed by policy/extension.
-  if (pref->name() == prefs::kUseSharedProxies) {
-    controlling_pref = pref_service->FindPreference(prefs::kProxy);
-    if (!controlling_pref)
-      return dict;
-  }
-#endif  // defined(OS_CHROMEOS)
-  if (controlling_pref->IsManaged()) {
-    dict->SetString("controlledBy", "policy");
-  } else if (controlling_pref->IsExtensionControlled()) {
-    dict->SetString("controlledBy", "extension");
-  }
-  dict->SetBoolean("disabled", !controlling_pref->IsUserModifiable());
-  return dict;
-}
-
-}  // namespace
-
 CoreOptionsHandler::CoreOptionsHandler()
     : handlers_host_(NULL) {
 }
 
 CoreOptionsHandler::~CoreOptionsHandler() {}
 
 void CoreOptionsHandler::Initialize() {
   clear_plugin_lso_data_enabled_.Init(prefs::kClearPluginLSODataEnabled,
                                       Profile::FromWebUI(web_ui_),
                                       this);
@@ skipping 61 matching lines @@
 WebUIMessageHandler* CoreOptionsHandler::Attach(WebUI* web_ui) {
   WebUIMessageHandler* result = WebUIMessageHandler::Attach(web_ui);
   DCHECK(web_ui_);
   registrar_.Init(Profile::FromWebUI(web_ui_)->GetPrefs());
   return result;
 }
 
 void CoreOptionsHandler::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_PREF_CHANGED)
-    NotifyPrefChanged(content::Details<std::string>(details).ptr());
+  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
+    std::string* pref_name = content::Details<std::string>(details).ptr();
+    if (*pref_name == prefs::kClearPluginLSODataEnabled) {
+      // This preference is stored in Local State, not in the user preferences.
+      UpdateClearPluginLSOData();
+      return;
+    }
+    NotifyPrefChanged(*pref_name, std::string());
+  }
 }
 
 void CoreOptionsHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("coreOptionsInitialize",
       base::Bind(&CoreOptionsHandler::HandleInitialize,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("fetchPrefs",
       base::Bind(&CoreOptionsHandler::HandleFetchPrefs,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("observePrefs",
@@ skipping 31 matching lines @@
 }
 
 Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
   PrefService* pref_service = Profile::FromWebUI(web_ui_)->GetPrefs();
 
   const PrefService::Preference* pref =
       pref_service->FindPreference(pref_name.c_str());
   if (!pref)
     return Value::CreateNullValue();
 
-  return CreateValueForPref(pref_service, pref);
+  return CreateValueForPref(pref, NULL);
 }
 
 void CoreOptionsHandler::ObservePref(const std::string& pref_name) {
   registrar_.Add(pref_name.c_str(), this);
 }
 
 void CoreOptionsHandler::SetPref(const std::string& pref_name,
                                  const Value* value,
                                  const std::string& metric) {
   PrefService* pref_service = Profile::FromWebUI(web_ui_)->GetPrefs();
 
   switch (value->GetType()) {
     case Value::TYPE_BOOLEAN:
     case Value::TYPE_INTEGER:
     case Value::TYPE_DOUBLE:
     case Value::TYPE_STRING:
       pref_service->Set(pref_name.c_str(), *value);
       break;
 
     default:
       NOTREACHED();
       return;
   }
 
   pref_service->ScheduleSavePersistentPrefs();
+
   ProcessUserMetric(value, metric);
 }
 
 void CoreOptionsHandler::ClearPref(const std::string& pref_name,
                                    const std::string& metric) {
   PrefService* pref_service = Profile::FromWebUI(web_ui_)->GetPrefs();
   pref_service->ClearPref(pref_name.c_str());
   pref_service->ScheduleSavePersistentPrefs();
 
   if (!metric.empty())
     UserMetrics::RecordComputedAction(metric);
 }
 
 void CoreOptionsHandler::ProcessUserMetric(const Value* value,
                                            const std::string& metric) {
   if (metric.empty())
     return;
 
   std::string metric_string = metric;
   if (value->IsType(Value::TYPE_BOOLEAN)) {
     bool bool_value;
     CHECK(value->GetAsBoolean(&bool_value));
     metric_string += bool_value ? "_Enable" : "_Disable";
   }
 
   UserMetrics::RecordComputedAction(metric_string);
 }
 
+void CoreOptionsHandler::NotifyPrefChanged(
+    const std::string& pref_name,
+    const std::string& controlling_pref_name) {
+  const PrefService* pref_service = Profile::FromWebUI(web_ui_)->GetPrefs();
+  const PrefService::Preference* pref =
+      pref_service->FindPreference(pref_name.c_str());
+  if (!pref)
+    return;
+  const PrefService::Preference* controlling_pref =
+      !controlling_pref_name.empty() ?
+          pref_service->FindPreference(controlling_pref_name.c_str()) : NULL;
+  std::pair<PreferenceCallbackMap::const_iterator,
+            PreferenceCallbackMap::const_iterator> range;
+  range = pref_callback_map_.equal_range(pref_name);
+  for (PreferenceCallbackMap::const_iterator iter = range.first;
+       iter != range.second; ++iter) {
+    const std::wstring& callback_function = iter->second;
+    ListValue result_value;
+    result_value.Append(Value::CreateStringValue(pref_name.c_str()));
+    result_value.Append(CreateValueForPref(pref, controlling_pref));
+    web_ui_->CallJavascriptFunction(WideToASCII(callback_function),
+                                    result_value);
+  }
+}
+
+DictionaryValue* CoreOptionsHandler::CreateValueForPref(
+    const PrefService::Preference* pref,
+    const PrefService::Preference* controlling_pref) {
+  DictionaryValue* dict = new DictionaryValue;
+  dict->Set("value", pref->GetValue()->DeepCopy());
+  if (!controlling_pref)  // No controlling pref is managing actual pref.
+    controlling_pref = pref;  // This means pref is controlling itself.
+  if (controlling_pref->IsManaged()) {
+    dict->SetString("controlledBy", "policy");
+  } else if (controlling_pref->IsExtensionControlled()) {
+    dict->SetString("controlledBy", "extension");
+  }
+  dict->SetBoolean("disabled", !controlling_pref->IsUserModifiable());
+  return dict;
+}
+
 void CoreOptionsHandler::StopObservingPref(const std::string& path) {
   registrar_.Remove(path.c_str(), this);
 }
 
 void CoreOptionsHandler::HandleFetchPrefs(const ListValue* args) {
   // First param is name of callback function, so, there needs to be at least
   // one more element for the actual preference identifier.
   DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 
   // Get callback JS function name.
@@ skipping 162 matching lines @@
   if (!metric.empty())
     UserMetrics::RecordComputedAction(metric);
 }
 
 void CoreOptionsHandler::UpdateClearPluginLSOData() {
   scoped_ptr<Value> enabled(
       Value::CreateBooleanValue(clear_plugin_lso_data_enabled_.GetValue()));
   web_ui_->CallJavascriptFunction(
       "OptionsPage.setClearPluginLSODataEnabled", *enabled);
 }
-
-void CoreOptionsHandler::NotifyPrefChanged(const std::string* pref_name) {
-  if (*pref_name == prefs::kClearPluginLSODataEnabled) {
-    // This preference is stored in Local State, not in the user preferences.
-    UpdateClearPluginLSOData();
-    return;
-  }
-
-  PrefService* pref_service = Profile::FromWebUI(web_ui_)->GetPrefs();
-  const PrefService::Preference* pref =
-      pref_service->FindPreference(pref_name->c_str());
-  if (!pref)
-    return;
-
-  std::pair<PreferenceCallbackMap::const_iterator,
-            PreferenceCallbackMap::const_iterator> range;
-  range = pref_callback_map_.equal_range(*pref_name);
-  for (PreferenceCallbackMap::const_iterator iter = range.first;
-       iter != range.second; ++iter) {
-    const std::wstring& callback_function = iter->second;
-    ListValue result_value;
-    result_value.Append(Value::CreateStringValue(pref_name->c_str()));
-
-    result_value.Append(CreateValueForPref(pref_service, pref));
-
-    web_ui_->CallJavascriptFunction(WideToASCII(callback_function),
-                                    result_value);
-  }
-}