Plumb connection attempts from (non-proxy) ConnectJobs to HttpNetworkTransaction.

net/socket/transport_client_socket_pool.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/socket/transport_client_socket_pool.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 183 matching lines @@
 
 TransportConnectJob::TransportConnectJob(
     const std::string& group_name,
     RequestPriority priority,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
-    : ConnectJob(group_name, timeout_duration, priority, delegate,
+    : ConnectJob(group_name,
+                 timeout_duration,
+                 priority,
+                 delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       helper_(params, client_socket_factory, host_resolver, &connect_timing_),
-      interval_between_connects_(CONNECT_INTERVAL_GT_20MS) {
+      interval_between_connects_(CONNECT_INTERVAL_GT_20MS),
+      connect_result_(OK) {
   helper_.SetOnIOComplete(this);
 }
 
 TransportConnectJob::~TransportConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
   // ~SingleRequestHostResolver and ~StreamSocket will take care of it.
 }
 
 LoadState TransportConnectJob::GetLoadState() const {
   switch (helper_.next_state()) {
     case TransportConnectJobHelper::STATE_RESOLVE_HOST:
     case TransportConnectJobHelper::STATE_RESOLVE_HOST_COMPLETE:
       return LOAD_STATE_RESOLVING_HOST;
     case TransportConnectJobHelper::STATE_TRANSPORT_CONNECT:
     case TransportConnectJobHelper::STATE_TRANSPORT_CONNECT_COMPLETE:
       return LOAD_STATE_CONNECTING;
     case TransportConnectJobHelper::STATE_NONE:
       return LOAD_STATE_IDLE;
   }
   NOTREACHED();
   return LOAD_STATE_IDLE;
 }
 
+void TransportConnectJob::GetAdditionalErrorState(ClientSocketHandle* handle) {
+  if (connect_result_ == OK)
+    return;
+
+  // If the actual socket Connect call failed, record the result and the last
+  // address attempted.
+  // TODO(ttuttle): Plumb into the socket layer and record *all* attempts.
+  DCHECK_LT(0u, helper_.addresses().size());
+  ConnectionAttempts attempts;
+  attempts.push_back(
+      ConnectionAttempt(helper_.addresses().back(), connect_result_));
+  handle->set_connection_attempts(attempts);
+}
+
 // static
 void TransportConnectJob::MakeAddressListStartWithIPv4(AddressList* list) {
   for (AddressList::iterator i = list->begin(); i != list->end(); ++i) {
     if (i->GetFamily() == ADDRESS_FAMILY_IPV4) {
       std::rotate(list->begin(), i, list->end());
       break;
     }
   }
 }
 
@@ skipping 112 matching lines @@
     }
 
     SetSocket(transport_socket_.Pass());
     fallback_timer_.Stop();
   } else {
     // Be a bit paranoid and kill off the fallback members to prevent reuse.
     fallback_transport_socket_.reset();
     fallback_addresses_.reset();
   }
 
+  connect_result_ = result;
+
   return result;
 }
 
 void TransportConnectJob::DoIPv6FallbackTransportConnect() {
   // The timer should only fire while we're waiting for the main connect to
   // succeed.
   if (helper_.next_state() !=
       TransportConnectJobHelper::STATE_TRANSPORT_CONNECT_COMPLETE) {
     NOTREACHED();
     return;
@@ skipping 190 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net