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

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 62 matching lines @@
       m_userTiming(nullptr),
       m_timeOrigin(timeOrigin),
       m_observerFilterOptions(PerformanceEntry::Invalid),
       m_deliverObservationsTimer(
           std::move(taskRunner),
           this,
           &PerformanceBase::deliverObservationsTimerFired) {}
 
 PerformanceBase::~PerformanceBase() {}
 
-PerformanceNavigationTiming::NavigationType PerformanceBase::getNavigationType(
-    NavigationType type,
-    const Document* document) {
-  if (document &&
-      document->pageVisibilityState() == PageVisibilityStatePrerender) {
-    return PerformanceNavigationTiming::NavigationType::Prerender;
-  }
-  switch (type) {
-    case NavigationTypeReload:
-      return PerformanceNavigationTiming::NavigationType::Reload;
-    case NavigationTypeBackForward:
-      return PerformanceNavigationTiming::NavigationType::BackForward;
-    case NavigationTypeLinkClicked:
-    case NavigationTypeFormSubmitted:
-    case NavigationTypeFormResubmitted:
-    case NavigationTypeOther:
-      return PerformanceNavigationTiming::NavigationType::Navigate;
-  }
-  NOTREACHED();
-  return PerformanceNavigationTiming::NavigationType::Navigate;
-}
-
 const AtomicString& PerformanceBase::interfaceName() const {
   return EventTargetNames::Performance;
 }
 
 PerformanceTiming* PerformanceBase::timing() const {
   return nullptr;
 }
 
-PerformanceEntryVector PerformanceBase::getEntries() const {
+PerformanceEntryVector PerformanceBase::getEntries() {
   PerformanceEntryVector entries;
 
   entries.appendVector(m_resourceTimingBuffer);
+  if (!m_navigationTiming)
+    m_navigationTiming = createNavigationTimingInstance();
+  // This extra checking is needed when WorkerPerformance
+  // calls this method.
   if (m_navigationTiming)
     entries.push_back(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::Resource:
       for (const auto& resource : m_resourceTimingBuffer)
         entries.push_back(resource);
       break;
     case PerformanceEntry::Navigation:
+      if (!m_navigationTiming)
+        m_navigationTiming = createNavigationTimingInstance();
       if (m_navigationTiming)
         entries.push_back(m_navigationTiming);
       break;
     case PerformanceEntry::Composite:
     case PerformanceEntry::Render:
       for (const auto& frame : m_frameTimingBuffer) {
         if (type == frame->entryTypeEnum()) {
           entries.push_back(frame);
         }
       }
@@ skipping 35 matching lines @@
     return entries;
 
   if (entryType.isNull() || type == PerformanceEntry::Resource) {
     for (const auto& resource : m_resourceTimingBuffer) {
       if (resource->name() == name)
         entries.push_back(resource);
     }
   }
 
   if (entryType.isNull() || type == PerformanceEntry::Navigation) {
+    if (!m_navigationTiming)
+      m_navigationTiming = createNavigationTimingInstance();
     if (m_navigationTiming && m_navigationTiming->name() == name)
       entries.push_back(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.push_back(frame);
@@ 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::performanceNavigationTiming2Enabled())

[Kunihiko Sakamoto, 2017/02/13 08:22:29]

Does this runtime flag still work after your change?

[sunjian, 2017/02/14 21:29:03]

I don't think we need the flag any more since this feature is already flipped to
stable.

[Kunihiko Sakamoto, 2017/02/15 06:35:30]

The flag makes it easier to unship the feature if a critical security / privacy
issue is found. I recommend keeping it functional for 1-2 milestones after
launch, unless it's hard to maintain.

Maybe we can just make createNavigationTimingInstance() return nullptr if the
flag is off?

[sunjian, 2017/02/15 20:30:28]

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;
-
-  ResourceTimingInfo* navigationTimingInfo =
-      documentLoader->getNavigationTimingInfo();
-  if (!navigationTimingInfo)
-    return;
-
-  const ResourceResponse& finalResponse = navigationTimingInfo->finalResponse();
-
-  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();
-
-  ExecutionContext* context = getExecutionContext();
-  SecurityOrigin* securityOrigin = getSecurityOrigin(context);
-  if (!securityOrigin)
-    return;
-
-  bool allowRedirectDetails =
-      allowsTimingRedirect(navigationTimingInfo->redirectChain(), finalResponse,
-                           *securityOrigin, context);
-
-  unsigned long long transferSize = navigationTimingInfo->transferSize();
-  unsigned long long encodedBodyLength = finalResponse.encodedBodyLength();
-  unsigned long long decodedBodyLength = finalResponse.decodedBodyLength();
-  bool didReuseConnection = finalResponse.connectionReused();
-  PerformanceNavigationTiming::NavigationType type =
-      getNavigationType(documentLoader->getNavigationType(), frame->document());
-
-  m_navigationTiming = new PerformanceNavigationTiming(
-      timeOrigin(), navigationTimingInfo->initialURL().getString(),
-      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, type,
-      documentLoadTiming.redirectStart(), documentLoadTiming.redirectEnd(),
-      documentLoadTiming.fetchStart(), documentLoadTiming.responseEnd(),
-      allowRedirectDetails,
-      documentLoadTiming.hasSameOriginAsPreviousDocument(), resourceLoadTiming,
-      lastRedirectEndTime, finishTime, transferSize, encodedBodyLength,
-      decodedBodyLength, didReuseConnection);
-  notifyObserversOfEntry(*m_navigationTiming);
+// Called after loadEventEnd happens.
+void PerformanceBase::notifyNavigationTimingToObservers() {
+  if (!m_navigationTiming)
+    m_navigationTiming = createNavigationTimingInstance();
+  if (m_navigationTiming)
+    notifyObserversOfEntry(*m_navigationTiming);
 }
 
 void PerformanceBase::addFirstPaintTiming(double startTime) {
   addPaintTiming(PerformancePaintTiming::PaintType::FirstPaint, startTime);
 }
 
 void PerformanceBase::addFirstContentfulPaintTiming(double startTime) {
   addPaintTiming(PerformancePaintTiming::PaintType::FirstContentfulPaint,
                  startTime);
 }
@@ skipping 184 matching lines @@
   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