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

net/proxy/proxy_config_service_linux.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.
 
 #include "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
@@ skipping 119 matching lines @@
     } else {
       // specified autoconfig URL
       config->set_pac_url(GURL(auto_proxy));
     }
     return true;
   }
   // "all_proxy" is a shortcut to avoid defining {http,https,ftp}_proxy.
   ProxyServer proxy_server;
   if (GetProxyFromEnvVar("all_proxy", &proxy_server)) {
     config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
-    config->proxy_rules().single_proxy = proxy_server;
+    config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_server);
   } else {
     bool have_http = GetProxyFromEnvVar("http_proxy", &proxy_server);
     if (have_http)
-      config->proxy_rules().proxy_for_http = proxy_server;
+      config->proxy_rules().proxies_for_http.SetSingleProxyServer(proxy_server);
     // It would be tempting to let http_proxy apply for all protocols
     // if https_proxy and ftp_proxy are not defined. Googling turns up
     // several documents that mention only http_proxy. But then the
     // user really might not want to proxy https. And it doesn't seem
     // like other apps do this. So we will refrain.
     bool have_https = GetProxyFromEnvVar("https_proxy", &proxy_server);
     if (have_https)
-      config->proxy_rules().proxy_for_https = proxy_server;
+      config->proxy_rules().proxies_for_https.
+          SetSingleProxyServer(proxy_server);
     bool have_ftp = GetProxyFromEnvVar("ftp_proxy", &proxy_server);
     if (have_ftp)
-      config->proxy_rules().proxy_for_ftp = proxy_server;
+      config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_server);
     if (have_http || have_https || have_ftp) {
       // mustn't change type unless some rules are actually set.
       config->proxy_rules().type =
           ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
     }
   }
   if (config->proxy_rules().empty()) {
     // If the above were not defined, try for socks.
     // For environment variables, we default to version 5, per the gnome
     // documentation: http://library.gnome.org/devel/gnet/stable/gnet-socks.html
     ProxyServer::Scheme scheme = ProxyServer::SCHEME_SOCKS5;
     std::string env_version;
     if (env_var_getter_->GetVar("SOCKS_VERSION", &env_version)
         && env_version == "4")
       scheme = ProxyServer::SCHEME_SOCKS4;
     if (GetProxyFromEnvVarForScheme("SOCKS_SERVER", scheme, &proxy_server)) {
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
-      config->proxy_rules().single_proxy = proxy_server;
+      config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_server);
     }
   }
   // Look for the proxy bypass list.
   std::string no_proxy;
   env_var_getter_->GetVar("no_proxy", &no_proxy);
   if (config->proxy_rules().empty()) {
     // Having only "no_proxy" set, presumably to "*", makes it
     // explicit that env vars do specify a configuration: having no
     // rules specified only means the user explicitly asks for direct
     // connections.
@@ skipping 1254 matching lines @@
     num_proxies_specified++;
   if (GetProxyFromSettings(SettingGetter::PROXY_FTP_HOST, &proxy_for_ftp))
     num_proxies_specified++;
   if (GetProxyFromSettings(SettingGetter::PROXY_SOCKS_HOST, &socks_proxy))
     num_proxies_specified++;
 
   if (same_proxy) {
     if (proxy_for_http.is_valid()) {
       // Use the http proxy for all schemes.
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
-      config->proxy_rules().single_proxy = proxy_for_http;
+      config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_for_http);
     }
   } else if (num_proxies_specified > 0) {
     if (socks_proxy.is_valid() && num_proxies_specified == 1) {
       // If the only proxy specified was for SOCKS, use it for all schemes.
       config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
-      config->proxy_rules().single_proxy = socks_proxy;
+      config->proxy_rules().single_proxies.SetSingleProxyServer(socks_proxy);
     } else {
-      // Otherwise use the indicate proxies per-scheme.
+      // Otherwise use the indicated proxies per-scheme.
       config->proxy_rules().type =
           ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
-      config->proxy_rules().proxy_for_http = proxy_for_http;
-      config->proxy_rules().proxy_for_https = proxy_for_https;
-      config->proxy_rules().proxy_for_ftp = proxy_for_ftp;
-      config->proxy_rules().fallback_proxy = socks_proxy;
+      config->proxy_rules().proxies_for_http.
+          SetSingleProxyServer(proxy_for_http);
+      config->proxy_rules().proxies_for_https.
+          SetSingleProxyServer(proxy_for_https);
+      config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_for_ftp);
+      config->proxy_rules().fallback_proxies.SetSingleProxyServer(socks_proxy);
     }
   }
 
   if (config->proxy_rules().empty()) {
     // Manual mode but we couldn't parse any rules.
     return false;
   }
 
   // Check for authentication, just so we can warn.
   bool use_auth = false;
@@ skipping 278 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net