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/network/ResourceTimingInfo.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/CurrentTime.h"
 #include <algorithm>
 
 namespace blink {
 
 using PerformanceObserverVector = HeapVector<Member<PerformanceObserver>>;
 
 static const size_t defaultResourceTimingBufferSize = 150;
 static const size_t defaultFrameTimingBufferSize = 150;
 

[panicker, 2016/11/02 20:12:37]

probably needs a buffer size?
(only have 1 entry)

[sunjian, 2016/11/04 01:12:38]

Since it's only one element, probably don't need a buffer size or a vector.

 PerformanceBase::PerformanceBase(double timeOrigin)
     : m_frameTimingBufferSize(defaultFrameTimingBufferSize),
       m_resourceTimingBufferSize(defaultResourceTimingBufferSize),
       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);
+  entries.appendVector(m_navigationTimingBuffer);
   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;
@@ skipping 74 matching lines @@
 
   std::sort(entries.begin(), entries.end(),
             PerformanceEntry::startTimeCompareLessThan);
   return entries;
 }
 
 void PerformanceBase::clearResourceTimings() {
   m_resourceTimingBuffer.clear();
 }
 
+void PerformanceBase::clearNavigationTimings() {
+  m_navigationTimingBuffer.clear();
+}
+
 void PerformanceBase::setResourceTimingBufferSize(unsigned size) {
   m_resourceTimingBufferSize = size;
   if (isResourceTimingBufferFull()) {
     dispatchEvent(Event::create(EventTypeNames::resourcetimingbufferfull));
     dispatchEvent(
         Event::create(EventTypeNames::webkitresourcetimingbufferfull));
   }
 }
 
 void PerformanceBase::clearFrameTimings() {
@@ skipping 104 matching lines @@
   double lastRedirectEndTime = lastRedirectTiming->receiveHeadersEnd();
 
   PerformanceEntry* entry = PerformanceResourceTiming::create(
       info, timeOrigin(), startTime, lastRedirectEndTime, allowTimingDetails,
       allowRedirectDetails);
   notifyObserversOfEntry(*entry);
   if (!isResourceTimingBufferFull())
     addResourceTimingBuffer(*entry);
 }
 
+const DocumentLoader* PerformanceBase::documentLoader(LocalFrame* frame) {
+  if (!frame)
+    return nullptr;
+  return frame->loader().documentLoader();
+}
+
+const DocumentLoadTiming* PerformanceBase::documentLoadTiming(
+    LocalFrame* frame) {
+  const DocumentLoader* loader = documentLoader(frame);
+  if (!loader)
+    return nullptr;
+  return &loader->timing();
+}
+
+const DocumentTiming* PerformanceBase::documentTiming(LocalFrame* frame) {
+  if (!frame)
+    return nullptr;
+
+  Document* document = frame->document();
+  if (!document)
+    return nullptr;
+
+  return &document->timing();
+}
+
+AtomicString PerformanceBase::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";
+  }
+}
+
+void PerformanceBase::addNavigationTiming(LocalFrame* frame) {

[panicker, 2016/11/02 20:12:37]

Add a check for the runtimeflag:
if (!RuntimeEnabledFeatures::yourflagname())
  return

[sunjian, 2016/11/04 01:12:38]

Done.

+  DCHECK(!frame);
+  if (!frame)
+    return;
+  const DocumentLoader* documentLoader = PerformanceBase::documentLoader(frame);
+  DCHECK(!documentLoader);
+  if (!documentLoader)

[panicker, 2016/11/02 20:12:37]

replace DCHECK with ASSERT and remove this if

[sunjian, 2016/11/04 01:12:38]

Done.

+    return;
+  const DocumentLoadTiming* documentLoadTiming =
+      PerformanceBase::documentLoadTiming(frame);
+  const DocumentTiming* documentTiming = PerformanceBase::documentTiming(frame);
+  DCHECK(!documentLoadTiming);
+  DCHECK(!documentTiming);
+  if (!documentTiming || !documentLoadTiming)

[panicker, 2016/11/02 20:12:37]

(same comment)

[sunjian, 2016/11/04 01:12:38]

Done.

+    return;
+
+  ResourceResponse finalResponse = documentLoader->response();
+
+  // Right now NavigationType doesn't seem to have a Prerender type yet

[panicker, 2016/11/02 20:12:37]

Prefix with:
// TODO(sunjian): Right now ....

[sunjian, 2016/11/04 01:12:39]

Done.

+  // Need to look into this
+  AtomicString type = getNavigationType(frame);
+
+  ResourceLoadTiming* resourceLoadTiming = finalResponse.resourceLoadTiming();
+  double lastRedirectEndTime = documentLoadTiming->redirectEnd();
+  double finishTime = documentLoadTiming->loadEventEnd();
+  // TODO(sunjian) for now just use encodedDataLength as transferSize, but will

[panicker, 2016/11/02 20:12:37]

for now just set it to 0 

[sunjian, 2016/11/04 01:12:39]

Done.

+  // have to come
+  // back and fix it.
+  unsigned long long transferSize = finalResponse.encodedDataLength();
+  unsigned long long encodedBodyLength = finalResponse.encodedBodyLength();
+  unsigned long long decodedBodyLength = finalResponse.decodedBodyLength();
+  bool didReuseConnection = finalResponse.connectionReused();
+
+  PerformanceEntry* entry = PerformanceNavigationTiming::create(
+      timeOrigin(), documentLoadTiming->unloadEventStart(),
+      documentLoadTiming->unloadEventEnd(),
+      documentLoadTiming->loadEventStart(), documentLoadTiming->loadEventEnd(),
+      documentLoadTiming->redirectCount(), documentTiming->domInteractive(),
+      documentTiming->domContentLoadedEventStart(),
+      documentTiming->domContentLoadedEventEnd(), documentTiming->domComplete(),
+      type, documentLoadTiming->redirectStart(),
+      documentLoadTiming->redirectEnd(), documentLoadTiming->fetchStart(),
+      documentLoadTiming->responseEnd(),
+      documentLoadTiming->hasCrossOriginRedirect(),
+      documentLoadTiming->hasSameOriginAsPreviousDocument(), resourceLoadTiming,
+      lastRedirectEndTime, finishTime, transferSize, encodedBodyLength,
+      decodedBodyLength, didReuseConnection);
+  notifyObserversOfEntry(*entry);
+  m_navigationTimingBuffer.append(entry);

[panicker, 2016/11/02 20:12:37]

assert that there's at most 1 entry in buffer?

[sunjian, 2016/11/04 01:12:38]

Done.

+}
+
 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_navigationTimingBuffer);
   visitor->trace(m_userTiming);
   visitor->trace(m_observers);
   visitor->trace(m_activeObservers);
   visitor->trace(m_suspendedObservers);
   EventTargetWithInlineData::trace(visitor);
 }
 
 }  // namespace blink