LoadTiming in net part 7: Hooking it all up

webkit/glue/weburlloader_impl.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.
 
 // An implementation of WebURLLoader in terms of ResourceLoaderBridge.
 
 #include "webkit/glue/weburlloader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 112 matching lines @@
 bool GetInfoFromDataURL(const GURL& url,
                         ResourceResponseInfo* info,
                         std::string* data,
                         int* error_code) {
   std::string mime_type;
   std::string charset;
   if (net::DataURL::Parse(url, &mime_type, &charset, data)) {
     *error_code = net::OK;
     // Assure same time for all time fields of data: URLs.
     Time now = Time::Now();
-    info->load_timing.base_time = now;
-    info->load_timing.base_ticks = TimeTicks::Now();
+    info->load_timing.request_start = TimeTicks::Now();
+    info->load_timing.request_start_time = now;
     info->request_time = now;
     info->response_time = now;
     info->headers = NULL;
     info->mime_type.swap(mime_type);
     info->charset.swap(charset);
     info->security_info.clear();
     info->content_length = data->length();
     info->encoded_data_length = 0;
 
     return true;
   }
 
   *error_code = net::ERR_INVALID_URL;
   return false;
 }
 
 typedef ResourceDevToolsInfo::HeadersVector HeadersVector;
 
+// Given a base time and a second time, returns the time from the base time to
+// the second time, in milliseconds.  If the second time is null, returns -1.
+// The base time must not be null.
+int TimeTicksToOffset(base::TimeTicks base_time, base::TimeTicks time) {
+  if (time.is_null())
+    return -1;
+  DCHECK(!base_time.is_null());
+  return static_cast<int>((time - base_time).InMillisecondsRoundedUp());
+}
+
+// Converts timing data from |load_timing| to the format used by WebKit.
+void PopulateURLLoadTiming(const net::LoadTimingInfo& load_timing,
+                           WebURLLoadTiming* url_timing) {
+  DCHECK(!load_timing.request_start.is_null());
+
+  url_timing->initialize();
+  url_timing->setRequestTime(
+      (load_timing.request_start - TimeTicks()).InSecondsF());
+  url_timing->setProxyStart(TimeTicksToOffset(load_timing.request_start,
+                                              load_timing.proxy_resolve_start));
+  url_timing->setProxyEnd(TimeTicksToOffset(load_timing.request_start,
+                                            load_timing.proxy_resolve_end));
+  url_timing->setDNSStart(TimeTicksToOffset(
+      load_timing.request_start,
+      load_timing.connect_timing.dns_start));
+  url_timing->setDNSEnd(TimeTicksToOffset(load_timing.request_start,
+                                          load_timing.connect_timing.dns_end));
+  url_timing->setConnectStart(
+      TimeTicksToOffset(load_timing.request_start,
+                        load_timing.connect_timing.connect_start));
+  url_timing->setConnectEnd(
+      TimeTicksToOffset(load_timing.request_start,
+                        load_timing.connect_timing.connect_end));
+  url_timing->setSSLStart(
+      TimeTicksToOffset(load_timing.request_start,
+                        load_timing.connect_timing.ssl_start));
+  url_timing->setSSLEnd(TimeTicksToOffset(load_timing.request_start,
+                                          load_timing.connect_timing.ssl_end));
+  url_timing->setSendStart(TimeTicksToOffset(load_timing.request_start,
+                                             load_timing.send_start));
+  url_timing->setSendEnd(TimeTicksToOffset(load_timing.request_start,
+                                           load_timing.send_end));
+  url_timing->setReceiveHeadersEnd(
+      TimeTicksToOffset(load_timing.request_start,
+                        load_timing.receive_headers_end));
+}
+
 void PopulateURLResponse(
     const GURL& url,
     const ResourceResponseInfo& info,
     WebURLResponse* response) {
   response->setURL(url);
   response->setResponseTime(info.response_time.ToDoubleT());
   response->setMIMEType(WebString::fromUTF8(info.mime_type));
   response->setTextEncodingName(WebString::fromUTF8(info.charset));
   response->setExpectedContentLength(info.content_length);
   response->setSecurityInfo(info.security_info);
   response->setAppCacheID(info.appcache_id);
   response->setAppCacheManifestURL(info.appcache_manifest_url);
-  response->setWasCached(!info.load_timing.base_time.is_null() &&
-      info.response_time < info.load_timing.base_time);
+  response->setWasCached(!info.load_timing.request_start_time.is_null() &&
+      info.response_time < info.load_timing.request_start_time);
   response->setRemoteIPAddress(
       WebString::fromUTF8(info.socket_address.host()));
   response->setRemotePort(info.socket_address.port());
-  response->setConnectionID(info.connection_id);
-  response->setConnectionReused(info.connection_reused);
+  response->setConnectionID(info.load_timing.socket_log_id);
+  response->setConnectionReused(info.load_timing.socket_reused);
   response->setDownloadFilePath(
       webkit_base::FilePathToWebString(info.download_file_path));
   WebURLResponseExtraDataImpl* extra_data =
       new WebURLResponseExtraDataImpl(info.npn_negotiated_protocol);
   response->setExtraData(extra_data);
   extra_data->set_was_fetched_via_spdy(info.was_fetched_via_spdy);
   extra_data->set_was_npn_negotiated(info.was_npn_negotiated);
   extra_data->set_was_alternate_protocol_available(
       info.was_alternate_protocol_available);
   extra_data->set_was_fetched_via_proxy(info.was_fetched_via_proxy);
 
-  const ResourceLoadTimingInfo& timing_info = info.load_timing;
-  if (!timing_info.base_time.is_null()) {
+  // If there's no received headers end time, don't set load timing.  This is
+  // the case for non-HTTP requests, requests that don't go over the wire, and
+  // certain error cases.
+  if (!info.load_timing.receive_headers_end.is_null()) {
     WebURLLoadTiming timing;
-    timing.initialize();
-    timing.setRequestTime((timing_info.base_ticks - TimeTicks()).InSecondsF());
-    timing.setProxyStart(timing_info.proxy_start);
-    timing.setProxyEnd(timing_info.proxy_end);
-    timing.setDNSStart(timing_info.dns_start);
-    timing.setDNSEnd(timing_info.dns_end);
-    timing.setConnectStart(timing_info.connect_start);
-    timing.setConnectEnd(timing_info.connect_end);
-    timing.setSSLStart(timing_info.ssl_start);
-    timing.setSSLEnd(timing_info.ssl_end);
-    timing.setSendStart(timing_info.send_start);
-    timing.setSendEnd(timing_info.send_end);
-    timing.setReceiveHeadersEnd(timing_info.receive_headers_end);
+    PopulateURLLoadTiming(info.load_timing, &timing);
     response->setLoadTiming(timing);
   }
 
   if (info.devtools_info.get()) {
     WebHTTPLoadInfo load_info;
 
     load_info.setHTTPStatusCode(info.devtools_info->http_status_code);
     load_info.setHTTPStatusText(WebString::fromUTF8(
         info.devtools_info->http_status_text));
     load_info.setEncodedDataLength(info.encoded_data_length);
@@ skipping 608 matching lines @@
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::didChangePriority(WebURLRequest::Priority new_priority) {
   context_->DidChangePriority(new_priority);
 }
 
 }  // namespace webkit_glue