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()) {
-        extension_proxy_rules->Set(keys::field_name[keys::SCHEME_ALL],
-                                   CreateProxyServerDict(rules.single_proxy));
+      if (!rules.single_proxies.IsEmpty()) {
+        extension_proxy_rules->Set(
+            keys::field_name[keys::SCHEME_ALL],
+            CreateProxyServerDict(rules.single_proxies.Get()));
       }
       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.Get()));
       }
-      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.Get()));
       }
-      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.Get()));
       }
-      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.Get()));
       }
       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;
@@ skipping 69 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