Diff
Modified: trunk/LayoutTests/ChangeLog (201675 => 201676)
--- trunk/LayoutTests/ChangeLog 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/LayoutTests/ChangeLog 2016-06-04 02:00:50 UTC (rev 201676)
@@ -1,3 +1,16 @@
+2016-06-03 Myles C. Maxfield <[email protected]>
+
+ Text not visible while external font downloading
+ https://bugs.webkit.org/show_bug.cgi?id=25207
+ <rdar://problem/15167413>
+
+ Reviewed by Dean Jackson.
+
+ * fast/text/web-font-load-fallback-during-loading-no-multiple-expected.txt: Added.
+ * fast/text/web-font-load-fallback-during-loading-no-multiple.html: Added.
+ * fast/text/web-font-load-fallback-during-loading-expected.html: Added.
+ * fast/text/web-font-load-fallback-during-loading.html: Added.
+
2016-06-03 Benjamin Poulain <[email protected]>
JSON.stringify replacer function calls with numeric array indices
Added: trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-expected.html (0 => 201676)
--- trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-expected.html (rev 0)
+++ trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-expected.html 2016-06-04 02:00:50 UTC (rev 201676)
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+</head>
+<body>
+This test makes sure that fallback fonts are used during the time when fonts are loading. The test passes if the next line below reads "Test complete" and all the subsequent statements below are legible and true.
+<p id="console">Test complete</p>
+<p><span class="test" style="font-family: Helvetica">This is rendered with Helvetica.</span></p>
+<p><span class="test" style="font-family: Helvetica">This is rendered with Helvetica.</span></p>
+<p><span class="test" style="font-family: Helvetica">This is rendered with Helvetica.</span></p>
+</body>
+</html>
\ No newline at end of file
Added: trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple-expected.txt (0 => 201676)
--- trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple-expected.txt (rev 0)
+++ trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple-expected.txt 2016-06-04 02:00:50 UTC (rev 201676)
@@ -0,0 +1,6 @@
+web-font-load-fallback-during-loading-no-multiple.html - didFinishLoading
+Ahem.ttf - willSendRequest <NSURLRequest URL Ahem.ttf, main document URL web-font-load-fallback-during-loading-no-multiple.html, http method GET> redirectResponse (null)
+Ahem.ttf - didReceiveResponse <NSURLResponse Ahem.ttf, http status code 0>
+Ahem.ttf - didFinishLoading
+This test makes sure that multiple remote fonts aren't requested concurrently due to timeouts. The test passes if only one remote font is requested.
+Hello World
Added: trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple.html (0 => 201676)
--- trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple.html (rev 0)
+++ trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading-no-multiple.html 2016-06-04 02:00:50 UTC (rev 201676)
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script>
+if (window.testRunner) {
+ testRunner.dumpResourceLoadCallbacks();
+ testRunner.dumpAsText();
+}
+if (window.internals) {
+ internals.clearMemoryCache();
+ internals.invalidateFontCache();
+}
+</script>
+<style>
+@font-face {
+ font-family: WebFont;
+ src: url("../../resources/Ahem.ttf") format("truetype"), url("../../resources/Ahem.otf") format("opentype"), local("Helvetica");
+}
+</style>
+</head>
+<body>
+This test makes sure that multiple remote fonts aren't requested concurrently due to timeouts. The test passes if only one remote font is requested.
+<div id="probe" style="font-family: WebFont;">Hello World</div>
+<script>
+var probe = document.getElementById("probe");
+probe.offsetTop;
+probe.style.fontSize = "20px;";
+probe.offsetTop;
+</script>
+</body>
+</html>
\ No newline at end of file
Added: trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading.html (0 => 201676)
--- trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading.html (rev 0)
+++ trunk/LayoutTests/fast/text/web-font-load-fallback-during-loading.html 2016-06-04 02:00:50 UTC (rev 201676)
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script>
+if (window.internals) {
+ internals.settings.setWebFontsAlwaysFallBack(true);
+ internals.clearMemoryCache();
+ internals.invalidateFontCache();
+}
+if (window.testRunner)
+ testRunner.waitUntilDone();
+
+function computeCurrentWidths() {
+ var result = [];
+ var collection = document.getElementsByClassName("test");
+ for (var i = 0; i < collection.length; ++i)
+ result.push(collection.item(i).getBoundingClientRect().width);
+ return result;
+}
+
+function testCompleted(widths, goal) {
+ for (var i = 0; i < widths.length; ++i) {
+ if (widths[i] != goal)
+ return false;
+ }
+ return true;
+}
+
+var token = window.setInterval(function () {
+ if (testCompleted(computeCurrentWidths(), expectedWidth)) {
+ window.clearInterval(token);
+ document.getElementById("console").appendChild(document.createTextNode("Test complete"));
+ if (window.testRunner)
+ testRunner.notifyDone();
+ }
+}, 0);
+
+</script>
+<style>
+@font-face {
+ font-family: WebFont;
+ src: url("../../resources/Ahem.ttf") format("truetype"), local("Helvetica");
+}
+@font-face {
+ font-family: WebFont2;
+ src: local("Helvetica");
+}
+@font-face {
+ font-family: WebFont2;
+ src: url("../../resources/Ahem.ttf") format("truetype");
+}
+</style>
+</head>
+<body>
+This test makes sure that fallback fonts are used during the time when fonts are loading. The test passes if the next line below reads "Test complete" and all the subsequent statements below are legible and true.
+<p id="console"></p>
+<p><span id="reference" style="font-family: Helvetica">This is rendered with Helvetica.</span></p>
+<p><span class="test" style="font-family: WebFont">This is rendered with Helvetica.</span></p>
+<p><span class="test" style="font-family: WebFont2">This is rendered with Helvetica.</span></p>
+<script>
+var expectedWidth = document.getElementById("reference").getBoundingClientRect().width;
+</script>
+</body>
+</html>
\ No newline at end of file
Modified: trunk/Source/WebCore/ChangeLog (201675 => 201676)
--- trunk/Source/WebCore/ChangeLog 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/ChangeLog 2016-06-04 02:00:50 UTC (rev 201676)
@@ -1,3 +1,47 @@
+2016-06-03 Myles C. Maxfield <[email protected]>
+
+ Text not visible while external font downloading
+ https://bugs.webkit.org/show_bug.cgi?id=25207
+ <rdar://problem/15167413>
+
+ Reviewed by Dean Jackson.
+
+ I already laid the groundwork for this when implementing the CSS Font Loading API.
+ We only have to create a timer and correctly respond to it timing out (by setting
+ state).
+
+ This patch also adds a new internal setting which puts us in a mode where font
+ loads never complete and the timeout occurs immediately. This is so we can test
+ the fallback behavior.
+
+ Test: fast/text/web-font-load-fallback-during-loading.html
+
+ * css/CSSFontFace.cpp:
+ (WebCore::CSSFontFace::CSSFontFace):
+ (WebCore::CSSFontFace::fontLoadEventOccurred):
+ (WebCore::CSSFontFace::timeoutFired):
+ (WebCore::CSSFontFace::setStatus):
+ (WebCore::CSSFontFace::fontLoaded):
+ (WebCore::CSSFontFace::webFontsShouldAlwaysFallBack):
+ (WebCore::CSSFontFace::pump):
+ (WebCore::CSSFontFace::font):
+ * css/CSSFontFace.h:
+ * css/CSSFontFaceSource.cpp:
+ (WebCore::CSSFontFaceSource::fontLoaded):
+ * css/FontFace.cpp:
+ (WebCore::FontFace::fontStateChanged):
+ * page/Settings.cpp:
+ (WebCore::Settings::Settings):
+ (WebCore::Settings::setWebFontsAlwaysFallBack):
+ * page/Settings.h:
+ (WebCore::Settings::webFontsAlwaysFallBack):
+ * testing/InternalSettings.cpp:
+ (WebCore::InternalSettings::Backup::Backup):
+ (WebCore::InternalSettings::Backup::restoreTo):
+ (WebCore::InternalSettings::setWebFontsAlwaysFallBack):
+ * testing/InternalSettings.h:
+ * testing/InternalSettings.idl:
+
2016-06-03 Chris Dumez <[email protected]>
Modernize a few more lambda captures
Modified: trunk/Source/WebCore/css/CSSFontFace.cpp (201675 => 201676)
--- trunk/Source/WebCore/css/CSSFontFace.cpp 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/css/CSSFontFace.cpp 2016-06-04 02:00:50 UTC (rev 201676)
@@ -89,7 +89,8 @@
}
CSSFontFace::CSSFontFace(CSSFontSelector* fontSelector, StyleRuleFontFace* cssConnection, FontFace* wrapper, bool isLocalFallback)
- : m_fontSelector(fontSelector)
+ : m_timeoutTimer(*this, &CSSFontFace::timeoutFired)
+ , m_fontSelector(fontSelector)
, m_cssConnection(cssConnection)
, m_wrapper(wrapper ? wrapper->createWeakPtr() : WeakPtr<FontFace>())
, m_isLocalFallback(isLocalFallback)
@@ -335,6 +336,31 @@
});
}
+void CSSFontFace::fontLoadEventOccurred()
+{
+ Ref<CSSFontFace> protectedThis(*this);
+
+ // If the font is already in the cache, CSSFontFaceSource may report it's loaded before it is added here as a source.
+ // Let's not pump the state machine until we've got all our sources. font() and load() are smart enough to act correctly
+ // when a source is failed or succeeded before we have asked it to load.
+ if (m_sourcesPopulated)
+ pump();
+
+ ASSERT(m_fontSelector);
+ m_fontSelector->fontLoaded();
+
+ iterateClients(m_clients, [&](Client& client) {
+ client.fontLoaded(*this);
+ });
+}
+
+void CSSFontFace::timeoutFired()
+{
+ setStatus(Status::TimedOut);
+
+ fontLoadEventOccurred();
+}
+
bool CSSFontFace::allSourcesFailed() const
{
for (auto& source : m_sources) {
@@ -412,6 +438,11 @@
break;
}
+ if (newStatus == Status::Loading)
+ m_timeoutTimer.startOneShot(webFontsShouldAlwaysFallBack() ? 0 : 3);
+ else if (newStatus == Status::Success || newStatus == Status::Failure)
+ m_timeoutTimer.stop();
+
iterateClients(m_clients, [&](Client& client) {
client.fontStateChanged(*this, m_status, newStatus);
});
@@ -421,20 +452,14 @@
void CSSFontFace::fontLoaded(CSSFontFaceSource&)
{
- Ref<CSSFontFace> protectedThis(*this);
+ ASSERT(!webFontsShouldAlwaysFallBack());
- // If the font is already in the cache, CSSFontFaceSource may report it's loaded before it is added here as a source.
- // Let's not pump the state machine until we've got all our sources. font() and load() are smart enough to act correctly
- // when a source is failed or succeeded before we have asked it to load.
- if (m_sourcesPopulated)
- pump();
+ fontLoadEventOccurred();
+}
- ASSERT(m_fontSelector);
- m_fontSelector->fontLoaded();
-
- iterateClients(m_clients, [&](Client& client) {
- client.fontLoaded(*this);
- });
+bool CSSFontFace::webFontsShouldAlwaysFallBack() const
+{
+ return m_fontSelector && m_fontSelector->document() && m_fontSelector->document()->settings() && m_fontSelector->document()->settings()->webFontsAlwaysFallBack();
}
size_t CSSFontFace::pump()
@@ -456,7 +481,7 @@
ASSERT_NOT_REACHED();
break;
case CSSFontFaceSource::Status::Loading:
- ASSERT(m_status == Status::Pending || m_status == Status::Loading);
+ ASSERT(m_status == Status::Pending || m_status == Status::Loading || m_status == Status::TimedOut);
if (m_status == Status::Pending)
setStatus(Status::Loading);
return i;
@@ -495,10 +520,13 @@
// of the sources to try to find a font to use. These subsequent tries should not affect
// our own state, though.
size_t startIndex = pump();
+ bool fontIsLoading = false;
for (size_t i = startIndex; i < m_sources.size(); ++i) {
auto& source = m_sources[i];
if (source->status() == CSSFontFaceSource::Status::Pending) {
ASSERT(m_fontSelector);
+ if (fontIsLoading)
+ continue;
source->load(*m_fontSelector);
}
@@ -507,6 +535,10 @@
ASSERT_NOT_REACHED();
break;
case CSSFontFaceSource::Status::Loading:
+ ASSERT(!fontIsLoading);
+ fontIsLoading = true;
+ if (status() == Status::TimedOut)
+ continue;
return Font::create(FontCache::singleton().lastResortFallbackFont(fontDescription)->platformData(), true, true);
case CSSFontFaceSource::Status::Success:
if (RefPtr<Font> result = source->font(fontDescription, syntheticBold, syntheticItalic, m_featureSettings, m_variantSettings))
Modified: trunk/Source/WebCore/css/CSSFontFace.h (201675 => 201676)
--- trunk/Source/WebCore/css/CSSFontFace.h 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/css/CSSFontFace.h 2016-06-04 02:00:50 UTC (rev 201676)
@@ -28,6 +28,7 @@
#include "CSSFontFaceRule.h"
#include "FontFeatureSettings.h"
#include "TextFlags.h"
+#include "Timer.h"
#include <memory>
#include <wtf/Forward.h>
#include <wtf/HashSet.h>
@@ -135,6 +136,8 @@
// We don't guarantee that the FontFace wrapper will be the same every time you ask for it.
Ref<FontFace> wrapper();
+ bool webFontsShouldAlwaysFallBack() const;
+
#if ENABLE(SVG_FONTS)
bool hasSVGFontFaceSource() const;
#endif
@@ -146,11 +149,15 @@
void setStatus(Status);
void notifyClientsOfFontPropertyChange();
+ void fontLoadEventOccurred();
+ void timeoutFired();
+
RefPtr<CSSValueList> m_families;
FontTraitsMask m_traitsMask { static_cast<FontTraitsMask>(FontStyleNormalMask | FontWeight400Mask) };
Vector<UnicodeRange> m_ranges;
FontFeatureSettings m_featureSettings;
FontVariantSettings m_variantSettings;
+ Timer m_timeoutTimer;
Vector<std::unique_ptr<CSSFontFaceSource>> m_sources;
RefPtr<CSSFontSelector> m_fontSelector;
RefPtr<StyleRuleFontFace> m_cssConnection;
Modified: trunk/Source/WebCore/css/CSSFontFaceSource.cpp (201675 => 201676)
--- trunk/Source/WebCore/css/CSSFontFaceSource.cpp 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/css/CSSFontFaceSource.cpp 2016-06-04 02:00:50 UTC (rev 201676)
@@ -65,6 +65,7 @@
ASSERT(status() == Status::Loading);
break;
}
+
m_status = newStatus;
}
@@ -113,10 +114,14 @@
return;
}
+ if (m_face.webFontsShouldAlwaysFallBack())
+ return;
+
if (m_font->errorOccurred())
setStatus(Status::Failure);
else
setStatus(Status::Success);
+
m_face.fontLoaded(*this);
}
Modified: trunk/Source/WebCore/css/FontFace.cpp (201675 => 201676)
--- trunk/Source/WebCore/css/FontFace.cpp 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/css/FontFace.cpp 2016-06-04 02:00:50 UTC (rev 201676)
@@ -367,12 +367,13 @@
// We still need to resolve promises when loading completes, even if all references to use have fallen out of scope.
ref();
break;
+ case CSSFontFace::Status::TimedOut:
+ break;
case CSSFontFace::Status::Success:
if (m_promise)
std::exchange(m_promise, Nullopt)->resolve(*this);
deref();
return;
- case CSSFontFace::Status::TimedOut:
case CSSFontFace::Status::Failure:
if (m_promise)
std::exchange(m_promise, Nullopt)->reject(NETWORK_ERR);
Modified: trunk/Source/WebCore/page/Settings.cpp (201675 => 201676)
--- trunk/Source/WebCore/page/Settings.cpp 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/page/Settings.cpp 2016-06-04 02:00:50 UTC (rev 201676)
@@ -209,6 +209,7 @@
, m_hiddenPageDOMTimerThrottlingEnabled(false)
, m_hiddenPageCSSAnimationSuspensionEnabled(false)
, m_fontFallbackPrefersPictographs(false)
+ , m_webFontsAlwaysFallBack(false)
, m_forcePendingWebGLPolicy(false)
{
// A Frame may not have been created yet, so we initialize the AtomicString
@@ -696,6 +697,14 @@
m_page->setNeedsRecalcStyleInAllFrames();
}
+void Settings::setWebFontsAlwaysFallBack(bool enable)
+{
+ if (m_webFontsAlwaysFallBack == enable)
+ return;
+
+ m_webFontsAlwaysFallBack = enable;
+}
+
void Settings::setLowPowerVideoAudioBufferSizeEnabled(bool flag)
{
gLowPowerVideoAudioBufferSizeEnabled = flag;
Modified: trunk/Source/WebCore/page/Settings.h (201675 => 201676)
--- trunk/Source/WebCore/page/Settings.h 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/page/Settings.h 2016-06-04 02:00:50 UTC (rev 201676)
@@ -242,6 +242,9 @@
WEBCORE_EXPORT void setFontFallbackPrefersPictographs(bool);
bool fontFallbackPrefersPictographs() const { return m_fontFallbackPrefersPictographs; }
+ WEBCORE_EXPORT void setWebFontsAlwaysFallBack(bool);
+ bool webFontsAlwaysFallBack() const { return m_webFontsAlwaysFallBack; }
+
static bool lowPowerVideoAudioBufferSizeEnabled() { return gLowPowerVideoAudioBufferSizeEnabled; }
WEBCORE_EXPORT static void setLowPowerVideoAudioBufferSizeEnabled(bool);
@@ -339,6 +342,7 @@
bool m_hiddenPageDOMTimerThrottlingEnabled : 1;
bool m_hiddenPageCSSAnimationSuspensionEnabled : 1;
bool m_fontFallbackPrefersPictographs : 1;
+ bool m_webFontsAlwaysFallBack : 1;
bool m_forcePendingWebGLPolicy : 1;
Modified: trunk/Source/WebCore/testing/InternalSettings.cpp (201675 => 201676)
--- trunk/Source/WebCore/testing/InternalSettings.cpp 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/testing/InternalSettings.cpp 2016-06-04 02:00:50 UTC (rev 201676)
@@ -93,6 +93,7 @@
, m_pluginReplacementEnabled(RuntimeEnabledFeatures::sharedFeatures().pluginReplacementEnabled())
, m_shouldConvertPositionStyleOnCopy(settings.shouldConvertPositionStyleOnCopy())
, m_fontFallbackPrefersPictographs(settings.fontFallbackPrefersPictographs())
+ , m_webFontsAlwaysFallBack(settings.webFontsAlwaysFallBack())
, m_backgroundShouldExtendBeyondPage(settings.backgroundShouldExtendBeyondPage())
, m_storageBlockingPolicy(settings.storageBlockingPolicy())
, m_scrollingTreeIncludesFrames(settings.scrollingTreeIncludesFrames())
@@ -169,6 +170,7 @@
settings.setAutoscrollForDragAndDropEnabled(m_autoscrollForDragAndDropEnabled);
settings.setShouldConvertPositionStyleOnCopy(m_shouldConvertPositionStyleOnCopy);
settings.setFontFallbackPrefersPictographs(m_fontFallbackPrefersPictographs);
+ settings.setWebFontsAlwaysFallBack(m_webFontsAlwaysFallBack);
settings.setBackgroundShouldExtendBeyondPage(m_backgroundShouldExtendBeyondPage);
settings.setStorageBlockingPolicy(m_storageBlockingPolicy);
settings.setScrollingTreeIncludesFrames(m_scrollingTreeIncludesFrames);
@@ -515,6 +517,12 @@
settings()->setFontFallbackPrefersPictographs(preferPictographs);
}
+void InternalSettings::setWebFontsAlwaysFallBack(bool enable, ExceptionCode& ec)
+{
+ InternalSettingsGuardForSettings();
+ settings()->setWebFontsAlwaysFallBack(enable);
+}
+
void InternalSettings::setPluginReplacementEnabled(bool enabled)
{
RuntimeEnabledFeatures::sharedFeatures().setPluginReplacementEnabled(enabled);
Modified: trunk/Source/WebCore/testing/InternalSettings.h (201675 => 201676)
--- trunk/Source/WebCore/testing/InternalSettings.h 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/testing/InternalSettings.h 2016-06-04 02:00:50 UTC (rev 201676)
@@ -93,6 +93,7 @@
bool m_pluginReplacementEnabled;
bool m_shouldConvertPositionStyleOnCopy;
bool m_fontFallbackPrefersPictographs;
+ bool m_webFontsAlwaysFallBack;
bool m_backgroundShouldExtendBeyondPage;
SecurityOrigin::StorageBlockingPolicy m_storageBlockingPolicy;
bool m_scrollingTreeIncludesFrames;
@@ -150,6 +151,7 @@
void setUseLegacyBackgroundSizeShorthandBehavior(bool, ExceptionCode&);
void setAutoscrollForDragAndDropEnabled(bool, ExceptionCode&);
void setFontFallbackPrefersPictographs(bool, ExceptionCode&);
+ void setWebFontsAlwaysFallBack(bool, ExceptionCode&);
void setPluginReplacementEnabled(bool);
void setBackgroundShouldExtendBeyondPage(bool, ExceptionCode&);
void setShouldConvertPositionStyleOnCopy(bool, ExceptionCode&);
Modified: trunk/Source/WebCore/testing/InternalSettings.idl (201675 => 201676)
--- trunk/Source/WebCore/testing/InternalSettings.idl 2016-06-04 01:31:47 UTC (rev 201675)
+++ trunk/Source/WebCore/testing/InternalSettings.idl 2016-06-04 02:00:50 UTC (rev 201676)
@@ -40,6 +40,7 @@
[RaisesException] void setFantasyFontFamily(DOMString family, DOMString script);
[RaisesException] void setPictographFontFamily(DOMString family, DOMString script);
[RaisesException] void setFontFallbackPrefersPictographs(boolean preferPictographs);
+ [RaisesException] void setWebFontsAlwaysFallBack(boolean enable);
[RaisesException] void setTextAutosizingEnabled(boolean enabled);
[RaisesException] void setTextAutosizingWindowSizeOverride(long width, long height);
