LoadTiming implementation in net, part 1.

net/socket/client_socket_handle.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_handle.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/logging.h"
+#include "net/base/load_timing_info.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_histograms.h"
 
 namespace net {
 
 ClientSocketHandle::ClientSocketHandle()
     : is_initialized_(false),
       pool_(NULL),
       layered_pool_(NULL),
@@ skipping 33 matching lines @@
   is_reused_ = false;
   user_callback_.Reset();
   if (layered_pool_) {
     pool_->RemoveLayeredPool(layered_pool_);
     layered_pool_ = NULL;
   }
   pool_ = NULL;
   idle_time_ = base::TimeDelta();
   init_time_ = base::TimeTicks();
   setup_time_ = base::TimeDelta();
+  connect_timing_ = ConnectTiming();

[mmenke, 2012/12/14 01:15:18]

This will result in a URLRequest not giving correct times after it's called
Reset.  This happens in the Connection:Close case, and maybe on some errors.

Fortunately, the only places we read the load timing are in two delegate
functions:  OnResponseStarted and OnResponseRedirected, so that's not an issue
for the current use case.  Can add a workaround for this if we ever need it.

[eroman, 2012/12/14 04:08:34]

I suggest additionally dumping these timings into NetLog. They could be useful
for slow request debugging. Also hung requests (although hung requests are
likely in connection establishment, and hence before this has been filled).

[mmenke, 2012/12/14 13:36:12]

Where are you thinking of dumping them?  With in-progress URLRequests when
net-internals is opened?  That sounds reasonable.

We could also have logging for in-progress ConnectJobs, though hooking that up
would be a little tricky.

   pool_id_ = -1;
 }
 
 void ClientSocketHandle::ResetErrorState() {
   is_ssl_error_ = false;
   ssl_error_response_info_ = HttpResponseInfo();
   pending_http_proxy_connection_.reset();
 }
 
 LoadState ClientSocketHandle::GetLoadState() const {
@@ skipping 21 matching lines @@
 
 void ClientSocketHandle::RemoveLayeredPool(LayeredPool* layered_pool) {
   CHECK(layered_pool);
   CHECK(layered_pool_);
   if (pool_) {
     pool_->RemoveLayeredPool(layered_pool);
     layered_pool_ = NULL;
   }
 }
 
+bool ClientSocketHandle::GetLoadTimingInfo(
+    bool is_reused,
+    LoadTimingInfo* load_timing_info) const {
+  // Only return load timing information when there's a socket.
+  if (!socket_)
+    return false;
+
+  load_timing_info->socket_log_id = socket_->NetLog().source().id;
+  load_timing_info->socket_reused = is_reused;
+
+  // No times if the socket is reused.
+  if (is_reused)
+    return true;
+
+  load_timing_info->dns_start = connect_timing_.dns_start;
+  load_timing_info->dns_end = connect_timing_.dns_end;
+  load_timing_info->connect_start = connect_timing_.connect_start;
+  load_timing_info->connect_end = connect_timing_.connect_end;
+  load_timing_info->ssl_start = connect_timing_.ssl_start;
+  load_timing_info->ssl_end = connect_timing_.ssl_end;
+  return true;
+}
+
 void ClientSocketHandle::OnIOComplete(int result) {
   CompletionCallback callback = user_callback_;
   user_callback_.Reset();
   HandleInitCompletion(result);
   callback.Run(result);
 }
 
 void ClientSocketHandle::HandleInitCompletion(int result) {
   CHECK_NE(ERR_IO_PENDING, result);
   if (result != OK) {
@@ skipping 28 matching lines @@
   // TODO(eroman): This logging is not complete, in particular set_socket() and
   // release() socket. It ends up working though, since those methods are being
   // used to layer sockets (and the destination sources are the same).
   DCHECK(socket_.get());
   socket_->NetLog().BeginEvent(
       NetLog::TYPE_SOCKET_IN_USE,
       requesting_source_.ToEventParametersCallback());
 }
 
 }  // namespace net