Collect all ConnectionAttempts from both sockets in TransportConnectJob.

net/socket/tcp_client_socket.cc

 // Copyright (c) 2013 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/tcp_client_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "net/base/io_buffer.h"
@@ skipping 106 matching lines @@
 
   const IPEndPoint& endpoint = addresses_[current_address_index_];
 
   {
     // TODO(ricea): Remove ScopedTracker below once crbug.com/436634 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("436634 TCPClientSocket::DoConnect"));
 
     if (previously_disconnected_) {
       use_history_.Reset();
+      connection_attempts_.clear();
       previously_disconnected_ = false;
     }
 
     next_connect_state_ = CONNECT_STATE_CONNECT_COMPLETE;
 
     if (socket_->IsValid()) {
       DCHECK(bind_address_);
     } else {
       int result = OpenSocket(endpoint.GetFamily());
       if (result != OK)
@@ skipping 15 matching lines @@
                           base::Bind(&TCPClientSocket::DidCompleteConnect,
                                      base::Unretained(this)));
 }
 
 int TCPClientSocket::DoConnectComplete(int result) {
   if (result == OK) {
     use_history_.set_was_ever_connected();
     return OK;  // Done!
   }
 
+  connection_attempts_.push_back(
+      ConnectionAttempt(addresses_[current_address_index_], result));
+
   // Close whatever partially connected socket we currently have.
   DoDisconnect();
 
   // Try to fall back to the next address in the list.
   if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
     ++current_address_index_;
     return OK;
   }
 
@@ skipping 117 matching lines @@
 }
 
 bool TCPClientSocket::SetKeepAlive(bool enable, int delay) {
   return socket_->SetKeepAlive(enable, delay);
 }
 
 bool TCPClientSocket::SetNoDelay(bool no_delay) {
   return socket_->SetNoDelay(no_delay);
 }
 
+void TCPClientSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
+  *out = connection_attempts_;
+}
+
+void TCPClientSocket::ClearConnectionAttempts() {
+  connection_attempts_.clear();
+}
+
+void TCPClientSocket::AddConnectionAttempts(
+    const ConnectionAttempts& attempts) {
+  connection_attempts_.insert(connection_attempts_.begin(), attempts.begin(),
+                              attempts.end());
+}
+
 void TCPClientSocket::DidCompleteConnect(int result) {
   DCHECK_EQ(next_connect_state_, CONNECT_STATE_CONNECT_COMPLETE);
   DCHECK_NE(result, ERR_IO_PENDING);
   DCHECK(!connect_callback_.is_null());
 
   result = DoConnectLoop(result);
   if (result != ERR_IO_PENDING) {
     socket_->EndLoggingMultipleConnectAttempts(result);
     base::ResetAndReturn(&connect_callback_).Run(result);
   }
@@ skipping 17 matching lines @@
   int result = socket_->Open(family);
   if (result != OK)
     return result;
 
   socket_->SetDefaultOptionsForClient();
 
   return OK;
 }
 
 }  // namespace net