[WIP] Support PerformanceResourceTiming for Service Worker Navigation Preload

third_party/WebKit/Source/core/timing/PerformanceResourceTiming.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 28 matching lines @@
 
 namespace blink {
 
 PerformanceResourceTiming::PerformanceResourceTiming(
     const ResourceTimingInfo& info,
     double time_origin,
     double start_time,
     double last_redirect_end_time,
     bool allow_timing_details,
     bool allow_redirect_details)
-    : PerformanceEntry(
-          info.InitialURL().GetString(),
-          "resource",
-          PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(time_origin,
-                                                              start_time),
-          PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-              time_origin,
-              info.LoadFinishTime())),
+    : PerformanceEntry(info.InitialURL().GetString(),
+                       "resource",
+                       PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
+                           time_origin,
+                           start_time,
+                           info.NegativeAllowed()),
+                       PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
+                           time_origin,
+                           info.LoadFinishTime(),
+                           info.NegativeAllowed())),
       initiator_type_(info.InitiatorType()),
       time_origin_(time_origin),
       timing_(info.FinalResponse().GetResourceLoadTiming()),
       last_redirect_end_time_(last_redirect_end_time),
       finish_time_(info.LoadFinishTime()),
       transfer_size_(info.TransferSize()),
       encoded_body_size_(info.FinalResponse().EncodedBodyLength()),
       decoded_body_size_(info.FinalResponse().DecodedBodyLength()),
       did_reuse_connection_(info.FinalResponse().ConnectionReused()),
       allow_timing_details_(allow_timing_details),
-      allow_redirect_details_(allow_redirect_details) {}
+      allow_redirect_details_(allow_redirect_details),
+      allow_negative_value_(info.NegativeAllowed()) {}
 
 // This constructor is for PerformanceNavigationTiming.
 PerformanceResourceTiming::PerformanceResourceTiming(const String& name,
                                                      const String& entry_type,
                                                      double start_time,
                                                      double duration)
     : PerformanceEntry(name, entry_type, start_time, duration) {}
 
 PerformanceResourceTiming::~PerformanceResourceTiming() {}
 
@@ skipping 24 matching lines @@
 AtomicString PerformanceResourceTiming::initiatorType() const {
   return initiator_type_;
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::workerStart() const {
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing || timing->WorkerStart() == 0.0)
     return 0.0;
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->WorkerStart());
+      time_origin_, timing->WorkerStart(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::WorkerReady() const {
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing || timing->WorkerReady() == 0.0)
     return 0.0;
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->WorkerReady());
+      time_origin_, timing->WorkerReady(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::redirectStart() const {
   if (!last_redirect_end_time_ || !allow_redirect_details_)
     return 0.0;
 
   if (DOMHighResTimeStamp worker_ready_time = WorkerReady())
     return worker_ready_time;
 
   return PerformanceEntry::startTime();
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::redirectEnd() const {
   if (!last_redirect_end_time_ || !allow_redirect_details_)
     return 0.0;
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, last_redirect_end_time_);
+      time_origin_, last_redirect_end_time_, allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::fetchStart() const {
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing)
     return PerformanceEntry::startTime();
 
   if (last_redirect_end_time_) {
     return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-        time_origin_, timing->RequestTime());
+        time_origin_, timing->RequestTime(), allow_negative_value_);
   }
 
   if (DOMHighResTimeStamp worker_ready_time = WorkerReady())
     return worker_ready_time;
 
   return PerformanceEntry::startTime();
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::domainLookupStart() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing || timing->DnsStart() == 0.0)
     return fetchStart();
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->DnsStart());
+      time_origin_, timing->DnsStart(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::domainLookupEnd() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing || timing->DnsEnd() == 0.0)
     return domainLookupStart();
 
-  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(time_origin_,
-                                                             timing->DnsEnd());
+  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
+      time_origin_, timing->DnsEnd(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::connectStart() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   // connectStart will be zero when a network request is not made.
   if (!timing || timing->ConnectStart() == 0.0 || DidReuseConnection())
     return domainLookupEnd();
 
   // connectStart includes any DNS time, so we may need to trim that off.
   double connect_start = timing->ConnectStart();
   if (timing->DnsEnd() > 0.0)
     connect_start = timing->DnsEnd();
 
-  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(time_origin_,
-                                                             connect_start);
+  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
+      time_origin_, connect_start, allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::connectEnd() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   // connectStart will be zero when a network request is not made.
   if (!timing || timing->ConnectEnd() == 0.0 || DidReuseConnection())
     return connectStart();
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->ConnectEnd());
+      time_origin_, timing->ConnectEnd(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::secureConnectionStart() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing ||
       timing->SslStart() == 0.0)  // Secure connection not negotiated.
     return 0.0;
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->SslStart());
+      time_origin_, timing->SslStart(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::requestStart() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing)
     return connectEnd();
 
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->SendStart());
+      time_origin_, timing->SendStart(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::responseStart() const {
   if (!AllowTimingDetails())
     return 0.0;
   ResourceLoadTiming* timing = GetResourceLoadTiming();
   if (!timing)
     return requestStart();
 
   // FIXME: This number isn't exactly correct. See the notes in
   // PerformanceTiming::responseStart().
   return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
-      time_origin_, timing->ReceiveHeadersEnd());
+      time_origin_, timing->ReceiveHeadersEnd(), allow_negative_value_);
 }
 
 DOMHighResTimeStamp PerformanceResourceTiming::responseEnd() const {
   if (!finish_time_)
     return responseStart();
 
-  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(time_origin_,
-                                                             finish_time_);
+  return PerformanceBase::MonotonicTimeToDOMHighResTimeStamp(
+      time_origin_, finish_time_, allow_negative_value_);
 }
 
 unsigned long long PerformanceResourceTiming::transferSize() const {
   if (!AllowTimingDetails())
     return 0;
 
   return GetTransferSize();
 }
 
 unsigned long long PerformanceResourceTiming::encodedBodySize() const {
@@ skipping 24 matching lines @@
   builder.AddNumber("secureConnectionStart", secureConnectionStart());
   builder.AddNumber("requestStart", requestStart());
   builder.AddNumber("responseStart", responseStart());
   builder.AddNumber("responseEnd", responseEnd());
   builder.AddNumber("transferSize", transferSize());
   builder.AddNumber("encodedBodySize", encodedBodySize());
   builder.AddNumber("decodedBodySize", decodedBodySize());
 }
 
 }  // namespace blink