more changes

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/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
@@ skipping 229 matching lines @@
   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());
+      data = base::StringValue::New(config.automatic_proxy.pac_url.spec());
     }
     found = true;
   } else if (path == kProxySingleHttp) {
     data = CreateServerHostValue(config.single_proxy);
     found = true;
   } else if (path == kProxySingleHttpPort) {
     data = CreateServerPortValue(config.single_proxy);
     found = true;
   } else if (path == kProxyHttpUrl) {
     data = CreateServerHostValue(config.http_proxy);
     found = true;
   } else if (path == kProxyHttpsUrl) {
     data = CreateServerHostValue(config.https_proxy);
     found = true;
   } else if (path == kProxyType) {
     if (config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_AUTO_DETECT ||
         config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PAC_SCRIPT) {
-      data = Value::CreateIntegerValue(3);
+      data = base::NumberValue::New(3);
     } else if (config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY ||
         config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_PROXY_PER_SCHEME) {
-      data = Value::CreateIntegerValue(2);
+      data = base::NumberValue::New(2);
     } else {
-      data = Value::CreateIntegerValue(1);
+      data = base::NumberValue::New(1);
     }
     found = true;
   } else if (path == kProxySingle) {
-    data = Value::CreateBooleanValue(config.mode ==
+    data = base::BooleanValue::New(config.mode ==
         chromeos::ProxyConfigServiceImpl::ProxyConfig::MODE_SINGLE_PROXY);
     found = true;
   } else if (path == kProxyFtpUrl) {
     data = CreateServerHostValue(config.ftp_proxy);
     found = true;
   } else if (path == kProxySocks) {
     data = CreateServerHostValue(config.socks_proxy);
     found = true;
   } else if (path == kProxyHttpPort) {
     data = CreateServerPortValue(config.http_proxy);
     found = true;
   } else if (path == kProxyHttpsPort) {
     data = CreateServerPortValue(config.https_proxy);
     found = true;
   } else if (path == kProxyFtpPort) {
     data = CreateServerPortValue(config.ftp_proxy);
     found = true;
   } else if (path == kProxySocksPort) {
     data = CreateServerPortValue(config.socks_proxy);
     found = true;
   } else if (path == kProxyIgnoreList) {
     ListValue* list =  new ListValue();
     net::ProxyBypassRules::RuleList bypass_rules = config.bypass_rules.rules();
     for (size_t x = 0; x < bypass_rules.size(); x++) {
-      list->Append(Value::CreateStringValue(bypass_rules[x]->ToString()));
+      list->Append(base::StringValue::New(bypass_rules[x]->ToString()));
     }
     *out_value = list;
     return true;
   }
   if (found) {
     DictionaryValue* dict = new DictionaryValue;
     if (!data)
-      data = Value::CreateStringValue("");
+      data = base::StringValue::New("");
     dict->Set("value", data);
     dict->SetBoolean("managed", managed);
     *out_value = dict;
     return true;
   } else {
     *out_value = NULL;
     return false;
   }
 }
 
@@ skipping 32 matching lines @@
     host = proxy.server.host_port_pair().host();
   if (host.length() == 0 && port == 0)
     return net::ProxyServer();
   net::HostPortPair host_port_pair(host, port);
   return net::ProxyServer(scheme, host_port_pair);
 }
 
 Value* ProxyCrosSettingsProvider::CreateServerHostValue(
     const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
   return proxy.server.is_valid() ?
-         Value::CreateStringValue(proxy.server.host_port_pair().host()) :
+         base::StringValue::New(proxy.server.host_port_pair().host()) :
          NULL;
 }
 
 Value* ProxyCrosSettingsProvider::CreateServerPortValue(
     const ProxyConfigServiceImpl::ProxyConfig::ManualProxy& proxy) const {
   return proxy.server.is_valid() ?
-         Value::CreateIntegerValue(proxy.server.host_port_pair().port()) :
+         base::NumberValue::New(proxy.server.host_port_pair().port()) :
          NULL;
 }
 
 }  // namespace chromeos