WebFonts intervention: Add metrics only for miss-cached loading

third_party/WebKit/Source/core/css/RemoteFontFaceSource.cpp

 // Copyright 2014 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/css/RemoteFontFaceSource.h"
 
 #include "core/css/CSSCustomFontData.h"
 #include "core/css/CSSFontFace.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/dom/Document.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "public/platform/WebEffectiveConnectionType.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
-    bool isEffectiveConnectionTypeSlowFor(Document* document)
-    {
-        WebEffectiveConnectionType type = document->frame()->loader().client()->getEffectiveConnectionType();
+bool isEffectiveConnectionTypeSlowFor(Document* document)
+{
+    WebEffectiveConnectionType type = document->frame()->loader().client()->getEffectiveConnectionType();
 
-        WebEffectiveConnectionType thresholdType = RuntimeEnabledFeatures::webFontsInterventionV2With2GEnabled()
-            ? WebEffectiveConnectionType::Type2G
-            : WebEffectiveConnectionType::TypeSlow2G;
+    WebEffectiveConnectionType thresholdType = RuntimeEnabledFeatures::webFontsInterventionV2With2GEnabled()
+        ? WebEffectiveConnectionType::Type2G
+        : WebEffectiveConnectionType::TypeSlow2G;
 
-        return WebEffectiveConnectionType::TypeOffline <= type && type <= thresholdType;
-    }
+    return WebEffectiveConnectionType::TypeOffline <= type && type <= thresholdType;
+}
 
-    bool isConnectionTypeSlow()
-    {
-        return networkStateNotifier().connectionType() == WebConnectionTypeCellular2G;
-    }
+bool isConnectionTypeSlow()
+{
+    return networkStateNotifier().connectionType() == WebConnectionTypeCellular2G;
+}
 
-    bool shouldTriggerWebFontsIntervention(Document* document, FontDisplay display)
-    {
-        if (RuntimeEnabledFeatures::webFontsInterventionTriggerEnabled())
-            return true;
+bool shouldTriggerWebFontsIntervention(Document* document, FontDisplay display, bool isLoadedFromMemoryCache)
+{
+    if (isLoadedFromMemoryCache)
+        return false;

[Kunihiko Sakamoto, 2016/06/27 09:07:45]

So, we no longer trigger the intervention for memory-cached fonts -- could you
update the CL description for this behavior change?

[Takashi Toyoshima, 2016/06/27 09:39:40]

Done.

+    if (RuntimeEnabledFeatures::webFontsInterventionTriggerEnabled())
+        return true;
 
-        bool isV2Enabled = RuntimeEnabledFeatures::webFontsInterventionV2With2GEnabled() || RuntimeEnabledFeatures::webFontsInterventionV2WithSlow2GEnabled();
+    bool isV2Enabled = RuntimeEnabledFeatures::webFontsInterventionV2With2GEnabled() || RuntimeEnabledFeatures::webFontsInterventionV2WithSlow2GEnabled();
 
-        bool networkIsSlow = isV2Enabled ? isEffectiveConnectionTypeSlowFor(document) : isConnectionTypeSlow();
+    bool networkIsSlow = isV2Enabled ? isEffectiveConnectionTypeSlowFor(document) : isConnectionTypeSlow();
 
-        return networkIsSlow && display == FontDisplayAuto;
-    }
+    return networkIsSlow && display == FontDisplayAuto;
+}
 
 } // namespace
 
 RemoteFontFaceSource::RemoteFontFaceSource(FontResource* font, CSSFontSelector* fontSelector, FontDisplay display)
     : m_font(font)
     , m_fontSelector(fontSelector)
     , m_display(display)
     , m_period(display == FontDisplaySwap ? SwapPeriod : BlockPeriod)
     , m_isInterventionTriggered(false)
+    , m_isLoadedFromMemoryCache(font->isLoaded())
 {
     ThreadState::current()->registerPreFinalizer(this);
     m_font->addClient(this);
 
-    if (shouldTriggerWebFontsIntervention(m_fontSelector->document(), display)) {
+    if (shouldTriggerWebFontsIntervention(m_fontSelector->document(), display, m_isLoadedFromMemoryCache)) {
 
         m_isInterventionTriggered = true;
         m_period = SwapPeriod;
         m_fontSelector->document()->addConsoleMessage(ConsoleMessage::create(OtherMessageSource, InfoMessageLevel, "Slow network is detected. Fallback font will be used while loading: " + m_font->url().elidedString()));
     }
 }
 
 RemoteFontFaceSource::~RemoteFontFaceSource()
 {
 }
@@ skipping 29 matching lines @@
 }
 
 bool RemoteFontFaceSource::isValid() const
 {
     return !m_font->errorOccurred();
 }
 
 void RemoteFontFaceSource::notifyFinished(Resource*)
 {
     m_histograms.recordRemoteFont(m_font.get());
-    m_histograms.fontLoaded(m_isInterventionTriggered);
+    m_histograms.fontLoaded(m_isInterventionTriggered, m_isLoadedFromMemoryCache || m_font->response().wasCached());

[Takashi Toyoshima, 2016/06/27 08:55:10]

wasCached() returns disk cache result.

So, if the first fetch comes from network, m_isLoadedFromMemoryCache and
wasCached() are false. Then the next fetch will be m_isLoadedFromMemoryCache is
true and wasCached() was false because the same response() is cached in the
memory cache.

If the first fetch comes from disk cache, wasCached() is true for both first and
the second fetches.

 
     m_font->ensureCustomFontData();
     // FIXME: Provide more useful message such as OTS rejection reason.
     // See crbug.com/97467
     if (m_font->getStatus() == Resource::DecodeError && m_fontSelector->document()) {
         m_fontSelector->document()->addConsoleMessage(ConsoleMessage::create(OtherMessageSource, WarningMessageLevel, "Failed to decode downloaded font: " + m_font->url().elidedString()));
         if (m_font->otsParsingMessage().length() > 1)
             m_fontSelector->document()->addConsoleMessage(ConsoleMessage::create(OtherMessageSource, WarningMessageLevel, "OTS parsing error: " + m_font->otsParsingMessage()));
     }
 
@@ skipping 100 matching lines @@
     if (!m_loadStartTime)
         m_loadStartTime = currentTimeMS();
 }
 
 void RemoteFontFaceSource::FontLoadHistograms::fallbackFontPainted(DisplayPeriod period)
 {
     if (period == BlockPeriod && !m_blankPaintTime)
         m_blankPaintTime = currentTimeMS();
 }
 
-void RemoteFontFaceSource::FontLoadHistograms::fontLoaded(bool isInterventionTriggered)
+void RemoteFontFaceSource::FontLoadHistograms::fontLoaded(bool isInterventionTriggered, bool isLoadedFromCache)
 {
     if (!m_isLongLimitExceeded)
-        recordInterventionResult(isInterventionTriggered);
+        recordInterventionResult(isInterventionTriggered, isLoadedFromCache);
 }
 
 void RemoteFontFaceSource::FontLoadHistograms::longLimitExceeded(bool isInterventionTriggered)
 {
     m_isLongLimitExceeded = true;
-    recordInterventionResult(isInterventionTriggered);
+    recordInterventionResult(isInterventionTriggered, false);
 }
 
 void RemoteFontFaceSource::FontLoadHistograms::recordFallbackTime(const FontResource* font)
 {
     if (m_blankPaintTime <= 0)
         return;
     int duration = static_cast<int>(currentTimeMS() - m_blankPaintTime);
     DEFINE_STATIC_LOCAL(CustomCountHistogram, blankTextShownTimeHistogram, ("WebFont.BlankTextShownTime", 0, 10000, 50));
     blankTextShownTimeHistogram.count(duration);
     m_blankPaintTime = -1;
@@ skipping 46 matching lines @@
     }
     if (size < 1024 * 1024) {
         DEFINE_STATIC_LOCAL(CustomCountHistogram, under1mbHistogram, ("WebFont.DownloadTime.3.100KBTo1MB", 0, 10000, 50));
         under1mbHistogram.count(duration);
         return;
     }
     DEFINE_STATIC_LOCAL(CustomCountHistogram, over1mbHistogram, ("WebFont.DownloadTime.4.Over1MB", 0, 10000, 50));
     over1mbHistogram.count(duration);
 }
 
-void RemoteFontFaceSource::FontLoadHistograms::recordInterventionResult(bool triggered)
+void RemoteFontFaceSource::FontLoadHistograms::recordInterventionResult(bool triggered, bool loadedFromCache)
 {
     // interventionResult takes 0-3 values.
     int interventionResult = 0;
     if (m_isLongLimitExceeded)
         interventionResult |= 1 << 0;
     if (triggered)
         interventionResult |= 1 << 1;
     const int boundary = 1 << 2;
 
     DEFINE_STATIC_LOCAL(EnumerationHistogram, interventionHistogram, ("WebFont.InterventionResult", boundary));
+    DEFINE_STATIC_LOCAL(EnumerationHistogram, missCachedInterventionHistogram, ("WebFont.MissCachedInterventionResult", boundary));
     interventionHistogram.count(interventionResult);
+    if (!loadedFromCache)

[tbansal1, 2016/06/27 15:54:13]

Will the accuracy histogram be logged if the font was base-64 encoded within the
file (like a data URL)? 

[Takashi Toyoshima, 2016/06/28 05:42:52]

That's good point.
Let me check if we do not trigger the intervention for data URL after submitting
this CL.

I expect font->isLoaded() returns true at the constructor.
Once I check the behavior, I will report the result at the crbug.

+        missCachedInterventionHistogram.count(interventionResult);
 }
 
 } // namespace blink