Loosen FirstMeaningfulPaint UMA network-idle heuristics

third_party/WebKit/Source/core/paint/FirstMeaningfulPaintDetector.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/FirstMeaningfulPaintDetector.h"
 
 #include "core/css/FontFaceSet.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/paint/PaintTiming.h"
+#include "platform/Histogram.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 
 namespace blink {
 
 namespace {
 
 // Web fonts that laid out more than this number of characters block First
 // Meaningful Paint.
 const int kBlankCharactersThreshold = 200;
 
-// FirstMeaningfulPaintDetector stops observing layouts and reports First
-// Meaningful Paint when this duration passed from last network activity.
-const double kSecondsWithoutNetworkActivityThreshold = 0.5;
+// The page is n-quiet if there are no more than n active network requests for
+// this duration of time.
+const double kNetwork2QuietWindowSeconds = 3;
+const double kNetwork0QuietWindowSeconds = 0.5;
 
 }  // namespace
 
 FirstMeaningfulPaintDetector& FirstMeaningfulPaintDetector::from(
     Document& document) {
   return PaintTiming::from(document).firstMeaningfulPaintDetector();
 }
 
 FirstMeaningfulPaintDetector::FirstMeaningfulPaintDetector(
     PaintTiming* paintTiming,
@@ skipping 11 matching lines @@
 // Computes "layout significance" (http://goo.gl/rytlPL) of a layout operation.
 // Significance of a layout is the number of layout objects newly added to the
 // layout tree, weighted by page height (before and after the layout).
 // A paint after the most significance layout during page load is reported as
 // First Meaningful Paint.
 void FirstMeaningfulPaintDetector::markNextPaintAsMeaningfulIfNeeded(
     const LayoutObjectCounter& counter,
     int contentsHeightBeforeLayout,
     int contentsHeightAfterLayout,
     int visibleHeight) {
-  if (m_state == Reported)
+  if (m_networkState == Network0Quiet)
     return;
 
   unsigned delta = counter.count() - m_prevLayoutObjectCount;
   m_prevLayoutObjectCount = counter.count();
 
   if (visibleHeight == 0)
     return;
 
   double ratioBefore = std::max(
       1.0, static_cast<double>(contentsHeightBeforeLayout) / visibleHeight);
   double ratioAfter = std::max(
       1.0, static_cast<double>(contentsHeightAfterLayout) / visibleHeight);
   double significance = delta / ((ratioBefore + ratioAfter) / 2);
 
   // If the page has many blank characters, the significance value is
   // accumulated until the text become visible.
   int approximateBlankCharacterCount =
       FontFaceSet::approximateBlankCharacterCount(*document());
   if (approximateBlankCharacterCount > kBlankCharactersThreshold) {
     m_accumulatedSignificanceWhileHavingBlankText += significance;
   } else {
     significance += m_accumulatedSignificanceWhileHavingBlankText;
     m_accumulatedSignificanceWhileHavingBlankText = 0;
     if (significance > m_maxSignificanceSoFar) {
-      m_state = NextPaintIsMeaningful;
+      m_nextPaintIsMeaningful = true;
       m_maxSignificanceSoFar = significance;
     }
   }
 }
 
 void FirstMeaningfulPaintDetector::notifyPaint() {
-  if (m_state != NextPaintIsMeaningful)
+  if (!m_nextPaintIsMeaningful)
     return;
 
   // Skip document background-only paints.
   if (m_paintTiming->firstPaint() == 0.0)
     return;
 
   m_provisionalFirstMeaningfulPaint = monotonicallyIncreasingTime();
-  m_state = NextPaintIsNotMeaningful;
+  m_nextPaintIsMeaningful = false;
+  m_networkStateAtFirstMeaningfulPaint = m_networkState;
+
+  if (m_networkState != NetworkActive)
+    return;
 
   TRACE_EVENT_MARK_WITH_TIMESTAMP1(
       "loading", "firstMeaningfulPaintCandidate",
       TraceEvent::toTraceTimestamp(m_provisionalFirstMeaningfulPaint), "frame",
       document()->frame());
   // Ignore the first meaningful paint candidate as this generally is the first
   // contentful paint itself.
   if (!m_seenFirstMeaningfulPaintCandidate) {
     m_seenFirstMeaningfulPaintCandidate = true;
     return;
   }
   m_paintTiming->markFirstMeaningfulPaintCandidate();
 }
 
+bool FirstMeaningfulPaintDetector::isNetworkQuiet(int maxActiveConnections) {
+  DCHECK(document());
+  if (!document()->hasFinishedParsing())
+    return false;
+  ResourceFetcher* fetcher = document()->fetcher();
+  return fetcher->blockingRequestCount() + fetcher->nonblockingRequestCount() <=
+         maxActiveConnections;
+}
+
 void FirstMeaningfulPaintDetector::checkNetworkStable() {
-  DCHECK(document());
-  if (m_state == Reported || document()->fetcher()->hasPendingRequest())
-    return;
+  switch (m_networkState) {
+    case NetworkActive:
+      if (!isNetworkQuiet(2))
+        return;
+      m_networkStableTimer.startOneShot(kNetwork2QuietWindowSeconds,
+                                        BLINK_FROM_HERE);
+      break;
 
-  m_networkStableTimer.startOneShot(kSecondsWithoutNetworkActivityThreshold,
-                                    BLINK_FROM_HERE);
+    case Network2Quiet:
+      if (!isNetworkQuiet(0))
+        return;
+      m_networkStableTimer.startOneShot(kNetwork0QuietWindowSeconds,
+                                        BLINK_FROM_HERE);
+      break;
+
+    case Network0Quiet:
+      break;
+  }
 }
 
 void FirstMeaningfulPaintDetector::networkStableTimerFired(TimerBase*) {
-  if (m_state == Reported || !document() ||
-      document()->fetcher()->hasPendingRequest() ||
-      !m_paintTiming->firstContentfulPaint())
+  // This histogram is logged when the page reached network 0-quiet, so only
+  // possible values are NetworkActive and Network2Quiet.
+  DEFINE_STATIC_LOCAL(
+      EnumerationHistogram, networkStateAtFirstMeaningfulPaintHistogram,
+      ("PageLoad.Experimental.PaintTiming.NetworkStateAtFirstMeaningfulPaint",
+       Network0Quiet));
+
+  if (!document())
     return;
 
-  if (m_provisionalFirstMeaningfulPaint) {
-    // Enforce FirstContentfulPaint <= FirstMeaningfulPaint.
-    double timestamp = std::max(m_provisionalFirstMeaningfulPaint,
-                                m_paintTiming->firstContentfulPaint());
-    m_paintTiming->setFirstMeaningfulPaint(timestamp);
+  switch (m_networkState) {
+    case NetworkActive:
+      if (!isNetworkQuiet(2) || !m_paintTiming->firstContentfulPaint())
+        return;
+      m_networkState = Network2Quiet;
+      // Report FirstMeaningfulPaint when the page reached network 2-quiet.
+      if (m_provisionalFirstMeaningfulPaint) {
+        // Enforce FirstContentfulPaint <= FirstMeaningfulPaint.
+        double timestamp = std::max(m_provisionalFirstMeaningfulPaint,
+                                    m_paintTiming->firstContentfulPaint());
+        m_paintTiming->setFirstMeaningfulPaint(timestamp);
+      }
+      checkNetworkStable();
+      break;
+
+    case Network2Quiet:
+      if (!isNetworkQuiet(0))
+        return;
+      m_networkState = Network0Quiet;
+      networkStateAtFirstMeaningfulPaintHistogram.count(
+          m_networkStateAtFirstMeaningfulPaint);
+      break;
+
+    case Network0Quiet:
+      NOTREACHED();
+      break;
   }
-  m_state = Reported;
 }
 
 DEFINE_TRACE(FirstMeaningfulPaintDetector) {
   visitor->trace(m_paintTiming);
 }
 
 }  // namespace blink