Refactor proxy handling for ChromeOS to not go through the CrosSettings interface.

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"
@@ skipping 144 matching lines @@
   web_ui_->RegisterMessageCallback("coreOptionsUserMetricsAction",
       base::Bind(&CoreOptionsHandler::HandleUserMetricsAction,
                  base::Unretained(this)));
 }
 
 void CoreOptionsHandler::HandleInitialize(const ListValue* args) {
   DCHECK(handlers_host_);
   handlers_host_->InitializeHandlers();
 }
 
-Value* CoreOptionsHandler::FetchPref(const std::string& pref_name) {
+base::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 base::Value::CreateNullValue();
 
   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 base::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:
+    case base::Value::TYPE_BOOLEAN:
+    case base::Value::TYPE_INTEGER:
+    case base::Value::TYPE_DOUBLE:
+    case base::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,
+void CoreOptionsHandler::ProcessUserMetric(const base::Value* value,
                                            const std::string& metric) {
   if (metric.empty())
     return;
 
   std::string metric_string = metric;
-  if (value->IsType(Value::TYPE_BOOLEAN)) {
+  if (value->IsType(base::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(base::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;
@@ skipping 12 matching lines @@
 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.
-  Value* callback;
-  if (!args->Get(0, &callback) || !callback->IsType(Value::TYPE_STRING))
+  base::Value* callback;
+  if (!args->Get(0, &callback) || !callback->IsType(base::Value::TYPE_STRING))
     return;
 
   string16 callback_function;
   if (!callback->GetAsString(&callback_function))
     return;
 
   // Get the list of name for prefs to build the response dictionary.
   DictionaryValue result_value;
-  Value* list_member;
+  base::Value* list_member;
 
   for (size_t i = 1; i < args->GetSize(); i++) {
     if (!args->Get(i, &list_member))
       break;
 
-    if (!list_member->IsType(Value::TYPE_STRING))
+    if (!list_member->IsType(base::Value::TYPE_STRING))
       continue;
 
     std::string pref_name;
     if (!list_member->GetAsString(&pref_name))
       continue;
 
     result_value.Set(pref_name.c_str(), FetchPref(pref_name));
   }
   web_ui_->CallJavascriptFunction(UTF16ToASCII(callback_function),
                                   result_value);
 }
 
 void CoreOptionsHandler::HandleObservePrefs(const ListValue* args) {
   // First param is name is JS callback function name, the rest are pref
   // identifiers that we are observing.
   DCHECK_GE(static_cast<int>(args->GetSize()), 2);
 
   // Get preference change callback function name.
   string16 callback_func_name;
   if (!args->GetString(0, &callback_func_name))
     return;
 
   // Get all other parameters - pref identifiers.
   for (size_t i = 1; i < args->GetSize(); i++) {
-    Value* list_member;
+    base::Value* list_member;
     if (!args->Get(i, &list_member))
       break;
 
     // Just ignore bad pref identifiers for now.
     std::string pref_name;
-    if (!list_member->IsType(Value::TYPE_STRING) ||
+    if (!list_member->IsType(base::Value::TYPE_STRING) ||
         !list_member->GetAsString(&pref_name))
       continue;
 
     if (pref_callback_map_.find(pref_name) == pref_callback_map_.end())
       ObservePref(pref_name);
 
     pref_callback_map_.insert(
         PreferenceCallbackMap::value_type(pref_name,
                                           UTF16ToWideHack(callback_func_name)));
   }
@@ skipping 23 matching lines @@
   HandleSetPref(args, TYPE_LIST);
 }
 
 void CoreOptionsHandler::HandleSetPref(const ListValue* args, PrefType type) {
   DCHECK_GT(static_cast<int>(args->GetSize()), 1);
 
   std::string pref_name;
   if (!args->GetString(0, &pref_name))
     return;
 
-  Value* value;
+  base::Value* value;
   if (!args->Get(1, &value))
     return;
 
-  scoped_ptr<Value> temp_value;
+  scoped_ptr<base::Value> temp_value;
 
   switch (type) {
     case TYPE_BOOLEAN:
       CHECK_EQ(base::Value::TYPE_BOOLEAN, value->GetType());
       break;
     case TYPE_INTEGER: {
       // In JS all numbers are doubles.
       double double_value;
       CHECK(value->GetAsDouble(&double_value));
       int int_value = static_cast<int>(double_value);
-      temp_value.reset(Value::CreateIntegerValue(int_value));
+      temp_value.reset(base::Value::CreateIntegerValue(int_value));
       value = temp_value.get();
       break;
     }
     case TYPE_DOUBLE:
       CHECK_EQ(base::Value::TYPE_DOUBLE, value->GetType());
       break;
     case TYPE_STRING:
       CHECK_EQ(base::Value::TYPE_STRING, value->GetType());
       break;
     case TYPE_URL: {
       std::string original;
       CHECK(value->GetAsString(&original));
       GURL fixed = URLFixerUpper::FixupURL(original, std::string());
-      temp_value.reset(Value::CreateStringValue(fixed.spec()));
+      temp_value.reset(base::Value::CreateStringValue(fixed.spec()));
       value = temp_value.get();
       break;
     }
     case TYPE_LIST: {
       // In case we have a List pref we got a JSON string.
       std::string json_string;
       CHECK(value->GetAsString(&json_string));
       temp_value.reset(
           base::JSONReader().JsonToValue(json_string,
                                          false,  // no check_root
@@ skipping 26 matching lines @@
   ClearPref(pref_name, metric);
 }
 
 void CoreOptionsHandler::HandleUserMetricsAction(const ListValue* args) {
   std::string metric = UTF16ToUTF8(ExtractStringValue(args));
   if (!metric.empty())
     UserMetrics::RecordComputedAction(metric);
 }
 
 void CoreOptionsHandler::UpdateClearPluginLSOData() {
-  scoped_ptr<Value> enabled(
-      Value::CreateBooleanValue(clear_plugin_lso_data_enabled_.GetValue()));
+  scoped_ptr<base::Value> enabled(
+      base::Value::CreateBooleanValue(
+          clear_plugin_lso_data_enabled_.GetValue()));
   web_ui_->CallJavascriptFunction(
       "OptionsPage.setClearPluginLSODataEnabled", *enabled);
 }