Implement support for QUIC proxies in ProxyServer

net/proxy/proxy_server.h

 // Copyright (c) 2011 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_SERVER_H_
 #define NET_PROXY_PROXY_SERVER_H_
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
@@ skipping 13 matching lines @@
   // The type of proxy. These are defined as bit flags so they can be ORed
   // together to pass as the |scheme_bit_field| argument to
   // ProxyService::RemoveProxiesWithoutScheme().
   enum Scheme {
     SCHEME_INVALID = 1 << 0,
     SCHEME_DIRECT  = 1 << 1,
     SCHEME_HTTP    = 1 << 2,
     SCHEME_SOCKS4  = 1 << 3,
     SCHEME_SOCKS5  = 1 << 4,
     SCHEME_HTTPS   = 1 << 5,
+    // A QUIC proxy is an HTTP proxy in which QUIC is used as the transport,
+    // instead of TCP.
+    SCHEME_QUIC    = 1 << 6,
   };
 
   // Default copy-constructor and assignment operator are OK!
 
   // Constructs an invalid ProxyServer.
   ProxyServer() : scheme_(SCHEME_INVALID) {}
 
   ProxyServer(Scheme scheme, const HostPortPair& host_port_pair);
 
   bool is_valid() const { return scheme_ != SCHEME_INVALID; }
 
   // Gets the proxy's scheme (i.e. SOCKS4, SOCKS5, HTTP)
   Scheme scheme() const { return scheme_; }
 
   // Returns true if this ProxyServer is actually just a DIRECT connection.
   bool is_direct() const { return scheme_ == SCHEME_DIRECT; }
 
   // Returns true if this ProxyServer is an HTTP proxy.
   bool is_http() const { return scheme_ == SCHEME_HTTP; }
 
   // Returns true if this ProxyServer is an HTTPS proxy.
   bool is_https() const { return scheme_ == SCHEME_HTTPS; }
 
   // Returns true if this ProxyServer is a SOCKS proxy.
   bool is_socks() const {
     return scheme_ == SCHEME_SOCKS4 || scheme_ == SCHEME_SOCKS5;
   }
 
+  // Returns true if this ProxyServer is a QUIC proxy.
+  bool is_quic() const { return scheme_ == SCHEME_QUIC; }
+
   const HostPortPair& host_port_pair() const;
 
   // Parses from an input with format:
   //   [<scheme>"://"]<server>[":"<port>]
   //
   // Both <scheme> and <port> are optional. If <scheme> is omitted, it will be
   // assumed as |default_scheme|. If <port> is omitted, it will be assumed as
   // the default port for the chosen scheme (80 for "http", 1080 for "socks").
   //
   // If parsing fails the instance will be set to invalid.
   //
   // Examples (for |default_scheme| = SCHEME_HTTP ):
   //   "foopy"            {scheme=HTTP, host="foopy", port=80}
   //   "socks://foopy"    {scheme=SOCKS5, host="foopy", port=1080}
   //   "socks4://foopy"   {scheme=SOCKS4, host="foopy", port=1080}
   //   "socks5://foopy"   {scheme=SOCKS5, host="foopy", port=1080}
   //   "http://foopy:17"  {scheme=HTTP, host="foopy", port=17}
   //   "https://foopy:17" {scheme=HTTPS, host="foopy", port=17}
+  //   "quic://foopy:17"  {scheme=QUIC, host="foopy", port=17}
   //   "direct://"        {scheme=DIRECT}
   //   "foopy:X"          INVALID -- bad port.
   static ProxyServer FromURI(const std::string& uri, Scheme default_scheme);
   static ProxyServer FromURI(std::string::const_iterator uri_begin,
                              std::string::const_iterator uri_end,
                              Scheme default_scheme);
 
   // Formats as a URI string. This does the reverse of FromURI.
   std::string ToURI() const;
 
   // Parses from a PAC string result.
   //
   // If <port> is omitted, it will be assumed as the default port for the
   // chosen scheme (80 for "http", 1080 for "socks").
   //
   // If parsing fails the instance will be set to invalid.
   //
   // Examples:
   //   "PROXY foopy:19"   {scheme=HTTP, host="foopy", port=19}
   //   "DIRECT"           {scheme=DIRECT}
   //   "SOCKS5 foopy"     {scheme=SOCKS5, host="foopy", port=1080}
   //   "HTTPS foopy:123"  {scheme=HTTPS, host="foopy", port=123}
+  //   "QUIC foopy:123"   {scheme=QUIC, host="foopy", port=123}
   //   "BLAH xxx:xx"      INVALID
   static ProxyServer FromPacString(const std::string& pac_string);
   static ProxyServer FromPacString(std::string::const_iterator pac_string_begin,
                                    std::string::const_iterator pac_string_end);
 
   // Returns a ProxyServer representing DIRECT connections.
   static ProxyServer Direct() {
     return ProxyServer(SCHEME_DIRECT, HostPortPair());
   }
 
@@ skipping 52 matching lines @@
 
   Scheme scheme_;
   HostPortPair host_port_pair_;
 };
 
 typedef std::pair<HostPortPair, ProxyServer> HostPortProxyPair;
 
 }  // namespace net
 
 #endif  // NET_PROXY_PROXY_SERVER_H_