Fix Net.Socket.IdleSocketTimeSaving histogram

net/socket/client_socket_pool_base_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/client_socket_pool_base.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 45 matching lines @@
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace net {
 
 namespace {
 
 const int kDefaultMaxSockets = 4;
 const int kDefaultMaxSocketsPerGroup = 2;
 const char kIdleSocketFateHistogram[] = "Net.Socket.IdleSocketFate";
+const char kIdleSocketTimeSavingHistogram[] =
+    "Net.Socket.IdleSocketTimeSaving2";
 
 // Make sure |handle| sets load times correctly when it has been assigned a
 // reused socket.
 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
   LoadTimingInfo load_timing_info;
   // Only pass true in as |is_reused|, as in general, HttpStream types should
   // have stricter concepts of reuse than socket pools.
   EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
 
   EXPECT_EQ(true, load_timing_info.socket_reused);
@@ skipping 453 matching lines @@
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 
     base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
   }
 
   void CancelRequest(const std::string& group_name,
                      ClientSocketHandle* handle) override {
     base_.CancelRequest(group_name, handle);
   }
 
-  void ReleaseSocket(const std::string& group_name,
-                     std::unique_ptr<StreamSocket> socket,
-                     int id) override {
-    base_.ReleaseSocket(group_name, std::move(socket), id);
+  void ReleaseSocket(
+      const std::string& group_name,
+      std::unique_ptr<StreamSocket> socket,
+      int id,
+      const LoadTimingInfo::ConnectTiming& connect_timing) override {
+    base_.ReleaseSocket(group_name, std::move(socket), id, connect_timing);
   }
 
   void FlushWithError(int error) override { base_.FlushWithError(error); }
 
   bool IsStalled() const override { return base_.IsStalled(); }
 
   void CloseIdleSockets() override { base_.CloseIdleSockets(); }
 
   int IdleSocketCount() const override { return base_.idle_socket_count(); }
 
@@ skipping 333 matching lines @@
 
   EXPECT_THAT(StartRequest("e", DEFAULT_PRIORITY), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("f", DEFAULT_PRIORITY), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("g", DEFAULT_PRIORITY), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 7)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
   EXPECT_EQ(5, GetOrderOfRequest(5));
@@ skipping 21 matching lines @@
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   // Now create a new group and verify that we don't starve it.
   EXPECT_THAT(StartRequest("c", DEFAULT_PRIORITY), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 5)));
 
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
+
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
   EXPECT_EQ(5, GetOrderOfRequest(5));
 
@@ skipping 14 matching lines @@
             client_socket_factory_.allocation_count());
 
   EXPECT_THAT(StartRequest("c", LOWEST), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("b", HIGHEST), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 7)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   // First 4 requests don't have to wait, and finish in order.
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
 
   // Request ("b", HIGHEST) has the highest priority, then ("a", MEDIUM),
@@ skipping 19 matching lines @@
             client_socket_factory_.allocation_count());
 
   EXPECT_THAT(StartRequest("c", MEDIUM), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("b", HIGHEST), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 7)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 
   // First 4 requests don't have to wait, and finish in order.
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
@@ skipping 31 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // The next synchronous request should wait for its turn.
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
   EXPECT_THAT(StartRequest("e", DEFAULT_PRIORITY), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 5)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
   EXPECT_EQ(5, GetOrderOfRequest(5));
 
@@ skipping 29 matching lines @@
   EXPECT_THAT(
       histograms.GetAllSamples(kIdleSocketFateHistogram),
       testing::ElementsAre(base::Bucket(/*IDLE_SOCKET_FATE_CLOSE_ONE=*/8, 2)));
   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
   EXPECT_THAT(
       histograms.GetAllSamples(kIdleSocketFateHistogram),
       testing::ElementsAre(base::Bucket(/*IDLE_SOCKET_FATE_CLOSE_ONE=*/8, 2)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 }
 
 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
 
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a", params_, DEFAULT_PRIORITY,
@@ skipping 175 matching lines @@
   // which is the one which we would close an idle socket for.  We shouldn't
   // close an idle socket though, since we should reuse the idle socket.
   EXPECT_EQ(OK,
             handle.Init("0", params_, DEFAULT_PRIORITY,
                         ClientSocketPool::RespectLimits::ENABLED,
                         callback.callback(), pool_.get(), NetLogWithSource()));
 
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_REUSE_UNUSED=*/1, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
   EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
 }
 
 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
   base::HistogramTester histograms;
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk());
   EXPECT_THAT(StartRequest("a", DEFAULT_PRIORITY), IsOk());
   EXPECT_THAT(StartRequest("a", IDLE), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", MEDIUM), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", HIGHEST), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", LOW), IsError(ERR_IO_PENDING));
   EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
   // 2 sockets reused for last 6 requests.
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_REUSE_UNUSED=*/1, 6)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
             completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(8, GetOrderOfRequest(3));
   EXPECT_EQ(6, GetOrderOfRequest(4));
@@ skipping 19 matching lines @@
   EXPECT_THAT(StartRequest("a", LOWEST), IsError(ERR_IO_PENDING));
 
   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 
   for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i)
     EXPECT_THAT(request(i)->WaitForResult(), IsOk());
 
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABE=*/3, 7)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
   EXPECT_EQ(static_cast<int>(requests_size()),
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
             completion_count());
 }
 
 // This test will start up a RequestSocket() and then immediately Cancel() it.
 // The pending connect job will be cancelled and should not call back into
 // ClientSocketPoolBase.
 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
@@ skipping 50 matching lines @@
   // Cancel a request.
   size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2;
   EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
   (*requests())[index_to_cancel]->handle()->Reset();
 
   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
   // 2 sockets reused for 4 requests.
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_REUSE_UNUSED=*/1, 4)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
             client_socket_factory_.allocation_count());
   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup - 1,
             completion_count());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(5, GetOrderOfRequest(3));
   EXPECT_EQ(3, GetOrderOfRequest(4));
@@ skipping 164 matching lines @@
   int rv = handle.Init("a", params_, LOWEST,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), pool_.get(), log.bound());
   EXPECT_THAT(rv, IsOk());
   handle.Reset();
   EXPECT_EQ(1, pool_->IdleSocketCount());
   pool_->CloseIdleSockets();
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_FORCED=*/4, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 }
 
 TEST_F(ClientSocketPoolBaseTest, CleanUpUnusableIdleSockets) {
   base::HistogramTester histograms;
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   int rv = handle.Init("a", params_, LOWEST,
                        ClientSocketPool::RespectLimits::ENABLED,
                        callback.callback(), pool_.get(), log.bound());
   EXPECT_THAT(rv, IsOk());
   StreamSocket* socket = handle.socket();
   handle.Reset();
   EXPECT_EQ(1, pool_->IdleSocketCount());
 
   // Disconnect socket now to make the socket unusable.
   socket->Disconnect();
   ClientSocketHandle handle2;
   rv = handle2.Init("a", params_, LOWEST,
                     ClientSocketPool::RespectLimits::ENABLED,
                     callback.callback(), pool_.get(), log.bound());
   EXPECT_THAT(rv, IsOk());
   EXPECT_FALSE(handle2.is_reused());
 
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_UNUSABLE=*/7, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 }
 
 // Regression test for http://crbug.com/17985.
 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
   base::HistogramTester histograms;
   const int kMaxSockets = 3;
   const int kMaxSocketsPerGroup = 2;
   CreatePool(kMaxSockets, kMaxSocketsPerGroup);
 
   const RequestPriority kHighPriority = HIGHEST;
@@ skipping 29 matching lines @@
   // we were hitting a CHECK here.
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   pool_->CloseIdleSockets();
 
   // Run the released socket wakeups.
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(
       histograms.GetAllSamples(kIdleSocketFateHistogram),
       testing::ElementsAre(base::Bucket(/*IDLE_SOCKET_FATE_REUSE_UNUSED=*/1, 1),
                            base::Bucket(/*IDLE_SOCKET_FATE_CLOSE_ONE=*/8, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 }
 
 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 
   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
   ClientSocketHandle handle;
   TestCompletionCallback callback;
   BoundTestNetLog log;
   int rv = handle.Init("a", params_, LOWEST,
@@ skipping 502 matching lines @@
   ASSERT_THAT(rv, IsOk());
   EXPECT_TRUE(handle.is_reused());
   TestLoadTimingInfoConnectedReused(handle);
 
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_REUSE_REUSED=*/0, 1)));
+  auto buckets = histograms.GetAllSamples(kIdleSocketTimeSavingHistogram);
+  EXPECT_EQ(1u, buckets.size());
+  // The sample should be strictly greater than 0 because kPendingConnectDelay
+  // is used.
+  EXPECT_LT(0, buckets[0].min);
+  EXPECT_EQ(1, buckets[0].count);
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
+  EXPECT_TRUE(LogContainsEntryWithType(
+      entries, 1, NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
+}
+
+// Tests when idle socket are reused multiple times, histograms are correct.
+TEST_F(ClientSocketPoolBaseTest, IdleSocketsReusedTwice) {
+  base::HistogramTester histograms;
+  CreatePoolWithIdleTimeouts(
+      kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
+      base::TimeDelta(),              // Time out unused sockets immediately.
+      base::TimeDelta::FromDays(1));  // Don't time out used sockets.
+
+  connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
+
+  ClientSocketHandle handle;
+  TestCompletionCallback callback;
+  int rv = handle.Init("a", params_, LOWEST,
+                       ClientSocketPool::RespectLimits::ENABLED,
+                       callback.callback(), pool_.get(), NetLogWithSource());
+  ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
+  EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
+  ASSERT_THAT(callback.WaitForResult(), IsOk());
+
+  // Use and release the socket.
+  EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback()));
+  TestLoadTimingInfoConnectedNotReused(handle);
+  handle.Reset();
+
+  // Should now have one idle socket.
+  ASSERT_EQ(1, pool_->IdleSocketCount());
+
+  // Request a new socket. This should reuse the old socket and complete
+  // synchronously.
+  BoundTestNetLog log;
+  rv = handle.Init("a", params_, LOWEST,
+                   ClientSocketPool::RespectLimits::ENABLED,
+                   CompletionCallback(), pool_.get(), log.bound());
+  ASSERT_THAT(rv, IsOk());
+  EXPECT_TRUE(handle.is_reused());
+  TestLoadTimingInfoConnectedReused(handle);
+  // Both reuse should fall into the same bucket since they share the same
+  // connect timing.
+  auto buckets = histograms.GetAllSamples(kIdleSocketTimeSavingHistogram);
+  EXPECT_EQ(1u, buckets.size());
+  // The sample should be strictly greater than 0 because kPendingConnectDelay
+  // is used.
+  EXPECT_LT(0, buckets[0].min);
+  EXPECT_EQ(1, buckets[0].count);
+
+  // Releases socket.
+  handle.Reset();
+
+  // Request a socket again. This should reuse the old socket and complete
+  // synchronously.
+  ClientSocketHandle handle2;
+  rv = handle2.Init("a", params_, LOWEST,
+                    ClientSocketPool::RespectLimits::ENABLED,
+                    CompletionCallback(), pool_.get(), log.bound());
+  ASSERT_THAT(rv, IsOk());
+  EXPECT_TRUE(handle2.is_reused());
+  TestLoadTimingInfoConnectedReused(handle2);
+
+  ASSERT_TRUE(pool_->HasGroup("a"));
+  EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
+  EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
+  EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
+              testing::ElementsAre(
+                  base::Bucket(/*IDLE_SOCKET_FATE_REUSE_REUSED=*/0, 2)));
+  // Both reuse should fall into the same bucket since they share the same
+  // connect timing.
+  buckets = histograms.GetAllSamples(kIdleSocketTimeSavingHistogram);
+  EXPECT_EQ(1u, buckets.size());
+  EXPECT_LT(0, buckets[0].min);
+  EXPECT_EQ(2, buckets[0].count);
+
+  TestNetLogEntry::List entries;
+  log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEntryWithType(
       entries, 1, NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
 }
 
 #if defined(OS_IOS)
 // TODO(droger): Enable this test (crbug.com/512595).
 #define MAYBE_CleanupTimedOutIdleSocketsNoReuse \
   DISABLED_CleanupTimedOutIdleSocketsNoReuse
 #else
 #define MAYBE_CleanupTimedOutIdleSocketsNoReuse \
@@ skipping 57 matching lines @@
                    callback3.callback(), pool_.get(), log.bound());
   ASSERT_THAT(rv, IsError(ERR_IO_PENDING));
   ASSERT_THAT(callback3.WaitForResult(), IsOk());
   EXPECT_FALSE(handle.is_reused());
 
   EXPECT_THAT(
       histograms.GetAllSamples(kIdleSocketFateHistogram),
       testing::ElementsAre(
           base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_TIMED_OUT_REUSED=*/5, 1),
           base::Bucket(/*IDLE_SOCKET_FATE_CLEAN_UP_TIMED_OUT_UNUSED=*/6, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   // Make sure the idle socket is closed.
   ASSERT_TRUE(pool_->HasGroup("a"));
   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
 
   TestNetLogEntry::List entries;
   log.GetEntries(&entries);
   EXPECT_FALSE(LogContainsEntryWithType(
       entries, 1, NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
@@ skipping 142 matching lines @@
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 1)));
 
   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
   EXPECT_THAT((*requests())[3]->WaitForResult(), IsOk());
   EXPECT_EQ(4u, completion_count());
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 2)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 
   EXPECT_EQ(1, GetOrderOfRequest(1));
   EXPECT_EQ(2, GetOrderOfRequest(2));
   EXPECT_EQ(3, GetOrderOfRequest(3));
   EXPECT_EQ(4, GetOrderOfRequest(4));
 
   // Make sure we test order of all requests made.
   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5));
 }
 
@@ skipping 1194 matching lines @@
 
   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
   EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
       .WillOnce(Invoke(&mock_layered_pool,
                        &MockLayeredPool::ReleaseOneConnection));
   EXPECT_TRUE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
   EXPECT_THAT(histograms.GetAllSamples(kIdleSocketFateHistogram),
               testing::ElementsAre(
                   base::Bucket(/*IDLE_SOCKET_FATE_RELEASE_UNUSABLE=*/3, 1)));
+  EXPECT_TRUE(histograms.GetAllSamples(kIdleSocketTimeSavingHistogram).empty());
 }
 
 // Tests the basic case of closing an idle socket in a higher layered pool when
 // a new request is issued and the lower layer pool is stalled.
 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
   CreatePool(1, 1);
   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
 
   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
   EXPECT_THAT(mock_layered_pool.RequestSocket(pool_.get()), IsOk());
@@ skipping 246 matching lines @@
   request(1)->handle()->Reset();
   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
 
   EXPECT_THAT(request(2)->WaitForResult(), IsOk());
   EXPECT_FALSE(request(1)->have_result());
 }
 
 }  // namespace
 
 }  // namespace net