Change ProxyRules to handle ProxyLists rather than just single ProxyServer instances.

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 359 matching lines @@
     return NULL;
   }
 
   net::ProxyConfig::ProxyRules rules;
   rules.ParseFromString(proxy_servers);
 
   switch (rules.type) {
     case net::ProxyConfig::ProxyRules::TYPE_NO_RULES:
       return NULL;
     case net::ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY:
-      if (rules.single_proxy.is_valid()) {
+      if (!rules.single_proxies.IsEmpty()) {
         extension_proxy_rules->Set(keys::field_name[keys::SCHEME_ALL],
-                                   CreateProxyServerDict(rules.single_proxy));
+                                   CreateProxyServerDict(rules.single_proxies));
       }
       break;
     case net::ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME:
-      if (rules.proxy_for_http.is_valid()) {
-        extension_proxy_rules->Set(keys::field_name[keys::SCHEME_HTTP],
-                                   CreateProxyServerDict(rules.proxy_for_http));
+      if (!rules.proxies_for_http.IsEmpty()) {
+        extension_proxy_rules->Set(
+            keys::field_name[keys::SCHEME_HTTP],
+            CreateProxyServerDict(rules.proxies_for_http));
       }
-      if (rules.proxy_for_https.is_valid()) {
+      if (!rules.proxies_for_https.IsEmpty()) {
         extension_proxy_rules->Set(
             keys::field_name[keys::SCHEME_HTTPS],
-            CreateProxyServerDict(rules.proxy_for_https));
+            CreateProxyServerDict(rules.proxies_for_https));
       }
-      if (rules.proxy_for_ftp.is_valid()) {
-        extension_proxy_rules->Set(keys::field_name[keys::SCHEME_FTP],
-                                   CreateProxyServerDict(rules.proxy_for_ftp));
+      if (!rules.proxies_for_ftp.IsEmpty()) {
+        extension_proxy_rules->Set(
+            keys::field_name[keys::SCHEME_FTP],
+            CreateProxyServerDict(rules.proxies_for_ftp));
       }
-      if (rules.fallback_proxy.is_valid()) {
-        extension_proxy_rules->Set(keys::field_name[keys::SCHEME_FALLBACK],
-                                   CreateProxyServerDict(rules.fallback_proxy));
+      if (!rules.fallback_proxies.IsEmpty()) {
+        extension_proxy_rules->Set(
+            keys::field_name[keys::SCHEME_FALLBACK],
+            CreateProxyServerDict(rules.fallback_proxies));
       }
       break;
   }
 
   // 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, ",;");
     extension_proxy_rules->Set(keys::kProxyConfigBypassList, bypass_list);
   }
 
   return extension_proxy_rules.release();
 }
 
-DictionaryValue* CreateProxyServerDict(const net::ProxyServer& proxy) {
+DictionaryValue* CreateProxyServerDict(const net::ProxyList& proxies) {
+  CHECK(proxies.size() == 1);

[battre, 2013/03/07 10:18:54]

I think this can cause trouble. See CommandLinePrefStore::ApplyProxyMode().

I think if you pass the command line switch
--proxy-server="http=foopy,direct://" and then use the proxy settings API to
query the current proxy configuration, you trigger this CHECK.

[marq_use_my_chromium_address, 2013/03/07 20:26:15]

Yeah, this is bad. Removed.

+  net::ProxyServer proxy = proxies.Get();
   scoped_ptr<DictionaryValue> out(new 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");
@@ skipping 47 matching lines @@
                                 const std::string& delims) {
   ListValue* out = new ListValue;
   base::StringTokenizer entries(in, delims);
   while (entries.GetNext())
     out->Append(Value::CreateStringValue(entries.token()));
   return out;
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions