Collect all ConnectionAttempts from both sockets in TransportConnectJob.

net/http/http_stream_factory_impl_job.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/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 278 matching lines @@
   // working.
   return origin_url_.SchemeIs("https") ||
          proxy_info_.proxy_server().is_https() || IsSpdyAlternate();
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(!stream_factory_->for_websockets_);
 
-  MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest();
+  MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   if (IsOrphaned()) {
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
     request_->Complete(was_npn_negotiated(),
                        protocol_negotiated(),
                        using_spdy(),
                        net_log_);
     request_->OnStreamReady(this, server_ssl_config_, proxy_info_,
                             stream_.release());
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnWebSocketHandshakeStreamReadyCallback() {
   DCHECK(websocket_stream_);
   DCHECK(!IsPreconnecting());
   DCHECK(stream_factory_->for_websockets_);
   // An orphaned WebSocket job will be closed immediately and
   // never be ready.
   DCHECK(!IsOrphaned());
 
-  MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest();
+  MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   request_->Complete(was_npn_negotiated(),
                      protocol_negotiated(),
                      using_spdy(),
                      net_log_);
   request_->OnWebSocketHandshakeStreamReady(this,
                                             server_ssl_config_,
                                             proxy_info_,
                                             websocket_stream_.release());
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNewSpdySessionReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
   // Note: an event loop iteration has passed, so |new_spdy_session_| may be
   // NULL at this point if the SpdySession closed immediately after creation.
   base::WeakPtr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_.reset();
 
-  MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest();
+  MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   // TODO(jgraettinger): Notify the factory, and let that notify |request_|,
   // rather than notifying |request_| directly.
   if (IsOrphaned()) {
     if (spdy_session) {
       stream_factory_->OnNewSpdySessionReady(
           spdy_session, spdy_session_direct_, server_ssl_config_, proxy_info_,
           was_npn_negotiated(), protocol_negotiated(), using_spdy(), net_log_);
     }
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
     request_->OnNewSpdySessionReady(
         this, stream_.Pass(), spdy_session, spdy_session_direct_);
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {
   DCHECK(!IsPreconnecting());
 
-  MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest();
+  MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnStreamFailed(this, result, server_ssl_config_);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(
     int result, const SSLInfo& ssl_info) {
   DCHECK(!IsPreconnecting());
 
-  MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest();
+  MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnCertificateError(this, result, server_ssl_config_, ssl_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsProxyAuthCallback(
     const HttpResponseInfo& response,
@@ skipping 1130 matching lines @@
   std::string scheme = origin_url_.scheme();
   if (scheme == "https" || scheme == "wss" || IsSpdyAlternate())
     return ClientSocketPoolManager::SSL_GROUP;
 
   if (scheme == "ftp")
     return ClientSocketPoolManager::FTP_GROUP;
 
   return ClientSocketPoolManager::NORMAL_GROUP;
 }
 
+// If the connection succeeds, failed connection attempts leading up to the
+// success will be returned via the successfully connected socket. If the
+// connection fails, failed connection attempts will be returned via the
+// ClientSocketHandle. Check whether a socket was returned and copy the
+// connection attempts from the proper place.
 void HttpStreamFactoryImpl::Job::
-    MaybeCopyConnectionAttemptsFromClientSocketHandleToRequest() {
+    MaybeCopyConnectionAttemptsFromSocketOrHandle() {
   if (IsOrphaned() || !connection_)
     return;
 
-  request_->AddConnectionAttempts(connection_->connection_attempts());
+  if (connection_->socket()) {
+    ConnectionAttempts socket_attempts;
+    connection_->socket()->GetConnectionAttempts(&socket_attempts);
+    request_->AddConnectionAttempts(socket_attempts);
+  } else {
+    request_->AddConnectionAttempts(connection_->connection_attempts());
+  }
 }
 
 }  // namespace net