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 202 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 386 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(

[eroman, 2013/02/13 02:07:20]

Interesting, I didn't even realize this was a problem! Seriously wondering
whether we can't come up with a TimeTicks class that has consistent values
across processes and suspends...

[mmenke, 2013/02/13 02:26:46]

That would be handy.

       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) \
+  renderer_info->load_timing.field = converter.ToLocalTimeTicks( \
+      RemoteTimeTicks::FromTimeTicks( \
+          browser_info.load_timing.field)).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(request_start);
+  CONVERT(proxy_resolve_start);
+  CONVERT(proxy_resolve_end);
+  CONVERT(connect_timing.dns_start);
+  CONVERT(connect_timing.dns_end);
+  CONVERT(connect_timing.connect_start);
+  CONVERT(connect_timing.connect_end);
+  CONVERT(connect_timing.ssl_start);
+  CONVERT(connect_timing.ssl_end);
   CONVERT(send_start);
   CONVERT(send_end);
-  CONVERT(receive_headers_start);
   CONVERT(receive_headers_end);
 
 #undef CONVERT
 }
 
 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;
@@ skipping 57 matching lines @@
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content