Cleanup: Remove deprecated base::Value methods from net. Use base::Value too.

net/proxy/proxy_config.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 "net/proxy/proxy_config.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/values.h"
 #include "net/proxy/proxy_info.h"
 
 namespace net {
 
 namespace {
 
 // If |proxy| is valid, sets it in |dict| under the key |name|.
 void AddProxyToValue(const char* name,
                      const ProxyServer& proxy,
-                     DictionaryValue* dict) {
+                     base::DictionaryValue* dict) {
   if (proxy.is_valid())
     dict->SetString(name, proxy.ToURI());
 }
 
 }  // namespace
 
 ProxyConfig::ProxyRules::ProxyRules()
     : reverse_bypass(false),
       type(TYPE_NO_RULES) {
 }
@@ skipping 165 matching lines @@
 
 bool ProxyConfig::HasAutomaticSettings() const {
   return auto_detect_ || has_pac_url();
 }
 
 void ProxyConfig::ClearAutomaticSettings() {
   auto_detect_ = false;
   pac_url_ = GURL();
 }
 
-Value* ProxyConfig::ToValue() const {
-  DictionaryValue* dict = new DictionaryValue();
+base::Value* ProxyConfig::ToValue() const {
+  base::DictionaryValue* dict = new base::DictionaryValue();
 
   // Output the automatic settings.
   if (auto_detect_)
     dict->SetBoolean("auto_detect", auto_detect_);
   if (has_pac_url()) {
     dict->SetString("pac_url", pac_url_.possibly_invalid_spec());
     if (pac_mandatory_)
       dict->SetBoolean("pac_mandatory", pac_mandatory_);
   }
 
   // Output the manual settings.
   if (proxy_rules_.type != ProxyRules::TYPE_NO_RULES) {
     switch (proxy_rules_.type) {
       case ProxyRules::TYPE_SINGLE_PROXY:
         AddProxyToValue("single_proxy", proxy_rules_.single_proxy, dict);
         break;
       case ProxyRules::TYPE_PROXY_PER_SCHEME: {
-        DictionaryValue* dict2 = new DictionaryValue();
+        base::DictionaryValue* dict2 = new base::DictionaryValue();
         AddProxyToValue("http", proxy_rules_.proxy_for_http, dict2);
         AddProxyToValue("https", proxy_rules_.proxy_for_https, dict2);
         AddProxyToValue("ftp", proxy_rules_.proxy_for_ftp, dict2);
         AddProxyToValue("fallback", proxy_rules_.fallback_proxy, dict2);
         dict->Set("proxy_per_scheme", dict2);
         break;
       }
       default:
         NOTREACHED();
     }
 
     // Output the bypass rules.
     const ProxyBypassRules& bypass = proxy_rules_.bypass_rules;
     if (!bypass.rules().empty()) {
       if (proxy_rules_.reverse_bypass)
         dict->SetBoolean("reverse_bypass", true);
 
-      ListValue* list = new ListValue();
+      base::ListValue* list = new base::ListValue();
 
       for (ProxyBypassRules::RuleList::const_iterator it =
               bypass.rules().begin();
            it != bypass.rules().end(); ++it) {
-        list->Append(Value::CreateStringValue((*it)->ToString()));
+        list->Append(new base::StringValue((*it)->ToString()));
       }
 
       dict->Set("bypass_list", list);
     }
   }
 
   // Output the source.
   dict->SetString("source", ProxyConfigSourceToString(source_));
 
   return dict;
 }
 
 }  // namespace net