Use TimeTicks in WebURLLoadTiming

Change-Id: I8a7183bbd848f22a17888b60ed4475a87a64ec3d
Reviewed-on: https://chromium-review.googlesource.com/1040776
Commit-Queue: Nicolás Peña Moreno <npm@chromium.org>
Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556451}

content/common/resource_timing_info.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "base/optional.h"
+#include "base/time/time.h"
 
 namespace content {
 
@@ -36,22 +37,22 @@ struct ResourceLoadTiming {
   ResourceLoadTiming(const ResourceLoadTiming&);
   ~ResourceLoadTiming();
 
-  double request_time = 0.0;
-  double proxy_start = 0.0;
-  double proxy_end = 0.0;
-  double dns_start = 0.0;
-  double dns_end = 0.0;
-  double connect_start = 0.0;
-  double connect_end = 0.0;
-  double worker_start = 0.0;
-  double worker_ready = 0.0;
-  double send_start = 0.0;
-  double send_end = 0.0;
-  double receive_headers_end = 0.0;
-  double ssl_start = 0.0;
-  double ssl_end = 0.0;
-  double push_start = 0.0;
-  double push_end = 0.0;
+  base::TimeTicks request_time;
+  base::TimeTicks proxy_start;
+  base::TimeTicks proxy_end;
+  base::TimeTicks dns_start;
+  base::TimeTicks dns_end;
+  base::TimeTicks connect_start;
+  base::TimeTicks connect_end;
+  base::TimeTicks worker_start;
+  base::TimeTicks worker_ready;
+  base::TimeTicks send_start;
+  base::TimeTicks send_end;
+  base::TimeTicks receive_headers_end;
+  base::TimeTicks ssl_start;
+  base::TimeTicks ssl_end;
+  base::TimeTicks push_start;
+  base::TimeTicks push_end;
 };
 
 // TODO(dcheng): Migrate this struct over to Mojo so it doesn't need to be

content/renderer/loader/web_url_loader_impl.cc

@@ -142,32 +142,21 @@ void PopulateURLLoadTiming(const net::LoadTimingInfo& load_timing,
                            WebURLLoadTiming* url_timing) {
   DCHECK(!load_timing.request_start.is_null());
 
-  const TimeTicks kNullTicks;
   url_timing->Initialize();
-  url_timing->SetRequestTime(
-      (load_timing.request_start - kNullTicks).InSecondsF());
-  url_timing->SetProxyStart(
-      (load_timing.proxy_resolve_start - kNullTicks).InSecondsF());
-  url_timing->SetProxyEnd(
-      (load_timing.proxy_resolve_end - kNullTicks).InSecondsF());
-  url_timing->SetDNSStart(
-      (load_timing.connect_timing.dns_start - kNullTicks).InSecondsF());
-  url_timing->SetDNSEnd(
-      (load_timing.connect_timing.dns_end - kNullTicks).InSecondsF());
-  url_timing->SetConnectStart(
-      (load_timing.connect_timing.connect_start - kNullTicks).InSecondsF());
-  url_timing->SetConnectEnd(
-      (load_timing.connect_timing.connect_end - kNullTicks).InSecondsF());
-  url_timing->SetSSLStart(
-      (load_timing.connect_timing.ssl_start - kNullTicks).InSecondsF());
-  url_timing->SetSSLEnd(
-      (load_timing.connect_timing.ssl_end - kNullTicks).InSecondsF());
-  url_timing->SetSendStart((load_timing.send_start - kNullTicks).InSecondsF());
-  url_timing->SetSendEnd((load_timing.send_end - kNullTicks).InSecondsF());
-  url_timing->SetReceiveHeadersEnd(
-      (load_timing.receive_headers_end - kNullTicks).InSecondsF());
-  url_timing->SetPushStart((load_timing.push_start - kNullTicks).InSecondsF());
-  url_timing->SetPushEnd((load_timing.push_end - kNullTicks).InSecondsF());
+  url_timing->SetRequestTime(load_timing.request_start);
+  url_timing->SetProxyStart(load_timing.proxy_resolve_start);
+  url_timing->SetProxyEnd(load_timing.proxy_resolve_end);
+  url_timing->SetDNSStart(load_timing.connect_timing.dns_start);
+  url_timing->SetDNSEnd(load_timing.connect_timing.dns_end);
+  url_timing->SetConnectStart(load_timing.connect_timing.connect_start);
+  url_timing->SetConnectEnd(load_timing.connect_timing.connect_end);
+  url_timing->SetSSLStart(load_timing.connect_timing.ssl_start);
+  url_timing->SetSSLEnd(load_timing.connect_timing.ssl_end);
+  url_timing->SetSendStart(load_timing.send_start);
+  url_timing->SetSendEnd(load_timing.send_end);
+  url_timing->SetReceiveHeadersEnd(load_timing.receive_headers_end);
+  url_timing->SetPushStart(load_timing.push_start);
+  url_timing->SetPushEnd(load_timing.push_end);
 }
 
 net::RequestPriority ConvertWebKitPriorityToNetPriority(
@@ -1237,11 +1226,8 @@ void WebURLLoaderImpl::PopulateURLResponse(
   if (!info.load_timing.receive_headers_end.is_null()) {
     WebURLLoadTiming timing;
     PopulateURLLoadTiming(info.load_timing, &timing);
-    const TimeTicks kNullTicks;
-    timing.SetWorkerStart(
-        (info.service_worker_start_time - kNullTicks).InSecondsF());
-    timing.SetWorkerReady(
-        (info.service_worker_ready_time - kNullTicks).InSecondsF());
+    timing.SetWorkerStart(info.service_worker_start_time);
+    timing.SetWorkerReady(info.service_worker_ready_time);
     response->SetLoadTiming(timing);
   }
 

third_party/blink/public/platform/web_url_load_timing.h

@@ -31,6 +31,7 @@
 #ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_URL_LOAD_TIMING_H_
 #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_URL_LOAD_TIMING_H_
 
+#include "base/time/time.h"
 #include "third_party/blink/public/platform/web_common.h"
 #include "third_party/blink/public/platform/web_private_ptr.h"
 
@@ -62,53 +63,53 @@ class WebURLLoadTiming {
 
   bool IsNull() const { return private_.IsNull(); }
 
-  BLINK_PLATFORM_EXPORT double RequestTime() const;
-  BLINK_PLATFORM_EXPORT void SetRequestTime(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks RequestTime() const;
+  BLINK_PLATFORM_EXPORT void SetRequestTime(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double ProxyStart() const;
-  BLINK_PLATFORM_EXPORT void SetProxyStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks ProxyStart() const;
+  BLINK_PLATFORM_EXPORT void SetProxyStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double ProxyEnd() const;
-  BLINK_PLATFORM_EXPORT void SetProxyEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks ProxyEnd() const;
+  BLINK_PLATFORM_EXPORT void SetProxyEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double DnsStart() const;
-  BLINK_PLATFORM_EXPORT void SetDNSStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks DnsStart() const;
+  BLINK_PLATFORM_EXPORT void SetDNSStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double DnsEnd() const;
-  BLINK_PLATFORM_EXPORT void SetDNSEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks DnsEnd() const;
+  BLINK_PLATFORM_EXPORT void SetDNSEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double ConnectStart() const;
-  BLINK_PLATFORM_EXPORT void SetConnectStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks ConnectStart() const;
+  BLINK_PLATFORM_EXPORT void SetConnectStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double ConnectEnd() const;
-  BLINK_PLATFORM_EXPORT void SetConnectEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks ConnectEnd() const;
+  BLINK_PLATFORM_EXPORT void SetConnectEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double WorkerStart() const;
-  BLINK_PLATFORM_EXPORT void SetWorkerStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks WorkerStart() const;
+  BLINK_PLATFORM_EXPORT void SetWorkerStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double WorkerReady() const;
-  BLINK_PLATFORM_EXPORT void SetWorkerReady(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks WorkerReady() const;
+  BLINK_PLATFORM_EXPORT void SetWorkerReady(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double SendStart() const;
-  BLINK_PLATFORM_EXPORT void SetSendStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks SendStart() const;
+  BLINK_PLATFORM_EXPORT void SetSendStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double SendEnd() const;
-  BLINK_PLATFORM_EXPORT void SetSendEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks SendEnd() const;
+  BLINK_PLATFORM_EXPORT void SetSendEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double ReceiveHeadersEnd() const;
-  BLINK_PLATFORM_EXPORT void SetReceiveHeadersEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks ReceiveHeadersEnd() const;
+  BLINK_PLATFORM_EXPORT void SetReceiveHeadersEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double SslStart() const;
-  BLINK_PLATFORM_EXPORT void SetSSLStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks SslStart() const;
+  BLINK_PLATFORM_EXPORT void SetSSLStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double SslEnd() const;
-  BLINK_PLATFORM_EXPORT void SetSSLEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks SslEnd() const;
+  BLINK_PLATFORM_EXPORT void SetSSLEnd(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double PushStart() const;
-  BLINK_PLATFORM_EXPORT void SetPushStart(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks PushStart() const;
+  BLINK_PLATFORM_EXPORT void SetPushStart(base::TimeTicks);
 
-  BLINK_PLATFORM_EXPORT double PushEnd() const;
-  BLINK_PLATFORM_EXPORT void SetPushEnd(double);
+  BLINK_PLATFORM_EXPORT base::TimeTicks PushEnd() const;
+  BLINK_PLATFORM_EXPORT void SetPushEnd(base::TimeTicks);
 
 #if INSIDE_BLINK
   BLINK_PLATFORM_EXPORT WebURLLoadTiming(scoped_refptr<ResourceLoadTiming>);

third_party/blink/renderer/platform/exported/web_url_load_timing.cc

@@ -47,148 +47,132 @@ void WebURLLoadTiming::Assign(const WebURLLoadTiming& other) {
   private_ = other.private_;
 }
 
-double WebURLLoadTiming::RequestTime() const {
-  return TimeTicksInSeconds(private_->RequestTime());
+base::TimeTicks WebURLLoadTiming::RequestTime() const {
+  return private_->RequestTime();
 }
 
-void WebURLLoadTiming::SetRequestTime(double time) {
-  DCHECK_GE(time, 0.0);
-  private_->SetRequestTime(TimeTicksFromSeconds(time));
+void WebURLLoadTiming::SetRequestTime(base::TimeTicks time) {
+  private_->SetRequestTime(time);
 }
 
-double WebURLLoadTiming::ProxyStart() const {
-  return TimeTicksInSeconds(private_->ProxyStart());
+base::TimeTicks WebURLLoadTiming::ProxyStart() const {
+  return private_->ProxyStart();
 }
 
-void WebURLLoadTiming::SetProxyStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetProxyStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetProxyStart(base::TimeTicks start) {
+  private_->SetProxyStart(start);
 }
 
-double WebURLLoadTiming::ProxyEnd() const {
-  return TimeTicksInSeconds(private_->ProxyEnd());
+base::TimeTicks WebURLLoadTiming::ProxyEnd() const {
+  return private_->ProxyEnd();
 }
 
-void WebURLLoadTiming::SetProxyEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetProxyEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetProxyEnd(base::TimeTicks end) {
+  private_->SetProxyEnd(end);
 }
 
-double WebURLLoadTiming::DnsStart() const {
-  return TimeTicksInSeconds(private_->DnsStart());
+base::TimeTicks WebURLLoadTiming::DnsStart() const {
+  return private_->DnsStart();
 }
 
-void WebURLLoadTiming::SetDNSStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetDnsStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetDNSStart(base::TimeTicks start) {
+  private_->SetDnsStart(start);
 }
 
-double WebURLLoadTiming::DnsEnd() const {
-  return TimeTicksInSeconds(private_->DnsEnd());
+base::TimeTicks WebURLLoadTiming::DnsEnd() const {
+  return private_->DnsEnd();
 }
 
-void WebURLLoadTiming::SetDNSEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetDnsEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetDNSEnd(base::TimeTicks end) {
+  private_->SetDnsEnd(end);
 }
 
-double WebURLLoadTiming::ConnectStart() const {
-  return TimeTicksInSeconds(private_->ConnectStart());
+base::TimeTicks WebURLLoadTiming::ConnectStart() const {
+  return private_->ConnectStart();
 }
 
-void WebURLLoadTiming::SetConnectStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetConnectStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetConnectStart(base::TimeTicks start) {
+  private_->SetConnectStart(start);
 }
 
-double WebURLLoadTiming::ConnectEnd() const {
-  return TimeTicksInSeconds(private_->ConnectEnd());
+base::TimeTicks WebURLLoadTiming::ConnectEnd() const {
+  return private_->ConnectEnd();
 }
 
-void WebURLLoadTiming::SetConnectEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetConnectEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetConnectEnd(base::TimeTicks end) {
+  private_->SetConnectEnd(end);
 }
 
-double WebURLLoadTiming::WorkerStart() const {
-  return TimeTicksInSeconds(private_->WorkerStart());
+base::TimeTicks WebURLLoadTiming::WorkerStart() const {
+  return private_->WorkerStart();
 }
 
-void WebURLLoadTiming::SetWorkerStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetWorkerStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetWorkerStart(base::TimeTicks start) {
+  private_->SetWorkerStart(start);
 }
 
-double WebURLLoadTiming::WorkerReady() const {
-  return TimeTicksInSeconds(private_->WorkerReady());
+base::TimeTicks WebURLLoadTiming::WorkerReady() const {
+  return private_->WorkerReady();
 }
 
-void WebURLLoadTiming::SetWorkerReady(double ready) {
-  DCHECK_GE(ready, 0.0);
-  private_->SetWorkerReady(TimeTicksFromSeconds(ready));
+void WebURLLoadTiming::SetWorkerReady(base::TimeTicks ready) {
+  private_->SetWorkerReady(ready);
 }
 
-double WebURLLoadTiming::SendStart() const {
-  return TimeTicksInSeconds(private_->SendStart());
+base::TimeTicks WebURLLoadTiming::SendStart() const {
+  return private_->SendStart();
 }
 
-void WebURLLoadTiming::SetSendStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetSendStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetSendStart(base::TimeTicks start) {
+  private_->SetSendStart(start);
 }
 
-double WebURLLoadTiming::SendEnd() const {
-  return TimeTicksInSeconds(private_->SendEnd());
+base::TimeTicks WebURLLoadTiming::SendEnd() const {
+  return private_->SendEnd();
 }
 
-void WebURLLoadTiming::SetSendEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetSendEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetSendEnd(base::TimeTicks end) {
+  private_->SetSendEnd(end);
 }
 
-double WebURLLoadTiming::ReceiveHeadersEnd() const {
-  return TimeTicksInSeconds(private_->ReceiveHeadersEnd());
+base::TimeTicks WebURLLoadTiming::ReceiveHeadersEnd() const {
+  return private_->ReceiveHeadersEnd();
 }
 
-void WebURLLoadTiming::SetReceiveHeadersEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetReceiveHeadersEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetReceiveHeadersEnd(base::TimeTicks end) {
+  private_->SetReceiveHeadersEnd(end);
 }
 
-double WebURLLoadTiming::SslStart() const {
-  return TimeTicksInSeconds(private_->SslStart());
+base::TimeTicks WebURLLoadTiming::SslStart() const {
+  return private_->SslStart();
 }
 
-void WebURLLoadTiming::SetSSLStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetSslStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetSSLStart(base::TimeTicks start) {
+  private_->SetSslStart(start);
 }
 
-double WebURLLoadTiming::SslEnd() const {
-  return TimeTicksInSeconds(private_->SslEnd());
+base::TimeTicks WebURLLoadTiming::SslEnd() const {
+  return private_->SslEnd();
 }
 
-void WebURLLoadTiming::SetSSLEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetSslEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetSSLEnd(base::TimeTicks end) {
+  private_->SetSslEnd(end);
 }
 
-double WebURLLoadTiming::PushStart() const {
-  return TimeTicksInSeconds(private_->PushStart());
+base::TimeTicks WebURLLoadTiming::PushStart() const {
+  return private_->PushStart();
 }
 
-void WebURLLoadTiming::SetPushStart(double start) {
-  DCHECK_GE(start, 0.0);
-  private_->SetPushStart(TimeTicksFromSeconds(start));
+void WebURLLoadTiming::SetPushStart(base::TimeTicks start) {
+  private_->SetPushStart(start);
 }
 
-double WebURLLoadTiming::PushEnd() const {
-  return TimeTicksInSeconds(private_->PushEnd());
+base::TimeTicks WebURLLoadTiming::PushEnd() const {
+  return private_->PushEnd();
 }
 
-void WebURLLoadTiming::SetPushEnd(double end) {
-  DCHECK_GE(end, 0.0);
-  private_->SetPushEnd(TimeTicksFromSeconds(end));
+void WebURLLoadTiming::SetPushEnd(base::TimeTicks end) {
+  private_->SetPushEnd(end);
 }
 
 WebURLLoadTiming::WebURLLoadTiming(scoped_refptr<ResourceLoadTiming> value)