Collect all ConnectionAttempts from both sockets in TransportConnectJob.

net/socket/transport_client_socket_pool_test_util.cc

 // Copyright 2014 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_test_util.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 51 matching lines @@
   const BoundNetLog& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override { use_tcp_fastopen_ = true; }
   bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
+  void GetConnectionAttempts(ConnectionAttempts* out) const override {
+    out->clear();
+  }
+  void ClearConnectionAttempts() override {}
+  void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
 
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   int Write(IOBuffer* buf,
             int buf_len,
             const CompletionCallback& callback) override {
@@ skipping 36 matching lines @@
   const BoundNetLog& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override { use_tcp_fastopen_ = true; }
   bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
+  void GetConnectionAttempts(ConnectionAttempts* out) const override {
+    out->clear();
+    for (const auto& addr : addrlist_)
+      out->push_back(ConnectionAttempt(addr, ERR_CONNECTION_FAILED));
+  }
+  void ClearConnectionAttempts() override {}
+  void AddConnectionAttempts(const ConnectionAttempts& attempts) override {}
 
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   int Write(IOBuffer* buf,
             int buf_len,
@@ skipping 51 matching lines @@
       net::NetLog* net_log) {
     scoped_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, should_connect, net_log));
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, socket->GetConnectCallback(), delay);
     return socket.Pass();
   }
 
   static scoped_ptr<StreamSocket> MakeMockStalledClientSocket(
       const AddressList& addrlist,
-      net::NetLog* net_log) {
+      net::NetLog* net_log,
+      bool failing) {
     scoped_ptr<MockTriggerableClientSocket> socket(
         new MockTriggerableClientSocket(addrlist, true, net_log));
+    if (failing) {
+      DCHECK_LE(1u, addrlist.size());
+      ConnectionAttempts attempts;
+      attempts.push_back(ConnectionAttempt(addrlist[0], ERR_CONNECTION_FAILED));
+      socket->AddConnectionAttempts(attempts);
+    }
     return socket.Pass();
   }
 
   // StreamSocket implementation.
   int Connect(const CompletionCallback& callback) override {
     DCHECK(callback_.is_null());
     callback_ = callback;
     return ERR_IO_PENDING;
   }
 
@@ skipping 17 matching lines @@
   const BoundNetLog& NetLog() const override { return net_log_; }
 
   void SetSubresourceSpeculation() override {}
   void SetOmniboxSpeculation() override {}
   bool WasEverUsed() const override { return false; }
   void EnableTCPFastOpenIfSupported() override { use_tcp_fastopen_ = true; }
   bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
   bool WasNpnNegotiated() const override { return false; }
   NextProto GetNegotiatedProtocol() const override { return kProtoUnknown; }
   bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
+  void GetConnectionAttempts(ConnectionAttempts* out) const override {
+    *out = connection_attempts_;
+  }
+  void ClearConnectionAttempts() override { connection_attempts_.clear(); }
+  void AddConnectionAttempts(const ConnectionAttempts& attempts) override {
+    connection_attempts_.insert(connection_attempts_.begin(), attempts.begin(),
+                                attempts.end());
+  }
 
   // Socket implementation.
   int Read(IOBuffer* buf,
            int buf_len,
            const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   int Write(IOBuffer* buf,
             int buf_len,
             const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   int SetReceiveBufferSize(int32 size) override { return OK; }
   int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   void DoCallback() {
     is_connected_ = should_connect_;
     callback_.Run(is_connected_ ? OK : ERR_CONNECTION_FAILED);
   }
 
   bool should_connect_;
   bool is_connected_;
   const AddressList addrlist_;
   BoundNetLog net_log_;
   CompletionCallback callback_;
   bool use_tcp_fastopen_;
+  ConnectionAttempts connection_attempts_;
 
   base::WeakPtrFactory<MockTriggerableClientSocket> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTriggerableClientSocket);
 };
 
 }  // namespace
 
 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
   LoadTimingInfo load_timing_info;
@@ skipping 80 matching lines @@
     case MOCK_PENDING_FAILING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockPendingClientSocket(
           addresses, false, net_log_);
     case MOCK_DELAYED_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
           addresses, true, delay_, net_log_);
     case MOCK_DELAYED_FAILING_CLIENT_SOCKET:
       return MockTriggerableClientSocket::MakeMockDelayedClientSocket(
           addresses, false, delay_, net_log_);
     case MOCK_STALLED_CLIENT_SOCKET:
-      return MockTriggerableClientSocket::MakeMockStalledClientSocket(addresses,
-                                                                      net_log_);
+      return MockTriggerableClientSocket::MakeMockStalledClientSocket(
+          addresses, net_log_, false);
+    case MOCK_STALLED_FAILING_CLIENT_SOCKET:
+      return MockTriggerableClientSocket::MakeMockStalledClientSocket(
+          addresses, net_log_, true);
     case MOCK_TRIGGERABLE_CLIENT_SOCKET: {
       scoped_ptr<MockTriggerableClientSocket> rv(
           new MockTriggerableClientSocket(addresses, true, net_log_));
       triggerable_sockets_.push(rv->GetConnectCallback());
       // run_loop_quit_closure_ behaves like a condition variable. It will
       // wake up WaitForTriggerableSocketCreation() if it is sleeping. We
       // don't need to worry about atomicity because this code is
       // single-threaded.
       if (!run_loop_quit_closure_.is_null())
         run_loop_quit_closure_.Run();
@@ skipping 36 matching lines @@
     run_loop_quit_closure_ = run_loop.QuitClosure();
     run_loop.Run();
     run_loop_quit_closure_.Reset();
   }
   base::Closure trigger = triggerable_sockets_.front();
   triggerable_sockets_.pop();
   return trigger;
 }
 
 }  // namespace net