[WIP] WebFonts cache-aware timeout adaption

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"
@@ skipping 136 matching lines @@
 void RemoteFontFaceSource::fontLoadLongLimitExceeded(FontResource*) {
   if (m_display == FontDisplayBlock ||
       (!m_isInterventionTriggered && m_display == FontDisplayAuto))
     switchToSwapPeriod();
   else if (m_display == FontDisplayFallback)
     switchToFailurePeriod();
 
   m_histograms.longLimitExceeded(m_isInterventionTriggered);
 }
 
-void RemoteFontFaceSource::switchToSwapPeriod() {
-  ASSERT(m_period == BlockPeriod);
-  m_period = SwapPeriod;
+void RemoteFontFaceSource::willReloadAfterDiskCacheMiss(const FontResource*) {
+  if (m_period == SwapPeriod || m_period == FailurePeriod)
+    didBecomeVisibleFallback();

[Kunihiko Sakamoto, 2016/10/11 08:07:38]

We should move to next period here, instead of keeping it and complicating the
condition for visibility of fallback font.

[Shao-Chuan Lee, 2016/10/11 10:58:48]

Done.

+}
 
+void RemoteFontFaceSource::didBecomeVisibleFallback() {
   pruneTable();
   if (m_face) {
     m_fontSelector->fontFaceInvalidated();
     m_face->didBecomeVisibleFallback(this);
   }
+}
 
+void RemoteFontFaceSource::switchToSwapPeriod() {
+  DCHECK(m_period == BlockPeriod);
+  m_period = SwapPeriod;
+  didBecomeVisibleFallback();
   m_histograms.recordFallbackTime(m_font.get());
 }
 
 void RemoteFontFaceSource::switchToFailurePeriod() {
   if (m_period == BlockPeriod)
     switchToSwapPeriod();
-  ASSERT(m_period == SwapPeriod);
+  DCHECK(m_period == SwapPeriod);
   m_period = FailurePeriod;
 }
 
 bool RemoteFontFaceSource::shouldTriggerWebFontsIntervention() {
   if (RuntimeEnabledFeatures::webFontsInterventionTriggerEnabled())
     return true;
   if (m_histograms.dataSource() == FontLoadHistograms::FromMemoryCache ||
       m_histograms.dataSource() == FontLoadHistograms::FromDataURL)
     return false;
 
   bool isV2Enabled =
       RuntimeEnabledFeatures::webFontsInterventionV2With2GEnabled() ||
       RuntimeEnabledFeatures::webFontsInterventionV2With3GEnabled() ||
       RuntimeEnabledFeatures::webFontsInterventionV2WithSlow2GEnabled();
 
   bool networkIsSlow =
       isV2Enabled ? isEffectiveConnectionTypeSlowFor(m_fontSelector->document())
                   : isConnectionTypeSlow();
 
   return networkIsSlow && m_display == FontDisplayAuto;
 }
 
+bool RemoteFontFaceSource::shouldUseInvisibleFallback() const {
+  if (m_period == BlockPeriod)
+    return true;
+  if (m_font->resourceRequest().isCacheAwareLoadingActivated()) {
+    switch (m_display) {
+      case FontDisplaySwap:
+      case FontDisplayFallback:
+      case FontDisplayOptional:
+        return true;
+      case FontDisplayAuto:
+      case FontDisplayBlock:
+        break;
+      case FontDisplayEnumMax:
+        NOTREACHED();
+    }
+  }
+  return false;
+}
+
 PassRefPtr<SimpleFontData> RemoteFontFaceSource::createFontData(
     const FontDescription& fontDescription) {
   if (!isLoaded())
     return createLoadingFallbackFontData(fontDescription);
 
   if (!m_font->ensureCustomFontData() || m_period == FailurePeriod)
     return nullptr;
 
   m_histograms.recordFallbackTime(m_font.get());
 
@@ skipping 10 matching lines @@
   // This temporary font is not retained and should not be returned.
   FontCachePurgePreventer fontCachePurgePreventer;
   SimpleFontData* temporaryFont =
       FontCache::fontCache()->getNonRetainedLastResortFallbackFont(
           fontDescription);
   if (!temporaryFont) {
     ASSERT_NOT_REACHED();
     return nullptr;
   }
   RefPtr<CSSCustomFontData> cssFontData = CSSCustomFontData::create(
-      this, m_period == BlockPeriod ? CSSCustomFontData::InvisibleFallback
-                                    : CSSCustomFontData::VisibleFallback);
+      this, shouldUseInvisibleFallback() ? CSSCustomFontData::InvisibleFallback
+                                         : CSSCustomFontData::VisibleFallback);
   return SimpleFontData::create(temporaryFont->platformData(), cssFontData);
 }
 
 void RemoteFontFaceSource::beginLoadIfNeeded() {
   if (m_fontSelector->document() && m_font->stillNeedsLoad()) {
     m_fontSelector->document()->fetcher()->startLoad(m_font);
     m_histograms.loadStarted();
   }
   m_font->startLoadLimitTimersIfNeeded();
 
@@ skipping 181 matching lines @@
       return Miss;
     case FromUnknown:
     // Fall through.
     default:
       NOTREACHED();
   }
   return Miss;
 }
 
 }  // namespace blink