Support bypassList in Proxy Settings API.

chrome/browser/extensions/extension_proxy_api.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/extensions/extension_proxy_api.h"
 
 #include "base/string_util.h"
+#include "base/string_tokenizer.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/pref_names.h"
 #include "net/proxy/proxy_config.h"
 
 namespace {
 
 // The scheme for which to use a manually specified proxy, not of the proxy URI
@@ skipping 24 matching lines @@
                               "ftp",
                               "socks" };
 
 // String literals in dictionaries used to communicate with extension.
 const char kProxyCfgMode[] = "mode";
 const char kProxyCfgPacScript[] = "pacScript";
 const char kProxyCfgPacScriptUrl[] = "url";
 const char kProxyCfgRules[] = "rules";
 const char kProxyCfgRuleHost[] = "host";
 const char kProxyCfgRulePort[] = "port";
+const char kProxyCfgBypassList[] = "bypassList";
 const char kProxyCfgScheme[] = "scheme";
 
 COMPILE_ASSERT(SCHEME_MAX == SCHEME_SOCKS, SCHEME_MAX_must_equal_SCHEME_SOCKS);
 COMPILE_ASSERT(arraysize(field_name) == SCHEME_MAX + 1,
                field_name_array_is_wrong_size);
 COMPILE_ASSERT(arraysize(scheme_name) == SCHEME_MAX + 1,
                scheme_name_array_is_wrong_size);
 COMPILE_ASSERT(SCHEME_ALL == 0, singleProxy_must_be_first_option);
 
+bool TokenizeToStringList(
+    const std::string& in, const std::string& delims, ListValue** out) {
+  scoped_ptr<ListValue> result(new ListValue);
+  StringTokenizer entries(in, delims);
+  while (entries.GetNext()) {
+    result->Append(Value::CreateStringValue(entries.token()));
+  }
+  *out = result.release();
+  return true;
+}
+
+bool JoinStringList(
+    ListValue* list, const std::string& joiner, std::string* out) {
+  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))
+      return false;
+    if (!IsStringASCII(entry))
+      return false;
+    result.append(UTF16ToASCII(entry));
+  }
+  *out = result;
+  return true;
+}
+
 // Converts a proxy server description |dict| as passed by the API caller
 // (e.g. for the http proxy in the rules element) and converts it to a
 // ProxyServer. Returns true if successful.
 bool GetProxyServer(const DictionaryValue* dict,
                     net::ProxyServer::Scheme default_scheme,
                     net::ProxyServer* proxy_server) {
   std::string scheme_string;  // optional.
-  dict->GetString(kProxyCfgScheme, &scheme_string);
+  // We can safely assume that this is ASCII due to the allowed enumeration
+  // values specified in extension_api.json.
+  dict->GetStringASCII(kProxyCfgScheme, &scheme_string);
 
   net::ProxyServer::Scheme scheme =
       net::ProxyServer::GetSchemeFromURI(scheme_string);
   if (scheme == net::ProxyServer::SCHEME_INVALID)
     scheme = default_scheme;
 
-  std::string host;
-  if (!dict->GetString(kProxyCfgRuleHost, &host))
+  // TODO(battre): handle UTF-8 in hostnames (http://crbug.com/72692)
+  string16 host16;
+  if (!dict->GetString(kProxyCfgRuleHost, &host16))
     return false;
+  if (!IsStringASCII(host16))
+    return false;
+  std::string host = UTF16ToASCII(host16);
 
   int port;  // optional.
   if (!dict->GetInteger(kProxyCfgRulePort, &port))
     port = net::ProxyServer::GetDefaultPortForScheme(scheme);
 
   *proxy_server = net::ProxyServer(scheme, net::HostPortPair(host, port));
 
   return true;
 }
 
@@ skipping 51 matching lines @@
       proxy_pref.append(scheme_name[i]);
       proxy_pref.append("=");
       proxy_pref.append(proxy_server[i].ToURI());
     }
   }
 
   *out = proxy_pref;
   return true;
 }
 
+// Creates a string of the "bypassList" entries of a ProxyRules object (see API
+// documentation) by joining the elements with commas.
+// Returns true if successful (i.e. string could be delivered or no "bypassList"
+// exists in the |proxy_rules|).
+bool GetBypassList(DictionaryValue* proxy_rules, std::string* out) {
+  if (!proxy_rules)
+    return false;
+
+  ListValue* bypass_list;
+  if (!proxy_rules->HasKey(kProxyCfgBypassList)) {
+    *out = "";
+    return true;
+  }
+  if (!proxy_rules->GetList(kProxyCfgBypassList, &bypass_list))
+    return false;
+
+  return JoinStringList(bypass_list, ",", out);
+}
+
 }  // namespace
 
 void ProxySettingsFunction::ApplyPreference(const char* pref_path,
                                             Value* pref_value,
                                             bool incognito) {
   Profile* use_profile = profile();
   if (use_profile->IsOffTheRecord())
     use_profile = use_profile->GetOriginalProfile();
 
   use_profile->GetExtensionService()->extension_prefs()->
@@ skipping 14 matching lines @@
 bool UseCustomProxySettingsFunction::RunImpl() {
   DictionaryValue* proxy_config;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &proxy_config));
 
   bool incognito = false;  // Optional argument, defaults to false.
   if (HasOptionalArgument(1)) {
     EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &incognito));
   }
 
   std::string proxy_mode;
-  proxy_config->GetString(kProxyCfgMode, &proxy_mode);
+  // We can safely assume that this is ASCII due to the allowed enumeration
+  // values specified in extension_api.json.
+  proxy_config->GetStringASCII(kProxyCfgMode, &proxy_mode);
   ProxyPrefs::ProxyMode mode_enum;
   if (!ProxyPrefs::StringToProxyMode(proxy_mode, &mode_enum)) {
     LOG(ERROR) << "Invalid mode for proxy settings: " << proxy_mode << ". "
                << "Setting custom proxy settings failed.";
     return false;
   }
 
   DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary(kProxyCfgPacScript, &pac_dict);
-  std::string pac_url;
-  if (pac_dict && !pac_dict->GetString(kProxyCfgPacScriptUrl, &pac_url)) {
+  // TODO(battre): Handle UTF-8 URLs (http://crbug.com/72692)
+  string16 pac_url16;
+  if (pac_dict && !pac_dict->GetString(kProxyCfgPacScriptUrl, &pac_url16)) {
     LOG(ERROR) << "'pacScript' requires a 'url' field. "
                << "Setting custom proxy settings failed.";
     return false;
   }
+  if (!IsStringASCII(pac_url16)) {
+    LOG(ERROR) << "Only ASCII URLs are supported, yet";
+    return false;
+  }
+  std::string pac_url = UTF16ToASCII(pac_url16);
 
   DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary(kProxyCfgRules, &proxy_rules);
   std::string proxy_rules_string;
   if (proxy_rules && !GetProxyRules(proxy_rules, &proxy_rules_string)) {
     LOG(ERROR) << "Invalid 'rules' specified. "
                << "Setting custom proxy settings failed.";
     return false;
   }
+  std::string bypass_list;
+  if (proxy_rules && !GetBypassList(proxy_rules, &bypass_list)) {
+    LOG(ERROR) << "Invalid 'bypassList' specified. "
+               << "Setting custom proxy settings failed.";
+    return false;
+  }
 
-  // not supported, yet.
-  std::string bypass_list;
-
   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: {
       if (!pac_dict) {
@@ skipping 86 matching lines @@
       if (!dict.GetPacUrl(&pac_url)) {
         LOG(ERROR) << "Missing pac url";
         return false;
       }
       DictionaryValue* pac_dict = new DictionaryValue;
       pac_dict->SetString(kProxyCfgPacScriptUrl, pac_url);
       api_proxy_config->Set(kProxyCfgPacScript, pac_dict);
       break;
     }
     case ProxyPrefs::MODE_FIXED_SERVERS: {
-      // TODO(battre): Handle bypass list.
+      scoped_ptr<DictionaryValue> rules_dict(new DictionaryValue);
+
       std::string proxy_servers;
       if (!dict.GetProxyServer(&proxy_servers)) {
-        LOG(ERROR) << "Missing proxy servers";
+        LOG(ERROR) << "Missing proxy servers in configuration";
         return false;
       }
-      DictionaryValue* rules_dict = new DictionaryValue;
-      if (!ParseRules(proxy_servers, rules_dict)) {
+      if (!ParseRules(proxy_servers, rules_dict.get())) {
         LOG(ERROR) << "Could not parse proxy rules";
         return false;
       }
-      api_proxy_config->Set(kProxyCfgRules, rules_dict);
+
+      bool hasBypassList = dict.HasBypassList();
+      if (hasBypassList) {
+        std::string bypass_list_string;
+        if (!dict.GetBypassList(&bypass_list_string)) {
+          LOG(ERROR) << "Invalid bypassList in configuration";
+          return false;
+        }
+        ListValue* bypass_list = NULL;
+        if (TokenizeToStringList(bypass_list_string, ",;", &bypass_list)) {
+          rules_dict->Set(kProxyCfgBypassList, bypass_list);
+        } else {
+          LOG(ERROR) << "Error parsing bypassList " << bypass_list_string;
+          return false;
+        }
+      }
+      api_proxy_config->Set(kProxyCfgRules, rules_dict.release());
       break;
     }
     case ProxyPrefs::kModeCount:
       NOTREACHED();
   }
   return true;
 }
 
 bool GetCurrentProxySettingsFunction::ParseRules(const std::string& rules,
                                                  DictionaryValue* out) const {
@@ skipping 49 matching lines @@
       break;
     case net::ProxyServer::SCHEME_DIRECT:
     case net::ProxyServer::SCHEME_INVALID:
       NOTREACHED();
       return out;
   }
   out->SetString(kProxyCfgRuleHost, proxy.host_port_pair().host());
   out->SetInteger(kProxyCfgRulePort, proxy.host_port_pair().port());
   return out;
 }