Navigation Timing Level 2

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

Index: third_party/WebKit/Source/core/timing/PerformanceBase.cpp
diff --git a/third_party/WebKit/Source/core/timing/PerformanceBase.cpp b/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
index 88094fa06e3bbc734cc74a5cfebffa8c64b236f7..a7191fc7591fcf3607099160b25138b9bc4f6270 100644
--- a/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
+++ b/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
@@ -32,12 +32,19 @@
 #include "core/timing/PerformanceBase.h"
 
 #include "core/dom/Document.h"
+#include "core/dom/DocumentTiming.h"
+#include "core/dom/Element.h"
 #include "core/events/Event.h"
+#include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
+#include "core/loader/DocumentLoadTiming.h"
+#include "core/loader/DocumentLoader.h"
 #include "core/timing/PerformanceLongTaskTiming.h"
+#include "core/timing/PerformanceNavigationTiming.h"
 #include "core/timing/PerformanceObserver.h"
 #include "core/timing/PerformanceResourceTiming.h"
 #include "core/timing/PerformanceUserTiming.h"
+#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
@@ -45,6 +52,50 @@
 
 namespace blink {
 
+namespace {
+const DocumentLoader* documentLoader(LocalFrame* frame) {
+  if (!frame)
+    return nullptr;
+  return frame->loader().documentLoader();
+}
+
+const DocumentLoadTiming* documentLoadTiming(LocalFrame* frame) {
+  const DocumentLoader* loader = documentLoader(frame);
+  if (!loader)
+    return nullptr;
+  return &loader->timing();
+}
+
+const DocumentTiming* documentTiming(LocalFrame* frame) {
+  if (!frame)
+    return nullptr;
+
+  Document* document = frame->document();
+  if (!document)
+    return nullptr;
+
+  return &document->timing();
+}

[kinuko, 2016/11/06 15:16:43]

Not really sure if adding these helper methods are super useful.  These all seem
to be called only once and we're DCHECK'ing on the results, then why we need
these extra null checks?

[sunjian, 2016/11/08 02:10:18]

Done.

+
+AtomicString getNavigationType(LocalFrame* frame) {
+  if (!frame)
+    return "navigate";
+
+  DocumentLoader* documentLoader = frame->loader().documentLoader();
+  if (!documentLoader)
+    return "navigate";
+
+  switch (documentLoader->getNavigationType()) {
+    case NavigationTypeReload:
+      return "reload";
+    case NavigationTypeBackForward:
+      return "back_forward";
+    default:
+      return "navigate";

[kinuko, 2016/11/06 15:16:43]

Do these need to use AtomicString?  Calling this seems to always construct an
atomic string which involves hash lookup.  I think we could use a simple enum
here and return a String only when PerformanceNavigationTiming.type is accessed.

[sunjian, 2016/11/08 02:10:19]

Done.

+  }
+}
+}

[kinuko, 2016/11/06 15:16:43]

nit: }  // namespace

[sunjian, 2016/11/08 02:10:19]

No need anymore.

+
 using PerformanceObserverVector = HeapVector<Member<PerformanceObserver>>;
 
 static const size_t defaultResourceTimingBufferSize = 150;
@@ -53,6 +104,7 @@ static const size_t defaultFrameTimingBufferSize = 150;
 PerformanceBase::PerformanceBase(double timeOrigin)
     : m_frameTimingBufferSize(defaultFrameTimingBufferSize),
       m_resourceTimingBufferSize(defaultResourceTimingBufferSize),
+      m_navigationTiming(nullptr),
       m_userTiming(nullptr),
       m_timeOrigin(timeOrigin),
       m_observerFilterOptions(PerformanceEntry::Invalid),
@@ -74,6 +126,8 @@ PerformanceEntryVector PerformanceBase::getEntries() const {
   PerformanceEntryVector entries;
 
   entries.appendVector(m_resourceTimingBuffer);
+  if (RuntimeEnabledFeatures::performanceNavigationTimingEnabled())
+    entries.append(m_navigationTiming);
   entries.appendVector(m_frameTimingBuffer);
 
   if (m_userTiming) {
@@ -103,6 +157,11 @@ PerformanceEntryVector PerformanceBase::getEntriesByType(
       for (const auto& resource : m_resourceTimingBuffer)
         entries.append(resource);
       break;
+    case PerformanceEntry::Navigation:
+      if (RuntimeEnabledFeatures::performanceNavigationTimingEnabled()) {
+        entries.append(m_navigationTiming);
+      }

[kinuko, 2016/11/06 15:16:43]

nit: no { } for single-line body in blink

[sunjian, 2016/11/08 02:10:19]

Done.

+      break;
     case PerformanceEntry::Composite:
     case PerformanceEntry::Render:
       for (const auto& frame : m_frameTimingBuffer) {
@@ -143,6 +202,12 @@ PerformanceEntryVector PerformanceBase::getEntriesByName(
     }
   }
 
+  if (entryType.isNull() || type == PerformanceEntry::Navigation) {
+    if (RuntimeEnabledFeatures::performanceNavigationTimingEnabled() &&
+        m_navigationTiming->name() == name)
+      entries.append(m_navigationTiming);
+  }
+
   if (entryType.isNull() || type == PerformanceEntry::Composite ||
       type == PerformanceEntry::Render) {
     for (const auto& frame : m_frameTimingBuffer) {
@@ -292,6 +357,48 @@ void PerformanceBase::addResourceTiming(const ResourceTimingInfo& info) {
     addResourceTimingBuffer(*entry);
 }
 
+void PerformanceBase::addNavigationTiming(LocalFrame* frame) {
+  if (!RuntimeEnabledFeatures::performanceNavigationTimingEnabled())
+    return;
+  DCHECK(frame);
+  const DocumentLoader* docLoader = documentLoader(frame);
+  DCHECK(docLoader);
+  const DocumentLoadTiming* docLoadTiming = documentLoadTiming(frame);
+  const DocumentTiming* docTiming = documentTiming(frame);
+  DCHECK(docLoadTiming);
+  DCHECK(docTiming);
+
+  ResourceResponse finalResponse = docLoader->response();
+
+  // TODO(sunjian) Right now NavigationType doesn't seem to have a Prerender
+  // type yet, need to look into this
+  AtomicString type = getNavigationType(frame);
+
+  ResourceLoadTiming* resourceLoadTiming = finalResponse.resourceLoadTiming();
+  double lastRedirectEndTime = docLoadTiming->redirectEnd();
+  double finishTime = docLoadTiming->loadEventEnd();
+
+  // TODO(sunjian) Implement transfer size.

[kinuko, 2016/11/06 15:16:43]

please link to a bug

[sunjian, 2016/11/08 02:10:19]

Done.

+  unsigned long long transferSize = 0;
+  unsigned long long encodedBodyLength = finalResponse.encodedBodyLength();
+  unsigned long long decodedBodyLength = finalResponse.decodedBodyLength();
+  bool didReuseConnection = finalResponse.connectionReused();
+
+  m_navigationTiming = PerformanceNavigationTiming::create(
+      timeOrigin(), docLoadTiming->unloadEventStart(),
+      docLoadTiming->unloadEventEnd(), docLoadTiming->loadEventStart(),
+      docLoadTiming->loadEventEnd(), docLoadTiming->redirectCount(),
+      docTiming->domInteractive(), docTiming->domContentLoadedEventStart(),
+      docTiming->domContentLoadedEventEnd(), docTiming->domComplete(), type,
+      docLoadTiming->redirectStart(), docLoadTiming->redirectEnd(),
+      docLoadTiming->fetchStart(), docLoadTiming->responseEnd(),
+      docLoadTiming->hasCrossOriginRedirect(),
+      docLoadTiming->hasSameOriginAsPreviousDocument(), resourceLoadTiming,
+      lastRedirectEndTime, finishTime, transferSize, encodedBodyLength,
+      decodedBodyLength, didReuseConnection);
+  notifyObserversOfEntry(*m_navigationTiming);
+}
+
 void PerformanceBase::addResourceTimingBuffer(PerformanceEntry& entry) {
   m_resourceTimingBuffer.append(&entry);
 
@@ -464,6 +571,7 @@ DOMHighResTimeStamp PerformanceBase::now() const {
 DEFINE_TRACE(PerformanceBase) {
   visitor->trace(m_frameTimingBuffer);
   visitor->trace(m_resourceTimingBuffer);
+  visitor->trace(m_navigationTiming);
   visitor->trace(m_userTiming);
   visitor->trace(m_observers);
   visitor->trace(m_activeObservers);