PART2: Make SignedSettings use proper Value types instead of string all around the place.

chrome/browser/chromeos/proxy_cros_settings_provider.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/chromeos/proxy_cros_settings_provider.h"
 
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 52 matching lines @@
 
 bool ProxyCrosSettingsProvider::IsUsingSharedProxies() const {
   return GetConfigService()->use_shared_proxies();
 }
 
 const std::string& ProxyCrosSettingsProvider::GetCurrentNetworkName() const {
   return GetConfigService()->current_network_name();
 }
 
 void ProxyCrosSettingsProvider::DoSet(const std::string& path,
-                                      Value* in_value) {
-  if (!in_value) {
-    return;
-  }
-
+                                      const base::Value& in_value) {
   chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
   // Retrieve proxy config.
   chromeos::ProxyConfigServiceImpl::ProxyConfig config;
   config_service->UIGetProxyConfig(&config);
 
   if (path == kProxyPacUrl) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       GURL url(val);
       if (url.is_valid())
         config_service->UISetProxyConfigToPACScript(url);
       else
         config_service->UISetProxyConfigToAutoDetect();
     }
   } else if (path == kProxySingleHttp) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       config_service->UISetProxyConfigToSingleProxy(CreateProxyServerFromHost(
           val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxySingleHttpPort) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       config_service->UISetProxyConfigToSingleProxy(CreateProxyServerFromPort(
           val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyHttpUrl) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("http",
           CreateProxyServerFromHost(
               val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyHttpPort) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("http",
           CreateProxyServerFromPort(
               val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyHttpsUrl) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("https",
           CreateProxyServerFromHost(
               val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyHttpsPort) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("https",
           CreateProxyServerFromPort(
               val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyType) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       if (val == 3) {
         if (config.automatic_proxy.pac_url.is_valid())
           config_service->UISetProxyConfigToPACScript(
               config.automatic_proxy.pac_url);
         else
           config_service->UISetProxyConfigToAutoDetect();
       } else if (val == 2) {
         if (config.single_proxy.server.is_valid()) {
           config_service->UISetProxyConfigToSingleProxy(
               config.single_proxy.server);
@@ skipping 23 matching lines @@
             config_service->UISetProxyConfigToProxyPerScheme("http",
                 net::ProxyServer());
           }
         }
       } else {
         config_service->UISetProxyConfigToDirect();
       }
     }
   } else if (path == kProxySingle) {
     bool val;
-    if (in_value->GetAsBoolean(&val)) {
+    if (in_value.GetAsBoolean(&val)) {
       if (val)
         config_service->UISetProxyConfigToSingleProxy(
             config.single_proxy.server);
       else
         config_service->UISetProxyConfigToProxyPerScheme("http",
             config.http_proxy.server);
     }
   } else if (path == kProxyFtpUrl) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("ftp",
           CreateProxyServerFromHost(
               val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxyFtpPort) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("ftp",
           CreateProxyServerFromPort(
               val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
     }
   } else if (path == kProxySocks) {
     std::string val;
-    if (in_value->GetAsString(&val)) {
+    if (in_value.GetAsString(&val)) {
       config_service->UISetProxyConfigToProxyPerScheme("socks",
           CreateProxyServerFromHost(val, config.socks_proxy,
                                     StartsWithASCII(val, "socks5://", false) ?
                                         net::ProxyServer::SCHEME_SOCKS5 :
                                         net::ProxyServer::SCHEME_SOCKS4));
     }
   } else if (path == kProxySocksPort) {
     int val;
-    if (in_value->GetAsInteger(&val)) {
+    if (in_value.GetAsInteger(&val)) {
       std::string host = config.socks_proxy.server.host_port_pair().host();
       config_service->UISetProxyConfigToProxyPerScheme("socks",
           CreateProxyServerFromPort(val, config.socks_proxy,
                                     StartsWithASCII(host, "socks5://", false) ?
                                         net::ProxyServer::SCHEME_SOCKS5 :
                                         net::ProxyServer::SCHEME_SOCKS4));
     }
   } else if (path == kProxyIgnoreList) {
     net::ProxyBypassRules bypass_rules;
-    if (in_value->GetType() == Value::TYPE_LIST) {
-      const ListValue* list_value = static_cast<const ListValue*>(in_value);
-      for (size_t x = 0; x < list_value->GetSize(); x++) {
+    if (in_value.GetType() == base::Value::TYPE_LIST) {
+      const base::ListValue& list_value =
+          static_cast<const base::ListValue&>(in_value);
+      for (size_t x = 0; x < list_value.GetSize(); x++) {
         std::string val;
-        if (list_value->GetString(x, &val)) {
+        if (list_value.GetString(x, &val)) {
           bypass_rules.AddRuleFromString(val);
         }
       }
       config_service->UISetProxyConfigBypassRules(bypass_rules);
     }
   }
 }
 
 const Value* ProxyCrosSettingsProvider::Get(const std::string& path) const {
   bool found = false;
-  Value* data = NULL;
+  base::Value* data = NULL;
   chromeos::ProxyConfigServiceImpl* config_service = GetConfigService();
   chromeos::ProxyConfigServiceImpl::ProxyConfig config;
   config_service->UIGetProxyConfig(&config);
 
   if (path == kProxyPacUrl) {
     // Only show pacurl for pac-script mode.
     if (config.mode ==
             chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PAC_SCRIPT &&
         config.automatic_proxy.pac_url.is_valid()) {
       data = Value::CreateStringValue(config.automatic_proxy.pac_url.spec());
@@ skipping 120 matching lines @@
 }
 
 Value* ProxyCrosSettingsProvider::CreateServerPortValue(
     const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
   return proxy.server.is_valid() ?
          Value::CreateIntegerValue(proxy.server.host_port_pair().port()) :
          NULL;
 }
 
 }  // namespace chromeos