Correct manual proxy selection for WebSockets.

net/proxy/proxy_config.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.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/values.h"
@@ skipping 112 matching lines @@
       // is not a URL scheme. Rather this means "for everything else, send
       // it to the SOCKS proxy server XXX".
       if (url_scheme == "socks") {
         DCHECK(!entry);
         entry = &fallback_proxies;
         // Note that here 'socks' is understood to be SOCKS4, even though
         // 'socks' maps to SOCKS5 in ProxyServer::GetSchemeFromURIInternal.
         default_scheme = ProxyServer::SCHEME_SOCKS4;
       }
 
       if (entry) {

[tyoshino (SeeGerritForStatus), 2014/10/27 15:28:29]

before this change, MapUrlSchemeToProxyListNoFallback() returned NULL for
entries with ws/wss at the scheme field. now it returns the result of
GetProxyListForWebSocketScheme().

we should keep the current behavior for this function, I think.

so, hmm, maybe it's good to just define one for parsing and another for
applying. Only the latter will have the conditions at L173 below.

[Adam Rice, 2014/10/28 02:22:23]

Thank you for catching this.

         AddProxyURIListToProxyList(proxy_server_for_scheme.token(),
                                    entry,
                                    default_scheme);
       }
     }
   }
 }
 
 const ProxyList* ProxyConfig::ProxyRules::MapUrlSchemeToProxyList(
     const std::string& url_scheme) const {
@@ skipping 19 matching lines @@
 
 ProxyList* ProxyConfig::ProxyRules::MapUrlSchemeToProxyListNoFallback(
     const std::string& scheme) {
   DCHECK_EQ(TYPE_PROXY_PER_SCHEME, type);
   if (scheme == "http")
     return &proxies_for_http;
   if (scheme == "https")
     return &proxies_for_https;
   if (scheme == "ftp")
     return &proxies_for_ftp;
+  if (scheme == "ws" || scheme == "wss")
+    return GetProxyListForWebSocketScheme();
   return NULL;  // No mapping for this scheme.
 }
 
+ProxyList* ProxyConfig::ProxyRules::GetProxyListForWebSocketScheme() {
+  if (!fallback_proxies.IsEmpty())
+    return &fallback_proxies;
+  if (!proxies_for_https.IsEmpty())
+    return &proxies_for_https;
+  if (!proxies_for_http.IsEmpty())
+    return &proxies_for_http;
+  return NULL;
+}
+
 ProxyConfig::ProxyConfig()
     : auto_detect_(false), pac_mandatory_(false),
       source_(PROXY_CONFIG_SOURCE_UNKNOWN), id_(kInvalidConfigID)  {
 }
 
 ProxyConfig::ProxyConfig(const ProxyConfig& config)
     : auto_detect_(config.auto_detect_),
       pac_url_(config.pac_url_),
       pac_mandatory_(config.pac_mandatory_),
       proxy_rules_(config.proxy_rules_),
@@ skipping 82 matching lines @@
     }
   }
 
   // Output the source.
   dict->SetString("source", ProxyConfigSourceToString(source_));
 
   return dict;
 }
 
 }  // namespace net