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 6ba9a2000253cb958586e3e9a673c46ae36cae33..6b4549c0f17b88f333c8f331616bcea357620c66 100644
--- a/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
+++ b/third_party/WebKit/Source/core/timing/PerformanceBase.cpp
@@ -32,12 +32,18 @@
 #include "core/timing/PerformanceBase.h"
 
 #include "core/dom/Document.h"
+#include "core/dom/DocumentTiming.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"
@@ -74,6 +80,8 @@ PerformanceEntryVector PerformanceBase::getEntries() const {
   PerformanceEntryVector entries;
 
   entries.appendVector(m_resourceTimingBuffer);
+  if (m_navigationTiming)
+    entries.append(m_navigationTiming);
   entries.appendVector(m_frameTimingBuffer);
 
   if (m_userTiming) {
@@ -103,6 +111,10 @@ PerformanceEntryVector PerformanceBase::getEntriesByType(
       for (const auto& resource : m_resourceTimingBuffer)
         entries.append(resource);
       break;
+    case PerformanceEntry::Navigation:
+      if (m_navigationTiming)
+        entries.append(m_navigationTiming);
+      break;
     case PerformanceEntry::Composite:
     case PerformanceEntry::Render:
       for (const auto& frame : m_frameTimingBuffer) {
@@ -143,6 +155,11 @@ PerformanceEntryVector PerformanceBase::getEntriesByName(
     }
   }
 
+  if (entryType.isNull() || type == PerformanceEntry::Navigation) {
+    if (m_navigationTiming && 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 +309,52 @@ void PerformanceBase::addResourceTiming(const ResourceTimingInfo& info) {
     addResourceTimingBuffer(*entry);
 }
 
+void PerformanceBase::addNavigationTiming(LocalFrame* frame) {
+  if (!RuntimeEnabledFeatures::performanceNavigationTiming2Enabled())

[Rick Byers, 2016/11/21 19:05:01]

So the intent here is to implement the new API behind a flag but not ship
anything new yet, right?  If that's the case then you should add
[RuntimeEnabled=PerformanceNavigationTiming2] to the PerformanceNavigationTiming
interface definition.  That'll keep feature detects like "if
(window.PerformanceNavigationTiming)" from succeeding before you flip the
RuntimeEnabledFeature.  It'll also avoid any changes to
virtual/stable/webexposed test output :-)

[panicker, 2016/11/21 19:24:39]

Good catch (Jian is updating)
Although just want to mention that we still need this check here. 
The way this inherits from PerformanceEntry, only the additional fields added in
subclass are behind the flag in IDL, and without this check, one can still get
to the base fields in PerformanceEntry with something like
getEntriesByType("navigation")  (this was a surprise to me).

[sunjian, 2016/11/21 21:25:17]

Done.

+    return;
+  DCHECK(frame);
+  const DocumentLoader* documentLoader = frame->loader().documentLoader();
+  DCHECK(documentLoader);
+  const DocumentLoadTiming& documentLoadTiming = documentLoader->timing();
+
+  const DocumentTiming* documentTiming =
+      frame->document() ? &(frame->document()->timing()) : nullptr;
+
+  const ResourceResponse& finalResponse = documentLoader->response();
+
+  ResourceLoadTiming* resourceLoadTiming = finalResponse.resourceLoadTiming();
+  // Don't create a navigation timing instance when
+  // resourceLoadTiming is null, which could happen when visiting non-http sites
+  // such as about:blank or in some error cases.
+  if (!resourceLoadTiming)
+    return;
+  double lastRedirectEndTime = documentLoadTiming.redirectEnd();
+  double finishTime = documentLoadTiming.loadEventEnd();
+
+  // TODO(sunjian) Implement transfer size. crbug/663187
+  unsigned long long transferSize = 0;
+  unsigned long long encodedBodyLength = finalResponse.encodedBodyLength();
+  unsigned long long decodedBodyLength = finalResponse.decodedBodyLength();
+  bool didReuseConnection = finalResponse.connectionReused();
+
+  m_navigationTiming = new PerformanceNavigationTiming(
+      timeOrigin(), documentLoadTiming.unloadEventStart(),
+      documentLoadTiming.unloadEventEnd(), documentLoadTiming.loadEventStart(),
+      documentLoadTiming.loadEventEnd(), documentLoadTiming.redirectCount(),
+      documentTiming ? documentTiming->domInteractive() : 0,
+      documentTiming ? documentTiming->domContentLoadedEventStart() : 0,
+      documentTiming ? documentTiming->domContentLoadedEventEnd() : 0,
+      documentTiming ? documentTiming->domComplete() : 0,
+      documentLoader->getNavigationType(), documentLoadTiming.redirectStart(),
+      documentLoadTiming.redirectEnd(), documentLoadTiming.fetchStart(),
+      documentLoadTiming.responseEnd(),
+      documentLoadTiming.hasCrossOriginRedirect(),
+      documentLoadTiming.hasSameOriginAsPreviousDocument(), resourceLoadTiming,
+      lastRedirectEndTime, finishTime, transferSize, encodedBodyLength,
+      decodedBodyLength, didReuseConnection);
+  notifyObserversOfEntry(*m_navigationTiming);
+}
+
 void PerformanceBase::addResourceTimingBuffer(PerformanceEntry& entry) {
   m_resourceTimingBuffer.append(&entry);
 
@@ -464,6 +527,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);