Use a monotonic clock (TimeTicks) to report network times to WebCore.

webkit/glue/weburlloader_impl.cc

 // Copyright (c) 2011 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/file_path.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 102 matching lines @@
                         ResourceResponseInfo* info,
                         std::string* data,
                         net::URLRequestStatus* status) {
   std::string mime_type;
   std::string charset;
   if (net::DataURL::Parse(url, &mime_type, &charset, data)) {
     *status = net::URLRequestStatus(net::URLRequestStatus::SUCCESS, 0);
     // 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 = base::TimeTicks::Now().ToInternalValue();
     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 = -1;
     info->encoded_data_length = 0;
 
     return true;
@@ skipping 29 matching lines @@
       WebString::fromUTF8(info.socket_address.host()));
   response->setRemotePort(info.socket_address.port());
   response->setConnectionID(info.connection_id);
   response->setConnectionReused(info.connection_reused);
   response->setDownloadFilePath(FilePathToWebString(info.download_file_path));
 
   const ResourceLoadTimingInfo& timing_info = info.load_timing;
   if (!timing_info.base_time.is_null()) {
     WebURLLoadTiming timing;
     timing.initialize();
-    timing.setRequestTime(timing_info.base_time.ToDoubleT());
+    timing.setRequestTime(
+        timing_info.base_ticks /
+        static_cast<double>(base::Time::kMicrosecondsPerSecond));
     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);
@@ skipping 89 matching lines @@
       bool* has_new_first_party_for_cookies,
       GURL* new_first_party_for_cookies);
   virtual void OnReceivedResponse(const ResourceResponseInfo& info);
   virtual void OnDownloadedData(int len);
   virtual void OnReceivedData(const char* data,
                               int data_length,
                               int encoded_data_length);
   virtual void OnReceivedCachedMetadata(const char* data, int len);
   virtual void OnCompletedRequest(const net::URLRequestStatus& status,
                                   const std::string& security_info,
-                                  const base::Time& completion_time);
+                                  const base::TimeTicks& completion_time);
 
  private:
   friend class base::RefCounted<Context>;
   ~Context() {}
 
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURL(const GURL& url) const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
@@ skipping 294 matching lines @@
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     const net::URLRequestStatus& status,
     const std::string& security_info,
-    const base::Time& completion_time) {
+    const base::TimeTicks& completion_time) {
   if (ftp_listing_delegate_.get()) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   } else if (multipart_delegate_.get()) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
   // Prevent any further IPC to the browser now that we're complete, but
   // don't delete it to keep any downloaded temp files alive.
@@ skipping 11 matching lines @@
         error_code = status.os_error();
       }
       WebURLError error;
       if (error_code == net::ERR_ABORTED)
         error.isCancellation = true;
       error.domain = WebString::fromUTF8(net::kErrorDomain);
       error.reason = error_code;
       error.unreachableURL = request_.url();
       client_->didFail(loader_, error);
     } else {
-      client_->didFinishLoading(loader_, completion_time.ToDoubleT());
+      client_->didFinishLoading(

[pfeldman, 2011/08/26 16:08:01]

What is your plan on landing this? Are you going to coordinate the two-sided
landing? It seems like landing either of upstream/downstream patches first will
break the inspector timing.

If this is a coordinated landing, should we convert from double to integer for
the finishLoading and requestTime values upstream?

[James Simonsen, 2011/08/26 18:57:18]

I plan to make a best-effort coordinated landing. Basically, this change doesn't
break any tests, it only breaks the reported values if someone is running
chrome. So, I was just going to watch for the webkit roll and land the chrome
change about the same time. Hopefully, only a developer or two will sync then
and they'll never notice it's off.
Darin Adler wanted monotonicallyIncreasingTime() to be in doubles, so I think we
should have it match up with that.

+          loader_, completion_time.ToInternalValue() /
+          static_cast<double>(base::Time::kMicrosecondsPerSecond));
     }
   }
 
   // We are done with the bridge now, and so we need to release the reference
   // to ourselves that we took on behalf of the bridge.  This may cause our
   // destruction.
   Release();
 }
 
 bool WebURLLoaderImpl::Context::CanHandleDataURL(const GURL& url) const {
@@ skipping 23 matching lines @@
   ResourceResponseInfo info;
   net::URLRequestStatus status;
   std::string data;
 
   if (GetInfoFromDataURL(request_.url(), &info, &data, &status)) {
     OnReceivedResponse(info);
     if (!data.empty())
       OnReceivedData(data.data(), data.size(), 0);
   }
 
-  OnCompletedRequest(status, info.security_info, base::Time::Now());
+  OnCompletedRequest(status, info.security_info, base::TimeTicks::Now());
 }
 
 // WebURLLoaderImpl -----------------------------------------------------------
 
 WebURLLoaderImpl::WebURLLoaderImpl()
     : ALLOW_THIS_IN_INITIALIZER_LIST(context_(new Context(this))) {
 }
 
 WebURLLoaderImpl::~WebURLLoaderImpl() {
   cancel();
@@ skipping 41 matching lines @@
 
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::UpdateRoutingId(int new_routing_id) {
   context_->UpdateRoutingId(new_routing_id);
 }
 
 }  // namespace webkit_glue