Navigation Timing Level 2

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

 /*
  * Copyright (C) 2010 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 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #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"
 #include <algorithm>
 
 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;
 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),
       m_deliverObservationsTimer(
           this,
           &PerformanceBase::deliverObservationsTimerFired) {}
 
 PerformanceBase::~PerformanceBase() {}
 
 const AtomicString& PerformanceBase::interfaceName() const {
   return EventTargetNames::Performance;
 }
 
 PerformanceTiming* PerformanceBase::timing() const {
   return nullptr;
 }
 
 PerformanceEntryVector PerformanceBase::getEntries() const {
   PerformanceEntryVector entries;
 
   entries.appendVector(m_resourceTimingBuffer);
+  if (RuntimeEnabledFeatures::performanceNavigationTimingEnabled())
+    entries.append(m_navigationTiming);
   entries.appendVector(m_frameTimingBuffer);
 
   if (m_userTiming) {
     entries.appendVector(m_userTiming->getMarks());
     entries.appendVector(m_userTiming->getMeasures());
   }
 
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::startTimeCompareLessThan);
   return entries;
 }
 
 PerformanceEntryVector PerformanceBase::getEntriesByType(
     const String& entryType) {
   PerformanceEntryVector entries;
   PerformanceEntry::EntryType type =
       PerformanceEntry::toEntryTypeEnum(entryType);
 
   switch (type) {
     case PerformanceEntry::Invalid:
       return entries;
     case PerformanceEntry::LongTask:
       // Unsupported for LongTask. Per the spec, Long task entries can only be
       // accessed via Performance Observer. No separate buffer is maintained.
       return entries;
     case PerformanceEntry::Resource:
       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) {
         if (type == frame->entryTypeEnum()) {
           entries.append(frame);
         }
       }
       break;
     case PerformanceEntry::Mark:
       if (m_userTiming)
@@ skipping 20 matching lines @@
   if (!entryType.isNull() && type == PerformanceEntry::Invalid)
     return entries;
 
   if (entryType.isNull() || type == PerformanceEntry::Resource) {
     for (const auto& resource : m_resourceTimingBuffer) {
       if (resource->name() == name)
         entries.append(resource);
     }
   }
 
+  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) {
       if (frame->name() == name &&
           (entryType.isNull() || entryType == frame->entryType()))
         entries.append(frame);
     }
   }
 
   if (m_userTiming) {
@@ skipping 129 matching lines @@
   double lastRedirectEndTime = lastRedirectTiming->receiveHeadersEnd();
 
   PerformanceEntry* entry = PerformanceResourceTiming::create(
       info, timeOrigin(), startTime, lastRedirectEndTime, allowTimingDetails,
       allowRedirectDetails);
   notifyObserversOfEntry(*entry);
   if (!isResourceTimingBufferFull())
     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);
 
   if (isResourceTimingBufferFull()) {
     dispatchEvent(Event::create(EventTypeNames::resourcetimingbufferfull));
     dispatchEvent(
         Event::create(EventTypeNames::webkitresourcetimingbufferfull));
   }
 }
 
@@ skipping 152 matching lines @@
   return monotonicTimeToDOMHighResTimeStamp(monotonicTime) * 1000;
 }
 
 DOMHighResTimeStamp PerformanceBase::now() const {
   return monotonicTimeToDOMHighResTimeStamp(monotonicallyIncreasingTime());
 }
 
 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);
   visitor->trace(m_suspendedObservers);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink