Fix Net.Socket.IdleSocketTimeSaving histogram

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 <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 432 matching lines @@
       connect_job_factory_->NewConnectJob(group_name, request, this));
 
   int rv = connect_job->Connect();
   if (rv == OK) {
     LogBoundConnectJobToRequest(connect_job->net_log().source(), request);
     if (!preconnecting) {
       HandOutSocket(connect_job->PassSocket(), ClientSocketHandle::UNUSED,
                     connect_job->connect_timing(), handle, base::TimeDelta(),
                     group, request.net_log());
     } else {
-      AddIdleSocket(connect_job->PassSocket(), group);
+      AddIdleSocket(connect_job->PassSocket(), group,
+                    connect_job->connect_timing());
     }
   } else if (rv == ERR_IO_PENDING) {
     // If we don't have any sockets in this group, set a timer for potentially
     // creating a new one.  If the SYN is lost, this backup socket may complete
     // before the slow socket, improving end user latency.
     if (connect_backup_jobs_enabled_ && group->IsEmpty()) {
       group->StartBackupJobTimer(group_name, this);
     }
 
     connecting_socket_count_++;
@@ skipping 71 matching lines @@
 
     RecordIdleSocketFate(idle_socket.socket->WasEverUsed()
                              ? IDLE_SOCKET_FATE_REUSE_REUSED
                              : IDLE_SOCKET_FATE_REUSE_UNUSED);
     // 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();
 
     HandOutSocket(std::unique_ptr<StreamSocket>(idle_socket.socket), reuse_type,
-                  LoadTimingInfo::ConnectTiming(), request.handle(), idle_time,
+                  idle_socket.connect_timing, request.handle(), idle_time,
                   group, request.net_log());
     return true;
   }
 
   return false;
 }
 
 // static
 void ClientSocketPoolBaseHelper::LogBoundConnectJobToRequest(
     const NetLogSource& connect_job_source,
     const Request& request) {
   request.net_log().AddEvent(NetLogEventType::SOCKET_POOL_BOUND_TO_CONNECT_JOB,
                              connect_job_source.ToEventParametersCallback());
 }
 
 void ClientSocketPoolBaseHelper::CancelRequest(
     const std::string& group_name, ClientSocketHandle* handle) {
   PendingCallbackMap::iterator callback_it = pending_callback_map_.find(handle);
   if (callback_it != pending_callback_map_.end()) {
     int result = callback_it->second.result;
     pending_callback_map_.erase(callback_it);
     std::unique_ptr<StreamSocket> socket = handle->PassSocket();
     if (socket) {
       if (result != OK)
         socket->Disconnect();
-      ReleaseSocket(handle->group_name(), std::move(socket), handle->id());
+      ReleaseSocket(handle->group_name(), std::move(socket), handle->id(),
+                    handle->connect_timing());
     }
     return;
   }
 
   CHECK(base::ContainsKey(group_map_, group_name));
 
   Group* group = GetOrCreateGroup(group_name);
 
   // Search pending_requests for matching handle.
   std::unique_ptr<const Request> request =
@@ skipping 211 matching lines @@
   ++idle_socket_count_;
 }
 
 void ClientSocketPoolBaseHelper::DecrementIdleCount() {
   --idle_socket_count_;
 }
 
 void ClientSocketPoolBaseHelper::ReleaseSocket(
     const std::string& group_name,
     std::unique_ptr<StreamSocket> socket,
-    int id) {
+    int id,
+    const LoadTimingInfo::ConnectTiming& connect_timing) {
   GroupMap::iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
 
   Group* group = i->second;
 
   CHECK_GT(handed_out_socket_count_, 0);
   handed_out_socket_count_--;
 
   CHECK_GT(group->active_socket_count(), 0);
   group->DecrementActiveSocketCount();
 
   const bool can_reuse = socket->IsConnectedAndIdle() &&
       id == pool_generation_number_;
   if (can_reuse) {
     // Add it to the idle list.
-    AddIdleSocket(std::move(socket), group);
+    AddIdleSocket(std::move(socket), group, connect_timing);
     OnAvailableSocketSlot(group_name, group);
   } else {
     socket.reset();
     RecordIdleSocketFate(IDLE_SOCKET_FATE_RELEASE_UNUSABLE);
   }
 
   CheckForStalledSocketGroups();
 }
 
 void ClientSocketPoolBaseHelper::CheckForStalledSocketGroups() {
@@ skipping 92 matching lines @@
     RemoveConnectJob(job, group);
     std::unique_ptr<const Request> request = group->PopNextPendingRequest();
     if (request) {
       LogBoundConnectJobToRequest(job_log.source(), *request);
       HandOutSocket(std::move(socket), ClientSocketHandle::UNUSED,
                     connect_timing, request->handle(), base::TimeDelta(), group,
                     request->net_log());
       request->net_log().EndEvent(NetLogEventType::SOCKET_POOL);
       InvokeUserCallbackLater(request->handle(), request->callback(), result);
     } else {
-      AddIdleSocket(std::move(socket), group);
+      AddIdleSocket(std::move(socket), group, connect_timing);
       OnAvailableSocketSlot(group_name, group);
       CheckForStalledSocketGroups();
     }
   } else {
     // If we got a socket, it must contain error information so pass that
     // up so that the caller can retrieve it.
     bool handed_out_socket = false;
     std::unique_ptr<const Request> request = group->PopNextPendingRequest();
     if (request) {
       LogBoundConnectJobToRequest(job_log.source(), *request);
@@ skipping 91 matching lines @@
 
   if (reuse_type == ClientSocketHandle::REUSED_IDLE) {
     net_log.AddEvent(
         NetLogEventType::SOCKET_POOL_REUSED_AN_EXISTING_SOCKET,
         NetLog::IntCallback("idle_ms",
                             static_cast<int>(idle_time.InMilliseconds())));
 
     UMA_HISTOGRAM_COUNTS_1000("Net.Socket.IdleSocketReuseTime",
                               idle_time.InSeconds());
     UMA_HISTOGRAM_TIMES(
-        "Net.Socket.IdleSocketTimeSaving",
+        "Net.Socket.IdleSocketTimeSaving2",
         connect_timing.connect_end - connect_timing.connect_start);
   }
 
   if (reuse_type != ClientSocketHandle::UNUSED) {
     // The socket being handed out is no longer considered idle, but was
     // considered idle until just before this method was called.
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.Socket.NumIdleSockets",
                                 idle_socket_count() + 1, 1, 256, 50);
   }
 
   net_log.AddEvent(
       NetLogEventType::SOCKET_POOL_BOUND_TO_SOCKET,
       handle->socket()->NetLog().source().ToEventParametersCallback());
 
   handed_out_socket_count_++;
   group->IncrementActiveSocketCount();
 }
 
 void ClientSocketPoolBaseHelper::AddIdleSocket(
     std::unique_ptr<StreamSocket> socket,
-    Group* group) {
+    Group* group,
+    const LoadTimingInfo::ConnectTiming& connect_timing) {
   DCHECK(socket);
   IdleSocket idle_socket;
   idle_socket.socket = socket.release();
   idle_socket.start_time = base::TimeTicks::Now();
+  idle_socket.connect_timing = connect_timing;
 
   group->mutable_idle_sockets()->push_back(idle_socket);
   IncrementIdleCount();
 }
 
 void ClientSocketPoolBaseHelper::CancelAllConnectJobs() {
   for (GroupMap::iterator i = group_map_.begin(); i != group_map_.end();) {
     Group* group = i->second;
     connecting_socket_count_ -= group->jobs().size();
     group->RemoveAllJobs();
@@ skipping 304 matching lines @@
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   request->CrashIfInvalid();
   return request;
 }
 
 }  // namespace internal
 
 }  // namespace net