WebFonts cache-aware timeout adaptation

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/fetch/ResourceLoader.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"
@@ skipping 27 matching lines @@
 }
 
 }  // 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_period(BlockPeriod),
       m_histograms(font->url().protocolIsData()
                        ? FontLoadHistograms::FromDataURL
                        : font->isLoaded() ? FontLoadHistograms::FromMemoryCache
                                           : FontLoadHistograms::FromUnknown,
                    m_display),
       m_isInterventionTriggered(false) {
   ThreadState::current()->registerPreFinalizer(this);
   m_font->addClient(this);
 
   if (shouldTriggerWebFontsIntervention()) {
@@ skipping 84 matching lines @@
 
   if (m_display == FontDisplayBlock ||
       (!m_isInterventionTriggered && m_display == FontDisplayAuto))
     switchToSwapPeriod();
   else if (m_display == FontDisplayFallback)
     switchToFailurePeriod();
 
   m_histograms.longLimitExceeded(m_isInterventionTriggered);
 }
 
+void RemoteFontFaceSource::willReloadAfterDiskCacheMiss(const FontResource*) {
+  DCHECK(m_font->isLoading());
+  DCHECK(m_font->loader()->isCacheAwareLoadingActivated());
+  if (m_display == FontDisplaySwap)
+    switchToSwapPeriod();
+}
+
 void RemoteFontFaceSource::switchToSwapPeriod() {
-  ASSERT(m_period == BlockPeriod);
+  DCHECK_EQ(m_period, BlockPeriod);
   m_period = SwapPeriod;
 
   pruneTable();
   if (m_face) {
     m_fontSelector->fontFaceInvalidated();
     m_face->didBecomeVisibleFallback(this);
   }
 
   m_histograms.recordFallbackTime(m_font.get());
 }
 
 void RemoteFontFaceSource::switchToFailurePeriod() {
   if (m_period == BlockPeriod)
     switchToSwapPeriod();
-  ASSERT(m_period == SwapPeriod);
+  DCHECK_EQ(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;
 
@@ skipping 45 matching lines @@
 }
 
 void RemoteFontFaceSource::beginLoadIfNeeded() {
   if (m_fontSelector->document() && m_font->stillNeedsLoad()) {
     m_fontSelector->document()->fetcher()->startLoad(m_font);
     if (!m_font->isLoaded())
       m_font->startLoadLimitTimers();
     m_histograms.loadStarted();
   }
 
+  if (m_display == FontDisplaySwap && m_font->isLoading() &&
+      !m_font->loader()->isCacheAwareLoadingActivated()) {
+    // |m_period| might be modified if font load timeout callbacks are called
+    // during |m_font->addClient()| in constructor. Currently this should not
+    // happen with |m_display == FontDisplaySwap|.

[Shao-Chuan Lee, 2016/11/01 08:57:07]

ksakamoto@: I guess the if statement explains itself and this comment should be
sufficient?

+    DCHECK_EQ(m_period, BlockPeriod);
+    m_period = SwapPeriod;
+  }
+
   if (m_face)
     m_face->didBeginLoad();
 }
 
 DEFINE_TRACE(RemoteFontFaceSource) {
   visitor->trace(m_font);
   visitor->trace(m_fontSelector);
   CSSFontFaceSource::trace(visitor);
   FontResourceClient::trace(visitor);
 }
@@ skipping 196 matching lines @@
       return Miss;
     case FromUnknown:
     // Fall through.
     default:
       NOTREACHED();
   }
   return Miss;
 }
 
 }  // namespace blink