LoadTiming in net part 7: Hooking it all up

content/common/resource_dispatcher.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/common/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #include "net/http/http_response_headers.h"
 #include "webkit/glue/resource_request_body.h"
 #include "webkit/glue/resource_type.h"
 
 using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::ResourceRequestBody;
 using webkit_glue::ResourceResponseInfo;
 
 namespace content {
 
+namespace {
+
+// Converts |time| from a remote to local TimeTicks, overwriting the original
+// value.
+void RemoteToLocalTimeTicks(
+    const InterProcessTimeTicksConverter& converter,
+    base::TimeTicks* time) {
+  RemoteTimeTicks remote_time = RemoteTimeTicks::FromTimeTicks(*time);
+  *time = converter.ToLocalTimeTicks(remote_time).ToTimeTicks();
+}
+
+
+}  // namespace
+
 static void CrashOnMapFailure() {
 #if defined(OS_WIN)
   DWORD last_err = GetLastError();
   base::debug::Alias(&last_err);
 #endif
   CHECK(false);
 }
 
 // Each resource request is assigned an ID scoped to this process.
 static int MakeRequestID() {
@@ skipping 179 matching lines @@
   }
 
   response->error_code = result.error_code;
   response->url = result.final_url;
   response->headers = result.headers;
   response->mime_type = result.mime_type;
   response->charset = result.charset;
   response->request_time = result.request_time;
   response->response_time = result.response_time;
   response->encoded_data_length = result.encoded_data_length;
-  response->connection_id = result.connection_id;
-  response->connection_reused = result.connection_reused;
   response->load_timing = result.load_timing;
   response->devtools_info = result.devtools_info;
   response->data.swap(result.data);
   response->download_file_path = result.download_file_path;
 }
 
 // ResourceDispatcher ---------------------------------------------------------
 
 ResourceDispatcher::ResourceDispatcher(IPC::Sender* sender)
     : message_sender_(sender),
@@ skipping 393 matching lines @@
 
 void ResourceDispatcher::ToResourceResponseInfo(
     const PendingRequestInfo& request_info,
     const ResourceResponseHead& browser_info,
     ResourceResponseInfo* renderer_info) const {
   *renderer_info = browser_info;
   if (request_info.request_start.is_null() ||
       request_info.response_start.is_null() ||
       browser_info.request_start.is_null() ||
       browser_info.response_start.is_null() ||
-      browser_info.load_timing.base_ticks.is_null()) {
+      browser_info.load_timing.request_start.is_null()) {
     return;
   }
   InterProcessTimeTicksConverter converter(
       LocalTimeTicks::FromTimeTicks(request_info.request_start),
       LocalTimeTicks::FromTimeTicks(request_info.response_start),
       RemoteTimeTicks::FromTimeTicks(browser_info.request_start),
       RemoteTimeTicks::FromTimeTicks(browser_info.response_start));
 
-  LocalTimeTicks renderer_base_ticks = converter.ToLocalTimeTicks(
-      RemoteTimeTicks::FromTimeTicks(browser_info.load_timing.base_ticks));
-  renderer_info->load_timing.base_ticks = renderer_base_ticks.ToTimeTicks();
-
-#define CONVERT(field) \
-  LocalTimeDelta renderer_##field = converter.ToLocalTimeDelta( \
-      RemoteTimeDelta::FromRawDelta(browser_info.load_timing.field)); \
-  renderer_info->load_timing.field = renderer_##field.ToInt32()
-
-  CONVERT(proxy_start);
-  CONVERT(dns_start);
-  CONVERT(dns_end);
-  CONVERT(connect_start);
-  CONVERT(connect_end);
-  CONVERT(ssl_start);
-  CONVERT(ssl_end);
-  CONVERT(send_start);
-  CONVERT(send_end);
-  CONVERT(receive_headers_start);
-  CONVERT(receive_headers_end);
-
-#undef CONVERT
+  net::LoadTimingInfo* load_timing = &renderer_info->load_timing;
+  RemoteToLocalTimeTicks(converter, &load_timing->request_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->proxy_resolve_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->proxy_resolve_end);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.dns_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.dns_end);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.connect_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.connect_end);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.ssl_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.ssl_end);
+  RemoteToLocalTimeTicks(converter, &load_timing->send_start);
+  RemoteToLocalTimeTicks(converter, &load_timing->send_end);
+  RemoteToLocalTimeTicks(converter, &load_timing->receive_headers_end);
 }
 
 base::TimeTicks ResourceDispatcher::ToRendererCompletionTime(
     const PendingRequestInfo& request_info,
     const base::TimeTicks& browser_completion_time) const {
   if (request_info.completion_time.is_null()) {
     return browser_completion_time;
   }
 
   // TODO(simonjam): The optimal lower bound should be the most recent value of
@@ skipping 54 matching lines @@
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content