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

net/proxy/proxy_config.h

 // 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.
 
 #ifndef NET_PROXY_PROXY_CONFIG_H_
 #define NET_PROXY_PROXY_CONFIG_H_
 
 #include <string>
 
 #include "googleurl/src/gurl.h"
 #include "net/base/net_export.h"
 #include "net/proxy/proxy_bypass_rules.h"
 #include "net/proxy/proxy_config_source.h"
+#include "net/proxy/proxy_list.h"
 #include "net/proxy/proxy_server.h"
 
 namespace base {
 class Value;
 }
 
 namespace net {
 
 class ProxyInfo;
 
@@ skipping 21 matching lines @@
 
     // Note that the default of TYPE_NO_RULES results in direct connections
     // being made when using this ProxyConfig.
     ProxyRules();
     ~ProxyRules();
 
     bool empty() const {
       return type == TYPE_NO_RULES;
     }
 
     // Sets |result| with the proxy to use for |url| based on the current rules.

[eroman, 2013/02/26 01:13:50]

update: proxy --> proxies

[marq_use_my_chromium_address, 2013/02/27 23:08:19]

Done.

     void Apply(const GURL& url, ProxyInfo* result) const;
 
     // Parses the rules from a string, indicating which proxies to use.
     //
     //   proxy-uri = [<proxy-scheme>"://"]<proxy-host>[":"<proxy-port>]
     //
     // If the proxy to use depends on the scheme of the URL, can instead specify
     // a semicolon separated list of:
     //
     //   <url-scheme>"="<proxy-uri>
     //
+    //
+    // Multiple values can be specified for any given scheme, and they will
+    // be appended to the ProxyList for that scheme. If 'socks' is specified
+    // as a scheme, any schemes left without proxies specified will have
+    // that 'socks' server added.

[eroman, 2013/02/26 01:13:50]

What about instead changing the grammar from:
  url-scheme"="proxy-uri

to:
  url-scheme"="proxy-uri-list

where proxy-uri-list is a COMMA separated list of proxy-uri.

Do you really care about this string form (i.e. do you plan on setting things
this way), or can you just access it programmatically for your purposes.

(the particular grammar here is rather awkward/fragile, and forms the basis of
shared code with a platform-specific settings parser. it was extracted more for
convenience to re-use from command-line flags).

[marq_use_my_chromium_address, 2013/02/27 23:08:19]

Using this format to set things is the current plan; the alternative seems to be
to define a new proxy mode and many new proxy prefs that could be used to
construct a proxy list. 

I'm fine with commas instead of the repeated-entry list; the latter was a bit
easier to parse. 

+    //
     // For example:
     //   "http=foopy:80;ftp=foopy2"  -- use HTTP proxy "foopy:80" for http://
     //                                  URLs, and HTTP proxy "foopy2:80" for
     //                                  ftp:// URLs.
     //   "foopy:80"                  -- use HTTP proxy "foopy:80" for all URLs.
     //   "socks4://foopy"            -- use SOCKS v4 proxy "foopy:1080" for all
     //                                  URLs.
+    //   "http=foopy;http=bar.com;   -- use HTTP proxy "foopy" for http URLs,
+    //                                  and fail over to "bar.com" if "foopy"
+    //                                  is unavailable.
+    //   "http=foopy;http=direct://  -- use HTTP proxy "foopy" for http URLs,
+    //                                  and use no proxy if "foopy" is
+    //                                  unavailable.
+    //   "http=foopy;socks=foopy2   --  use HTTP proxy "foopy" for http URLs,
+    //                                  and use socks4://foopy2 for all other
+    //                                  URLs.
     void ParseFromString(const std::string& proxy_rules);
 
     // Returns one of {&proxy_for_http, &proxy_for_https, &proxy_for_ftp,
     // &fallback_proxy}, or NULL if there is no proxy to use.
     // Should only call this if the type is TYPE_PROXY_PER_SCHEME.
-    const ProxyServer* MapUrlSchemeToProxy(const std::string& url_scheme) const;
+    const ProxyList* MapUrlSchemeToProxy(const std::string& url_scheme) const;
 
     // Returns true if |*this| describes the same configuration as |other|.
     bool Equals(const ProxyRules& other) const;
 
     // Exceptions for when not to use a proxy.
     ProxyBypassRules bypass_rules;
 
     // Reverse the meaning of |bypass_rules|.
     bool reverse_bypass;
 
     Type type;
 
     // Set if |type| is TYPE_SINGLE_PROXY.
-    ProxyServer single_proxy;
+    ProxyList single_proxy;

[eroman, 2013/02/26 01:13:50]

These names are no longer good, since they are actually proxy lists. At a
minimum please add a TODO to rename these.

[marq_use_my_chromium_address, 2013/02/27 23:08:19]

Done.

 
     // Set if |type| is TYPE_PROXY_PER_SCHEME.
-    ProxyServer proxy_for_http;
-    ProxyServer proxy_for_https;
-    ProxyServer proxy_for_ftp;
+    ProxyList proxy_for_http;
+    ProxyList proxy_for_https;
+    ProxyList proxy_for_ftp;
 
-    // Used when there isn't a more specific per-scheme proxy server.
-    ProxyServer fallback_proxy;
+    // Used when a fallback (a socks= scheme) has been defined and the

[eroman, 2013/02/26 01:13:50]

I don't think this comment should mention socks= here. That is a concept of the
serialization format (ParseFromString), which honestly doesn't make much sense,
but is the format inherited from the Windows settings.

[marq_use_my_chromium_address, 2013/02/27 23:08:19]

Done.

+    // url to be proxied doesn't match any of the standard schemes.
+    ProxyList fallback_proxy;
 
    private:
     // Returns one of {&proxy_for_http, &proxy_for_https, &proxy_for_ftp}
     // or NULL if it is a scheme that we don't have a mapping
     // for. Should only call this if the type is TYPE_PROXY_PER_SCHEME.
-    ProxyServer* MapUrlSchemeToProxyNoFallback(const std::string& scheme);
+    ProxyList* MapUrlSchemeToProxyNoFallback(const std::string& scheme);
   };
 
   typedef int ID;
 
   // Indicates an invalid proxy config.
   static const ID kInvalidConfigID = 0;
 
   ProxyConfig();
   ProxyConfig(const ProxyConfig& config);
   ~ProxyConfig();
@@ skipping 100 matching lines @@
   ProxyConfigSource source_;
 
   ID id_;
 };
 
 }  // namespace net
 
 
 
 #endif  // NET_PROXY_PROXY_CONFIG_H_