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

net/socket/transport_client_socket_pool_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 167 matching lines @@
   int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_,
                        BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle.is_initialized());
   EXPECT_FALSE(handle.socket());
 
   EXPECT_EQ(OK, callback.WaitForResult());
   EXPECT_TRUE(handle.is_initialized());
   EXPECT_TRUE(handle.socket());
   TestLoadTimingInfoConnectedNotReused(handle);
+  EXPECT_EQ(0u, handle.connection_attempts().size());
 }
 
 // Make sure that TransportConnectJob passes on its priority to its
 // HostResolver request on Init.
 TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) {
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     RequestPriority priority = static_cast<RequestPriority>(i);
     TestCompletionCallback callback;
     ClientSocketHandle handle;
     EXPECT_EQ(ERR_IO_PENDING,
               handle.Init("a", params_, priority, callback.callback(), &pool_,
                           BoundNetLog()));
     EXPECT_EQ(priority, host_resolver_->last_request_priority());
   }
 }
 
 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   HostPortPair host_port_pair("unresolvable.host.name", 80);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
       host_port_pair, false, false, OnHostResolutionCallback(),
       TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a", dest, kDefaultPriority, callback.callback(),
                         &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
+  ASSERT_EQ(1u, handle.connection_attempts().size());
+  EXPECT_TRUE(handle.connection_attempts()[0].endpoint.address().empty());
+  EXPECT_EQ(ERR_NAME_NOT_RESOLVED, handle.connection_attempts()[0].result);
 }
 
 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
   client_socket_factory_.set_default_client_socket_type(
       MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a", params_, kDefaultPriority, callback.callback(),
                         &pool_, BoundNetLog()));
   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
+  ASSERT_EQ(1u, handle.connection_attempts().size());
+  EXPECT_EQ("127.0.0.1:80",
+            handle.connection_attempts()[0].endpoint.ToString());
+  EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);
 
   // Make the host resolutions complete synchronously this time.
   host_resolver_->set_synchronous_mode(true);
   EXPECT_EQ(ERR_CONNECTION_FAILED,
             handle.Init("a", params_, kDefaultPriority, callback.callback(),
                         &pool_, BoundNetLog()));
+  ASSERT_EQ(1u, handle.connection_attempts().size());
+  EXPECT_EQ("127.0.0.1:80",
+            handle.connection_attempts()[0].endpoint.ToString());
+  EXPECT_EQ(ERR_CONNECTION_FAILED, handle.connection_attempts()[0].result);
 }
 
 TEST_F(TransportClientSocketPoolTest, PendingRequests) {
   // First request finishes asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
   EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
 
   // Make all subsequent host resolutions complete synchronously.
   host_resolver_->set_synchronous_mode(true);
 
@@ skipping 848 matching lines @@
   handle.socket()->GetLocalAddress(&endpoint);
   EXPECT_EQ(kIPv6AddressSize, endpoint.address().size());
   EXPECT_EQ(1, client_socket_factory_.allocation_count());
   // Verify that TCP FastOpen was not turned on for the socket.
   EXPECT_FALSE(handle.socket()->UsingTCPFastOpen());
 }
 
 }  // namespace
 
 }  // namespace net