Collect all ConnectionAttempts from both sockets in TransportConnectJob.

net/socket/client_socket_pool_base.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/client_socket_pool_base.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
@@ skipping 471 matching lines @@
         base::TimeTicks::Now() - idle_socket_it->start_time;
     IdleSocket idle_socket = *idle_socket_it;
     idle_sockets->erase(idle_socket_it);
     // TODO(davidben): If |idle_time| is under some low watermark, consider
     // treating as UNUSED rather than UNUSED_IDLE. This will avoid
     // HttpNetworkTransaction retrying on some errors.
     ClientSocketHandle::SocketReuseType reuse_type =
         idle_socket.socket->WasEverUsed() ?
             ClientSocketHandle::REUSED_IDLE :
             ClientSocketHandle::UNUSED_IDLE;
+
+    // If this socket took multiple attempts to obtain, don't report those
+    // every time it's reused, just to the first user.
+    if (idle_socket.socket->WasEverUsed())
+      idle_socket.socket->ClearConnectionAttempts();

[Randy Smith (Not in Mondays), 2015/05/12 20:11:09]

I have a bit of a twitch here, which I'll give voice to and let you do what you
want.  From a pure truth&beauty API perspective, the re-use of the socket isn't
really something that the socket itself should be thinking about.  It's
connected, it's used for a while, it's destroyed, that's all she wrote.  I'm
solidly aware that that abstraction layer is already being violated, but I'll
call out that were I in an ideal world, I'd want to keep it clean, and maybe
export an operator to clear the connection attempts, or maybe just making
retrieving the connection attempts clear them so that this behavior
automatically happens.

Actually, ok, real question, why isn't that what happens?  Why do we need to
clear connection attempts; won't they always be cleared by retrieval by the
first consumer?

[Deprecated (see juliatuttle), 2015/05/13 18:22:28]

The socket isn't concerned about it, the socket pool is. The socket is,
unfortunately, also a conduit for the connection attempts, so it needs to have
the Add and Clear methods to allow the ConnectJob and SocketPoolBase,
respectively, to ensure the new owner of the socket sees the right set of
attempts.
GetConnectionAttempts does not clear them.

If you think it would be prettier, I could make it so that the
ClientSocketHandle clears the attempts on the socket after copying them.

+
     HandOutSocket(
         scoped_ptr<StreamSocket>(idle_socket.socket),
         reuse_type,
         LoadTimingInfo::ConnectTiming(),
         request.handle(),
         idle_time,
         group,
         request.net_log());
     return true;
   }
@@ skipping 829 matching lines @@
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   request->CrashIfInvalid();
   return request.Pass();
 }
 
 }  // namespace internal
 
 }  // namespace net