Report nav timing 2 instance as soon as it's requested.

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

 // Copyright 2016 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.
 
 #include "core/timing/PerformanceNavigationTiming.h"
 
 #include "bindings/core/v8/V8ObjectBuilder.h"
+#include "core/dom/Document.h"
+#include "core/dom/DocumentTiming.h"
+#include "core/frame/LocalFrame.h"
+#include "core/loader/DocumentLoadTiming.h"
+#include "core/loader/DocumentLoader.h"
 #include "core/timing/PerformanceBase.h"
+#include "platform/network/ResourceTimingInfo.h"
 
 namespace blink {
 
 PerformanceNavigationTiming::PerformanceNavigationTiming(
-    double timeOrigin,
-    const String& requestedUrl,
-    double unloadEventStart,
-    double unloadEventEnd,
-    double loadEventStart,
-    double loadEventEnd,
-    unsigned short redirectCount,
-    double domInteractive,
-    double domContentLoadedEventStart,
-    double domContentLoadedEventEnd,
-    double domComplete,
-    NavigationType type,
-    double redirectStart,
-    double redirectEnd,
-    double fetchStart,
-    double responseEnd,
-    bool allowRedirectDetails,
-    bool hasSameOriginAsPreviousDocument,
-    ResourceLoadTiming* timing,
-    double lastRedirectEndTime,
-    double finishTime,
-    unsigned long long transferSize,
-    unsigned long long encodedBodyLength,
-    unsigned long long decodedBodyLength,
-    bool didReuseConnection)
-    : PerformanceResourceTiming("navigation",
-                                timeOrigin,
-                                timing,
-                                lastRedirectEndTime,
-                                finishTime,
-                                transferSize,
-                                encodedBodyLength,
-                                decodedBodyLength,
-                                didReuseConnection,
-                                true /*allowTimingDetails*/,  // TODO(sunjian):
-                                                              // Create an enum
-                                                              // for this.
-                                allowRedirectDetails,
-                                requestedUrl,
+    LocalFrame* frame,
+    ResourceTimingInfo* info,
+    double timeOrigin)
+    : PerformanceResourceTiming(info ? info->initialURL().getString() : "",
                                 "navigation",
-                                timeOrigin),
+                                0.0,
+                                0.0),
       m_timeOrigin(timeOrigin),
-      m_unloadEventStart(unloadEventStart),
-      m_unloadEventEnd(unloadEventEnd),
-      m_loadEventStart(loadEventStart),
-      m_loadEventEnd(loadEventEnd),
-      m_redirectCount(redirectCount),
-      m_domInteractive(domInteractive),
-      m_domContentLoadedEventStart(domContentLoadedEventStart),
-      m_domContentLoadedEventEnd(domContentLoadedEventEnd),
-      m_domComplete(domComplete),
-      m_type(type),
-      m_redirectStart(redirectStart),
-      m_redirectEnd(redirectEnd),
-      m_fetchStart(fetchStart),
-      m_responseEnd(responseEnd),
-      m_allowRedirectDetails(allowRedirectDetails),
-      m_hasSameOriginAsPreviousDocument(hasSameOriginAsPreviousDocument) {}
+      m_resourceTimingInfo(info),
+      m_frame(frame) {
+  DCHECK(info);
+}
 
 PerformanceNavigationTiming::~PerformanceNavigationTiming() {}
 
+DEFINE_TRACE(PerformanceNavigationTiming) {
+  visitor->trace(m_frame);
+  PerformanceEntry::trace(visitor);
+}
+
+DocumentLoadTiming* PerformanceNavigationTiming::documentLoadTiming() const {
+  DocumentLoader* loader = documentLoader();
+  if (!loader)
+    return nullptr;
+
+  return &loader->timing();
+}
+
+DocumentLoader* PerformanceNavigationTiming::documentLoader() const {
+  if (!m_frame)
+    return nullptr;
+
+  return m_frame->loader().documentLoader();
+}
+
+const DocumentTiming* PerformanceNavigationTiming::documentTiming() const {
+  if (!m_frame)
+    return nullptr;
+
+  Document* document = m_frame->document();
+  if (!document)
+    return nullptr;
+
+  return &document->timing();
+}
+
+ResourceLoadTiming* PerformanceNavigationTiming::resourceLoadTiming() const {
+  return m_resourceTimingInfo->finalResponse().resourceLoadTiming();
+}
+
+bool PerformanceNavigationTiming::allowTimingDetails() const {
+  return true;
+}
+
+bool PerformanceNavigationTiming::didReuseConnection() const {
+  return m_resourceTimingInfo->finalResponse().connectionReused();
+}
+
+unsigned long long PerformanceNavigationTiming::getTransferSize() const {
+  return m_resourceTimingInfo->transferSize();
+}
+
+unsigned long long PerformanceNavigationTiming::getEncodedBodySize() const {
+  return m_resourceTimingInfo->finalResponse().encodedBodyLength();
+}
+
+unsigned long long PerformanceNavigationTiming::getDecodedBodySize() const {
+  return m_resourceTimingInfo->finalResponse().decodedBodyLength();
+}
+
+AtomicString PerformanceNavigationTiming::initiatorType() const {
+  return "navigation";
+}
+
+bool PerformanceNavigationTiming::getAllowRedirectDetails() const {
+  ExecutionContext* context = m_frame ? m_frame->document() : nullptr;
+  SecurityOrigin* securityOrigin = nullptr;
+  if (context)
+    securityOrigin = context->getSecurityOrigin();
+  if (!securityOrigin)
+    return false;
+  // TODO(sunjian): Think about how to make this flag deterministic.
+  // crbug/693183.
+  return PerformanceBase::allowsTimingRedirect(
+      m_resourceTimingInfo->redirectChain(),
+      m_resourceTimingInfo->finalResponse(), *securityOrigin, context);
+}
+
 DOMHighResTimeStamp PerformanceNavigationTiming::unloadEventStart() const {
-  if (!m_allowRedirectDetails || !m_hasSameOriginAsPreviousDocument)
+  bool allowRedirectDetails = getAllowRedirectDetails();
+  DocumentLoadTiming* timing = documentLoadTiming();
+
+  if (!allowRedirectDetails || !timing ||
+      !timing->hasSameOriginAsPreviousDocument())
     return 0;
   return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
-      m_timeOrigin, m_unloadEventStart);
+      m_timeOrigin, timing->unloadEventStart());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::unloadEventEnd() const {
-  if (!m_allowRedirectDetails || !m_hasSameOriginAsPreviousDocument)
+  bool allowRedirectDetails = getAllowRedirectDetails();
+  DocumentLoadTiming* timing = documentLoadTiming();
+
+  if (!allowRedirectDetails || !timing ||
+      !timing->hasSameOriginAsPreviousDocument())
     return 0;
-
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_unloadEventEnd);
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->unloadEventEnd());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::domInteractive() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_domInteractive);
+  const DocumentTiming* timing = documentTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->domInteractive());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::domContentLoadedEventStart()
     const {
+  const DocumentTiming* timing = documentTiming();
+  if (!timing)
+    return 0.0;
   return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
-      m_timeOrigin, m_domContentLoadedEventStart);
+      m_timeOrigin, timing->domContentLoadedEventStart());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::domContentLoadedEventEnd()
     const {
+  const DocumentTiming* timing = documentTiming();
+  if (!timing)
+    return 0.0;
   return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
-      m_timeOrigin, m_domContentLoadedEventEnd);
+      m_timeOrigin, timing->domContentLoadedEventEnd());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::domComplete() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_domComplete);
+  const DocumentTiming* timing = documentTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->domComplete());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::loadEventStart() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_loadEventStart);
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->loadEventStart());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::loadEventEnd() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_loadEventEnd);
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->loadEventEnd());
 }
 
 AtomicString PerformanceNavigationTiming::type() const {
-  switch (m_type) {
+  DocumentLoader* loader = documentLoader();
+  DCHECK(m_frame);
+  DCHECK(loader);
+  Document* document = m_frame->document();
+  switch (PerformanceBase::getNavigationType(loader->getNavigationType(),
+                                             document)) {
+    case NavigationType::Prerender:
+      return "prerender";
     case NavigationType::Reload:
       return "reload";
     case NavigationType::BackForward:
       return "back_forward";
-    case NavigationType::Prerender:
-      return "prerender";
     case NavigationType::Navigate:
       return "navigate";
   }
   NOTREACHED();
   return "navigate";
 }
 
 unsigned short PerformanceNavigationTiming::redirectCount() const {
-  if (!m_allowRedirectDetails)
+  bool allowRedirectDetails = getAllowRedirectDetails();
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!allowRedirectDetails || !timing)
     return 0;
-  return m_redirectCount;
+  return timing->redirectCount();
+}
+
+DOMHighResTimeStamp PerformanceNavigationTiming::redirectStart() const {
+  bool allowRedirectDetails = getAllowRedirectDetails();
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!allowRedirectDetails || !timing)
+    return 0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->redirectStart());
+}
+
+DOMHighResTimeStamp PerformanceNavigationTiming::redirectEnd() const {
+  bool allowRedirectDetails = getAllowRedirectDetails();
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!allowRedirectDetails || !timing)
+    return 0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->redirectEnd());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::fetchStart() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_fetchStart);
-}
-
-DOMHighResTimeStamp PerformanceNavigationTiming::redirectStart() const {
-  if (!m_allowRedirectDetails)
-    return 0;
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_redirectStart);
-}
-
-DOMHighResTimeStamp PerformanceNavigationTiming::redirectEnd() const {
-  if (!m_allowRedirectDetails)
-    return 0;
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_redirectEnd);
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->fetchStart());
 }
 
 DOMHighResTimeStamp PerformanceNavigationTiming::responseEnd() const {
-  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(m_timeOrigin,
-                                                             m_responseEnd);
+  DocumentLoadTiming* timing = documentLoadTiming();
+  if (!timing)
+    return 0.0;
+  return PerformanceBase::monotonicTimeToDOMHighResTimeStamp(
+      m_timeOrigin, timing->responseEnd());
+}
+
+// Overriding PerformanceEntry's attributes.
+DOMHighResTimeStamp PerformanceNavigationTiming::duration() const {
+  return loadEventEnd();
 }
 
 void PerformanceNavigationTiming::buildJSONValue(
     V8ObjectBuilder& builder) const {
   PerformanceResourceTiming::buildJSONValue(builder);
   builder.addNumber("unloadEventStart", unloadEventStart());
   builder.addNumber("unloadEventEnd", unloadEventEnd());
   builder.addNumber("domInteractive", domInteractive());
   builder.addNumber("domContentLoadedEventStart", domContentLoadedEventStart());
   builder.addNumber("domContentLoadedEventEnd", domContentLoadedEventEnd());
   builder.addNumber("domComplete", domComplete());
   builder.addNumber("loadEventStart", loadEventStart());
   builder.addNumber("loadEventEnd", loadEventEnd());
   builder.addString("type", type());
   builder.addNumber("redirectCount", redirectCount());
 }
 }