Merge 84251, 85083, 85188, 85375.

net/socket/transport_client_socket_pool.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_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 #pragma once
 
 #include <string>
 
@@ skipping 30 matching lines @@
   void Initialize(RequestPriority priority, const GURL& referrer,
                   bool disable_resolver_cache);
 
   HostResolver::RequestInfo destination_;
   bool ignore_limits_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
 };
 
 // TransportConnectJob handles the host resolution necessary for socket creation
-// and the transport (likely TCP) connect.
+// and the transport (likely TCP) connect. TransportConnectJob also has fallback
+// logic for IPv6 connect() timeouts (which may happen due to networks / routers
+// with broken IPv6 support). Those timeouts take 20s, so rather than make the
+// user wait 20s for the timeout to fire, we use a fallback timer
+// (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer
+// fires. Then we race the IPv4 connect() against the IPv6 connect() (which has
+// a headstart) and return the one that completes first to the socket pool.
 class TransportConnectJob : public ConnectJob {
  public:
   TransportConnectJob(const std::string& group_name,
-                const scoped_refptr<TransportSocketParams>& params,
-                base::TimeDelta timeout_duration,
-                ClientSocketFactory* client_socket_factory,
-                HostResolver* host_resolver,
-                Delegate* delegate,
-                NetLog* net_log);
+                      const scoped_refptr<TransportSocketParams>& params,
+                      base::TimeDelta timeout_duration,
+                      ClientSocketFactory* client_socket_factory,
+                      HostResolver* host_resolver,
+                      Delegate* delegate,
+                      NetLog* net_log);
   virtual ~TransportConnectJob();
 
   // ConnectJob methods.
   virtual LoadState GetLoadState() const;
 
+  // Makes |addrlist| start with an IPv4 address if |addrlist| contains any
+  // IPv4 address.
+  //
+  // WARNING: this method should only be used to implement the prefer-IPv4
+  // hack.  It is a public method for the unit tests.
+  static void MakeAddrListStartWithIPv4(AddressList* addrlist);
+
+  static const int kIPv6FallbackTimerInMs;
+
  private:
   enum State {
     STATE_RESOLVE_HOST,
     STATE_RESOLVE_HOST_COMPLETE,
     STATE_TRANSPORT_CONNECT,
     STATE_TRANSPORT_CONNECT_COMPLETE,
     STATE_NONE,
   };
 
   void OnIOComplete(int result);
 
   // Runs the state transition loop.
   int DoLoop(int result);
 
   int DoResolveHost();
   int DoResolveHostComplete(int result);
   int DoTransportConnect();
   int DoTransportConnectComplete(int result);
 
+  // Not part of the state machine.
+  void DoIPv6FallbackTransportConnect();
+  void DoIPv6FallbackTransportConnectComplete(int result);
+
   // Begins the host resolution and the TCP connect.  Returns OK on success
   // and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
   virtual int ConnectInternal();
 
   scoped_refptr<TransportSocketParams> params_;
   ClientSocketFactory* const client_socket_factory_;
   CompletionCallbackImpl<TransportConnectJob> callback_;
   SingleRequestHostResolver resolver_;
   AddressList addresses_;
   State next_state_;
 
   // The time Connect() was called.
   base::TimeTicks start_time_;
 
   // The time the connect was started (after DNS finished).
   base::TimeTicks connect_start_time_;
 
+  scoped_ptr<ClientSocket> transport_socket_;
+
+  scoped_ptr<ClientSocket> fallback_transport_socket_;
+  scoped_ptr<AddressList> fallback_addresses_;
+  CompletionCallbackImpl<TransportConnectJob> fallback_callback_;
+  base::TimeTicks fallback_connect_start_time_;
+  base::OneShotTimer<TransportConnectJob> fallback_timer_;
+
   DISALLOW_COPY_AND_ASSIGN(TransportConnectJob);
 };
 
 class TransportClientSocketPool : public ClientSocketPool {
  public:
   TransportClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
       ClientSocketPoolHistograms* histograms,
       HostResolver* host_resolver,
@@ skipping 78 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool);
 };
 
 REGISTER_SOCKET_PARAMS_FOR_POOL(TransportClientSocketPool,
                                 TransportSocketParams);
 
 }  // namespace net
 
 #endif  // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_