Implement CSS font-display

third_party/WebKit/Source/core/fetch/FontResource.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile, Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 20 matching lines @@
 #include "core/fetch/ResourceClientWalker.h"
 #include "core/fetch/ResourceFetcher.h"
 #include "platform/SharedBuffer.h"
 #include "platform/fonts/FontCustomPlatformData.h"
 #include "platform/fonts/FontPlatformData.h"
 #include "public/platform/Platform.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
-static const double fontLoadWaitLimitSec = 3.0;
+static const double fontLoadWaitShortLimitSec = 0.1;
+static const double fontLoadWaitLongLimitSec = 3.0;

[kinuko, 2015/11/01 16:32:04]

I assume this corresponds to "'100ms' or less is recommended" and "'3s' is
recommended in most cases" respectively- maybe have a short description from a
spec text and link to the spec in a comment?

[Kunihiko Sakamoto, 2015/11/02 05:30:16]

Done.

 
 enum FontPackageFormat {
     PackageFormatUnknown,
     PackageFormatSFNT,
     PackageFormatWOFF,
     PackageFormatWOFF2,
     PackageFormatSVG,
     PackageFormatEnumMax
 };
 
@@ skipping 18 matching lines @@
 ResourcePtr<FontResource> FontResource::fetch(FetchRequest& request, ResourceFetcher* fetcher)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextFont);
     return toFontResource(fetcher->requestResource(request, FontResourceFactory()));
 }
 
 FontResource::FontResource(const ResourceRequest& resourceRequest)
     : Resource(resourceRequest, Font)
     , m_state(Unloaded)
-    , m_exceedsFontLoadWaitLimit(false)
     , m_corsFailed(false)
-    , m_fontLoadWaitLimitTimer(this, &FontResource::fontLoadWaitLimitCallback)
+    , m_fontLoadShortLimitTimer(this, &FontResource::fontLoadShortLimitCallback)
+    , m_fontLoadLongLimitTimer(this, &FontResource::fontLoadLongLimitCallback)
 {
 }
 
 FontResource::~FontResource()
 {
 }
 
 void FontResource::didScheduleLoad()
 {
     if (m_state == Unloaded)
@@ skipping 21 matching lines @@
     Resource::didAddClient(c);
     if (!isLoading())
         static_cast<FontResourceClient*>(c)->fontLoaded(this);
 }
 
 void FontResource::beginLoadIfNeeded(ResourceFetcher* dl)
 {
     if (m_state != LoadInitiated) {
         m_state = LoadInitiated;
         Resource::load(dl, m_options);
-        m_fontLoadWaitLimitTimer.startOneShot(fontLoadWaitLimitSec, BLINK_FROM_HERE);
+        m_fontLoadShortLimitTimer.startOneShot(fontLoadWaitShortLimitSec, BLINK_FROM_HERE);
+        m_fontLoadLongLimitTimer.startOneShot(fontLoadWaitLongLimitSec, BLINK_FROM_HERE);
 
         ResourceClientWalker<FontResourceClient> walker(m_clients);
         while (FontResourceClient* client = walker.next())
             client->didStartFontLoad(this);
     }
 }
 
 bool FontResource::ensureCustomFontData()
 {
     if (!m_fontData && !errorOccurred() && !isLoading()) {
@@ skipping 14 matching lines @@
 {
     ASSERT(m_fontData);
     return m_fontData->fontPlatformData(size, bold, italic, orientation);
 }
 
 bool FontResource::isSafeToUnlock() const
 {
     return m_data->hasOneRef();
 }
 
-void FontResource::fontLoadWaitLimitCallback(Timer<FontResource>*)
+void FontResource::fontLoadShortLimitCallback(Timer<FontResource>*)
 {
     if (!isLoading())
         return;
-    m_exceedsFontLoadWaitLimit = true;
     ResourceClientWalker<FontResourceClient> walker(m_clients);
     while (FontResourceClient* client = walker.next())
-        client->fontLoadWaitLimitExceeded(this);
+        client->fontLoadShortLimitExceeded(this);
+}
+
+void FontResource::fontLoadLongLimitCallback(Timer<FontResource>*)
+{
+    if (!isLoading())
+        return;
+    ResourceClientWalker<FontResourceClient> walker(m_clients);
+    while (FontResourceClient* client = walker.next())
+        client->fontLoadLongLimitExceeded(this);
 }
 
 void FontResource::allClientsRemoved()
 {
     m_fontData.clear();
     Resource::allClientsRemoved();
 }
 
 void FontResource::checkNotify()
 {
-    m_fontLoadWaitLimitTimer.stop();
+    m_fontLoadShortLimitTimer.stop();
+    m_fontLoadLongLimitTimer.stop();
     ResourceClientWalker<FontResourceClient> w(m_clients);
     while (FontResourceClient* c = w.next())
         c->fontLoaded(this);
 }
 
 }