Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/proxy/proxy_api_helpers.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.
 
 // Implementation of helper functions for the Chrome Extensions Proxy Settings
 // API.
 //
 // Throughout this code, we report errors to the user by setting an |error|
 // parameter, if and only if these errors can be cause by invalid input
 // from the extension and we cannot expect that the extensions API has
@@ skipping 40 matching lines @@
   if (!url.is_valid())
     return false;
 
   std::string mime_type;
   std::string charset;
   return net::DataURL::Parse(url, &mime_type, &charset, pac_script);
 }
 
 // Extension Pref -> Browser Pref conversion.
 
-bool GetProxyModeFromExtensionPref(const DictionaryValue* proxy_config,
+bool GetProxyModeFromExtensionPref(const base::DictionaryValue* proxy_config,
                                    ProxyPrefs::ProxyMode* out,
                                    std::string* error,
                                    bool* bad_message) {
   std::string proxy_mode;
 
   // We can safely assume that this is ASCII due to the allowed enumeration
   // values specified in the extension API JSON.
   proxy_config->GetStringASCII(keys::kProxyConfigMode, &proxy_mode);
   if (!ProxyPrefs::StringToProxyMode(proxy_mode, out)) {
     LOG(ERROR) << "Invalid mode for proxy settings: " << proxy_mode;
     *bad_message = true;
     return false;
   }
   return true;
 }
 
-bool GetPacMandatoryFromExtensionPref(const DictionaryValue* proxy_config,
+bool GetPacMandatoryFromExtensionPref(const base::DictionaryValue* proxy_config,
                                       bool* out,
                                       std::string* error,
                                       bool* bad_message){
-  const DictionaryValue* pac_dict = NULL;
+  const base::DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   bool mandatory_pac = false;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptMandatory) &&
       !pac_dict->GetBoolean(keys::kProxyConfigPacScriptMandatory,
                             &mandatory_pac)) {
     LOG(ERROR) << "'pacScript.mandatory' could not be parsed.";
     *bad_message = true;
     return false;
   }
   *out = mandatory_pac;
   return true;
 }
 
-bool GetPacUrlFromExtensionPref(const DictionaryValue* proxy_config,
+bool GetPacUrlFromExtensionPref(const base::DictionaryValue* proxy_config,
                                 std::string* out,
                                 std::string* error,
                                 bool* bad_message) {
-  const DictionaryValue* pac_dict = NULL;
+  const base::DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   // TODO(battre): Handle UTF-8 URLs (http://crbug.com/72692).
   string16 pac_url16;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptUrl) &&
       !pac_dict->GetString(keys::kProxyConfigPacScriptUrl, &pac_url16)) {
     LOG(ERROR) << "'pacScript.url' could not be parsed.";
     *bad_message = true;
     return false;
   }
   if (!IsStringASCII(pac_url16)) {
     *error = "'pacScript.url' supports only ASCII URLs "
              "(encode URLs in Punycode format).";
     return false;
   }
   *out = UTF16ToASCII(pac_url16);
   return true;
 }
 
-bool GetPacDataFromExtensionPref(const DictionaryValue* proxy_config,
+bool GetPacDataFromExtensionPref(const base::DictionaryValue* proxy_config,
                                  std::string* out,
                                  std::string* error,
                                  bool* bad_message) {
-  const DictionaryValue* pac_dict = NULL;
+  const base::DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigPacScript, &pac_dict);
   if (!pac_dict)
     return true;
 
   string16 pac_data16;
   if (pac_dict->HasKey(keys::kProxyConfigPacScriptData) &&
       !pac_dict->GetString(keys::kProxyConfigPacScriptData, &pac_data16)) {
     LOG(ERROR) << "'pacScript.data' could not be parsed.";
     *bad_message = true;
     return false;
   }
   if (!IsStringASCII(pac_data16)) {
     *error = "'pacScript.data' supports only ASCII code"
              "(encode URLs in Punycode format).";
     return false;
   }
   *out = UTF16ToASCII(pac_data16);
   return true;
 }
 
-bool GetProxyServer(const DictionaryValue* proxy_server,
+bool GetProxyServer(const base::DictionaryValue* proxy_server,
                     net::ProxyServer::Scheme default_scheme,
                     net::ProxyServer* out,
                     std::string* error,
                     bool* bad_message) {
   std::string scheme_string;  // optional.
 
   // We can safely assume that this is ASCII due to the allowed enumeration
   // values specified in the extension API JSON.
   proxy_server->GetStringASCII(keys::kProxyConfigRuleScheme, &scheme_string);
 
@@ skipping 20 matching lines @@
 
   int port;  // optional.
   if (!proxy_server->GetInteger(keys::kProxyConfigRulePort, &port))
     port = net::ProxyServer::GetDefaultPortForScheme(scheme);
 
   *out = net::ProxyServer(scheme, net::HostPortPair(host, port));
 
   return true;
 }
 
-bool GetProxyRulesStringFromExtensionPref(const DictionaryValue* proxy_config,
-                                          std::string* out,
-                                          std::string* error,
-                                          bool* bad_message) {
-  const DictionaryValue* proxy_rules = NULL;
+bool GetProxyRulesStringFromExtensionPref(
+    const base::DictionaryValue* proxy_config,
+    std::string* out,
+    std::string* error,
+    bool* bad_message) {
+  const base::DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigRules, &proxy_rules);
   if (!proxy_rules)
     return true;
 
   // Local data into which the parameters will be parsed. has_proxy describes
   // whether a setting was found for the scheme; proxy_server holds the
   // respective ProxyServer objects containing those descriptions.
   bool has_proxy[keys::SCHEME_MAX + 1];
   net::ProxyServer proxy_server[keys::SCHEME_MAX + 1];
 
   // Looking for all possible proxy types is inefficient if we have a
   // singleProxy that will supersede per-URL proxies, but it's worth it to keep
   // the code simple and extensible.
   for (size_t i = 0; i <= keys::SCHEME_MAX; ++i) {
-    const DictionaryValue* proxy_dict = NULL;
+    const base::DictionaryValue* proxy_dict = NULL;
     has_proxy[i] = proxy_rules->GetDictionary(keys::field_name[i],
                                               &proxy_dict);
     if (has_proxy[i]) {
       net::ProxyServer::Scheme default_scheme = net::ProxyServer::SCHEME_HTTP;
       if (!GetProxyServer(proxy_dict, default_scheme,
                           &proxy_server[i], error, bad_message)) {
         // Don't set |error| here, as GetProxyServer takes care of that.
         return false;
       }
     }
@@ skipping 27 matching lines @@
       proxy_pref.append(keys::scheme_name[i]);
       proxy_pref.append("=");
       proxy_pref.append(proxy_server[i].ToURI());
     }
   }
 
   *out = proxy_pref;
   return true;
 }
 
-bool JoinUrlList(const ListValue* list,
+bool JoinUrlList(const base::ListValue* list,
                  const std::string& joiner,
                  std::string* out,
                  std::string* error,
                  bool* bad_message) {
   std::string result;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     if (!result.empty())
       result.append(joiner);
 
     // TODO(battre): handle UTF-8 (http://crbug.com/72692).
     string16 entry;
     if (!list->GetString(i, &entry)) {
       LOG(ERROR) << "'rules.bypassList' could not be parsed.";
       *bad_message = true;
       return false;
     }
     if (!IsStringASCII(entry)) {
       *error = "'rules.bypassList' supports only ASCII URLs "
                "(encode URLs in Punycode format).";
       return false;
     }
     result.append(UTF16ToASCII(entry));
   }
   *out = result;
   return true;
 }
 
-bool GetBypassListFromExtensionPref(const DictionaryValue* proxy_config,
+bool GetBypassListFromExtensionPref(const base::DictionaryValue* proxy_config,
                                     std::string* out,
                                     std::string* error,
                                     bool* bad_message) {
-  const DictionaryValue* proxy_rules = NULL;
+  const base::DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary(keys::kProxyConfigRules, &proxy_rules);
   if (!proxy_rules)
     return true;
 
   if (!proxy_rules->HasKey(keys::kProxyConfigBypassList)) {
     *out = "";
     return true;
   }
-  const ListValue* bypass_list = NULL;
+  const base::ListValue* bypass_list = NULL;
   if (!proxy_rules->GetList(keys::kProxyConfigBypassList, &bypass_list)) {
     LOG(ERROR) << "'rules.bypassList' could not be parsed.";
     *bad_message = true;
     return false;
   }
 
   return JoinUrlList(bypass_list, ",", out, error, bad_message);
 }
 
-DictionaryValue* CreateProxyConfigDict(ProxyPrefs::ProxyMode mode_enum,
-                                       bool pac_mandatory,
-                                       const std::string& pac_url,
-                                       const std::string& pac_data,
-                                       const std::string& proxy_rules_string,
-                                       const std::string& bypass_list,
-                                       std::string* error) {
-  DictionaryValue* result_proxy_config = NULL;
+base::DictionaryValue* CreateProxyConfigDict(
+    ProxyPrefs::ProxyMode mode_enum,
+    bool pac_mandatory,
+    const std::string& pac_url,
+    const std::string& pac_data,
+    const std::string& proxy_rules_string,
+    const std::string& bypass_list,
+    std::string* error) {
+  base::DictionaryValue* result_proxy_config = NULL;
   switch (mode_enum) {
     case ProxyPrefs::MODE_DIRECT:
       result_proxy_config = ProxyConfigDictionary::CreateDirect();
       break;
     case ProxyPrefs::MODE_AUTO_DETECT:
       result_proxy_config = ProxyConfigDictionary::CreateAutoDetect();
       break;
     case ProxyPrefs::MODE_PAC_SCRIPT: {
       std::string url;
       if (!pac_url.empty()) {
@@ skipping 23 matching lines @@
     }
     case ProxyPrefs::MODE_SYSTEM:
       result_proxy_config = ProxyConfigDictionary::CreateSystem();
       break;
     case ProxyPrefs::kModeCount:
       NOTREACHED();
   }
   return result_proxy_config;
 }
 
-DictionaryValue* CreateProxyRulesDict(
+base::DictionaryValue* CreateProxyRulesDict(
     const ProxyConfigDictionary& proxy_config) {
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_FIXED_SERVERS);
 
-  scoped_ptr<DictionaryValue> extension_proxy_rules(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> extension_proxy_rules(
+      new base::DictionaryValue);
 
   std::string proxy_servers;
   if (!proxy_config.GetProxyServer(&proxy_servers)) {
     LOG(ERROR) << "Missing proxy servers in configuration.";
     return NULL;
   }
 
   net::ProxyConfig::ProxyRules rules;
   rules.ParseFromString(proxy_servers);
 
@@ skipping 34 matching lines @@
   // If we add a new scheme some time, we need to also store a new dictionary
   // representing this scheme in the code above.
   COMPILE_ASSERT(keys::SCHEME_MAX == 4, SCHEME_FORGOTTEN);
 
   if (proxy_config.HasBypassList()) {
     std::string bypass_list_string;
     if (!proxy_config.GetBypassList(&bypass_list_string)) {
       LOG(ERROR) << "Invalid bypassList in configuration.";
       return NULL;
     }
-    ListValue* bypass_list = TokenizeToStringList(bypass_list_string, ",;");
+    base::ListValue* bypass_list =
+        TokenizeToStringList(bypass_list_string, ",;");
     extension_proxy_rules->Set(keys::kProxyConfigBypassList, bypass_list);
   }
 
   return extension_proxy_rules.release();
 }
 
-DictionaryValue* CreateProxyServerDict(const net::ProxyServer& proxy) {
-  scoped_ptr<DictionaryValue> out(new DictionaryValue);
+base::DictionaryValue* CreateProxyServerDict(const net::ProxyServer& proxy) {
+  scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
   switch (proxy.scheme()) {
     case net::ProxyServer::SCHEME_HTTP:
       out->SetString(keys::kProxyConfigRuleScheme, "http");
       break;
     case net::ProxyServer::SCHEME_HTTPS:
       out->SetString(keys::kProxyConfigRuleScheme, "https");
       break;
     case net::ProxyServer::SCHEME_SOCKS4:
       out->SetString(keys::kProxyConfigRuleScheme, "socks4");
       break;
     case net::ProxyServer::SCHEME_SOCKS5:
       out->SetString(keys::kProxyConfigRuleScheme, "socks5");
       break;
     case net::ProxyServer::SCHEME_DIRECT:
     case net::ProxyServer::SCHEME_INVALID:
       NOTREACHED();
       return NULL;
   }
   out->SetString(keys::kProxyConfigRuleHost, proxy.host_port_pair().host());
   out->SetInteger(keys::kProxyConfigRulePort, proxy.host_port_pair().port());
   return out.release();
 }
 
-DictionaryValue* CreatePacScriptDict(
+base::DictionaryValue* CreatePacScriptDict(
     const ProxyConfigDictionary& proxy_config) {
   ProxyPrefs::ProxyMode mode;
   CHECK(proxy_config.GetMode(&mode) && mode == ProxyPrefs::MODE_PAC_SCRIPT);
 
-  scoped_ptr<DictionaryValue> pac_script_dict(new DictionaryValue);
+  scoped_ptr<base::DictionaryValue> pac_script_dict(new base::DictionaryValue);
   std::string pac_url;
   if (!proxy_config.GetPacUrl(&pac_url)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC URL.";
     return NULL;
   }
   bool pac_mandatory = false;
   if (!proxy_config.GetPacMandatory(&pac_mandatory)) {
     LOG(ERROR) << "Invalid proxy configuration. Missing PAC mandatory field.";
     return NULL;
   }
 
   if (pac_url.find("data") == 0) {
     std::string pac_data;
     if (!CreatePACScriptFromDataURL(pac_url, &pac_data)) {
       LOG(ERROR) << "Cannot decode base64-encoded PAC data URL: " << pac_url;
       return NULL;
     }
     pac_script_dict->SetString(keys::kProxyConfigPacScriptData, pac_data);
   } else {
     pac_script_dict->SetString(keys::kProxyConfigPacScriptUrl, pac_url);
   }
   pac_script_dict->SetBoolean(keys::kProxyConfigPacScriptMandatory,
                               pac_mandatory);
   return pac_script_dict.release();
 }
 
-ListValue* TokenizeToStringList(const std::string& in,
+base::ListValue* TokenizeToStringList(const std::string& in,
                                 const std::string& delims) {
-  ListValue* out = new ListValue;
+  base::ListValue* out = new base::ListValue;
   base::StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->Append(Value::CreateStringValue(entries.token()));
   return out;
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions