Clean up font 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/FontLoader.h"
+#include "core/css/CSSFontSelector.h"
+#include "core/dom/Document.h"
+#include "core/inspector/ConsoleMessage.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 "wtf/CurrentTime.h"
 
 namespace blink {
 
-RemoteFontFaceSource::RemoteFontFaceSource(FontResource* font, FontLoader* fontLoader, FontDisplay display)
+RemoteFontFaceSource::RemoteFontFaceSource(FontResource* font, CSSFontSelector* fontSelector, FontDisplay display)
     : m_font(font)
-    , m_fontLoader(fontLoader)
+    , m_fontSelector(fontSelector)
     , m_display(display)
     , m_period(display == FontDisplaySwap ? SwapPeriod : BlockPeriod)
     , m_isInterventionTriggered(false)
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
     m_font->addClient(this);
 
     if (RuntimeEnabledFeatures::webFontsInterventionEnabled()) {
@@ skipping 42 matching lines @@
 bool RemoteFontFaceSource::isLoaded() const
 {
     return m_font->isLoaded();
 }
 
 bool RemoteFontFaceSource::isValid() const
 {
     return !m_font->errorOccurred();
 }
 
-void RemoteFontFaceSource::didStartFontLoad(FontResource*)
-{
-    // We may send duplicated reports when multiple CSSFontFaceSource are
-    // registered at this FontResource. Associating the same URL to different
-    // font-family causes the case, but we treat them as indivisual resources.
-    m_histograms.loadStarted();
-}
-
 void RemoteFontFaceSource::fontLoaded(FontResource*)
 {
     m_histograms.recordRemoteFont(m_font.get());
     m_histograms.fontLoaded(m_isInterventionTriggered);
 
     m_font->ensureCustomFontData();
-    if (m_font->getStatus() == Resource::DecodeError)
-        m_fontLoader->didFailToDecode(m_font.get());
+    // 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()));
+    }
 
     pruneTable();
     if (m_face) {
-        m_fontLoader->fontFaceInvalidated();
+        m_fontSelector->fontFaceInvalidated();
         m_face->fontLoaded(this);
     }
     // Should not do anything after this line since the m_face->fontLoaded()
     // above may trigger deleting this object.
 }
 
 void RemoteFontFaceSource::fontLoadShortLimitExceeded(FontResource*)
 {
     if (m_display == FontDisplayFallback)
         switchToSwapPeriod();
@@ skipping 11 matching lines @@
     m_histograms.longLimitExceeded(m_isInterventionTriggered);
 }
 
 void RemoteFontFaceSource::switchToSwapPeriod()
 {
     ASSERT(m_period == BlockPeriod);
     m_period = SwapPeriod;
 
     pruneTable();
     if (m_face) {
-        m_fontLoader->fontFaceInvalidated();
+        m_fontSelector->fontFaceInvalidated();
         m_face->didBecomeVisibleFallback(this);
     }
 
     m_histograms.recordFallbackTime(m_font.get());
 }
 
 void RemoteFontFaceSource::switchToFailurePeriod()
 {
     if (m_period == BlockPeriod)
         switchToSwapPeriod();
@@ skipping 25 matching lines @@
     if (!temporaryFont) {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     RefPtr<CSSCustomFontData> cssFontData = CSSCustomFontData::create(this, m_period == BlockPeriod ? CSSCustomFontData::InvisibleFallback : CSSCustomFontData::VisibleFallback);
     return SimpleFontData::create(temporaryFont->platformData(), cssFontData);
 }
 
 void RemoteFontFaceSource::beginLoadIfNeeded()
 {
-    if (m_font->stillNeedsLoad())
-        m_fontLoader->addFontToBeginLoading(m_font.get());
+    if (m_fontSelector->document() && m_font->stillNeedsLoad()) {
+        m_font->load(m_fontSelector->document()->fetcher());
+        m_histograms.loadStarted();
+    }
+    m_font->startLoadLimitTimersIfNeeded();

[Nate Chapin, 2016/04/07 23:46:16]

https://tabatkins.github.io/specs/css-font-display/#timeline says: "At the
moment the user agent first attempts to use a given downloaded font face on a
page, the font face’s font download timer is started."

Before this change, we always start the download timer when the we begin the
resource load, *even if it's a preload*. I chatted with tabatkins, and we agree
that's wrong, so with this change we start the timers when the load would have
begun if we hadn't preloaded it.

This has the benefit of removing the last override Resource::load :)

[Kunihiko Sakamoto, 2016/04/08 02:37:16]

Agreed, thanks for doing this!

 
     if (m_face)
         m_face->didBeginLoad();
 }
 
 DEFINE_TRACE(RemoteFontFaceSource)
 {
     visitor->trace(m_font);
-    visitor->trace(m_fontLoader);
+    visitor->trace(m_fontSelector);
     CSSFontFaceSource::trace(visitor);
 }
 
 void RemoteFontFaceSource::FontLoadHistograms::loadStarted()
 {
     if (!m_loadStartTime)
         m_loadStartTime = currentTimeMS();
 }
 
 void RemoteFontFaceSource::FontLoadHistograms::fallbackFontPainted(DisplayPeriod period)
@@ skipping 88 matching lines @@
         interventionResult |= 1 << 0;
     if (triggered)
         interventionResult |= 1 << 1;
     const int boundary = 1 << 2;
 
     DEFINE_STATIC_LOCAL(EnumerationHistogram, interventionHistogram, ("WebFont.InterventionResult", boundary));
     interventionHistogram.count(interventionResult);
 }
 
 } // namespace blink