summaryrefslogtreecommitdiffstats
path: root/layout/style/nsFontFaceLoader.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/style/nsFontFaceLoader.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/style/nsFontFaceLoader.cpp')
-rw-r--r--layout/style/nsFontFaceLoader.cpp306
1 files changed, 306 insertions, 0 deletions
diff --git a/layout/style/nsFontFaceLoader.cpp b/layout/style/nsFontFaceLoader.cpp
new file mode 100644
index 000000000..f5a0a9f34
--- /dev/null
+++ b/layout/style/nsFontFaceLoader.cpp
@@ -0,0 +1,306 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* code for loading in @font-face defined font data */
+
+#include "mozilla/Logging.h"
+
+#include "nsFontFaceLoader.h"
+
+#include "nsError.h"
+#include "nsContentUtils.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Telemetry.h"
+#include "FontFaceSet.h"
+#include "nsPresContext.h"
+#include "nsIPrincipal.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIHttpChannel.h"
+#include "nsIContentPolicy.h"
+#include "nsContentPolicyUtils.h"
+
+#include "mozilla/gfx/2D.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#define LOG(args) MOZ_LOG(gfxUserFontSet::GetUserFontsLog(), mozilla::LogLevel::Debug, args)
+#define LOG_ENABLED() MOZ_LOG_TEST(gfxUserFontSet::GetUserFontsLog(), \
+ LogLevel::Debug)
+
+static uint32_t
+GetFallbackDelay()
+{
+ return Preferences::GetInt("gfx.downloadable_fonts.fallback_delay", 3000);
+}
+
+static uint32_t
+GetShortFallbackDelay()
+{
+ return Preferences::GetInt("gfx.downloadable_fonts.fallback_delay_short", 100);
+}
+
+nsFontFaceLoader::nsFontFaceLoader(gfxUserFontEntry* aUserFontEntry,
+ nsIURI* aFontURI,
+ FontFaceSet* aFontFaceSet,
+ nsIChannel* aChannel)
+ : mUserFontEntry(aUserFontEntry),
+ mFontURI(aFontURI),
+ mFontFaceSet(aFontFaceSet),
+ mChannel(aChannel)
+{
+ mStartTime = TimeStamp::Now();
+}
+
+nsFontFaceLoader::~nsFontFaceLoader()
+{
+ if (mUserFontEntry) {
+ mUserFontEntry->mLoader = nullptr;
+ }
+ if (mLoadTimer) {
+ mLoadTimer->Cancel();
+ mLoadTimer = nullptr;
+ }
+ if (mFontFaceSet) {
+ mFontFaceSet->RemoveLoader(this);
+ }
+}
+
+void
+nsFontFaceLoader::StartedLoading(nsIStreamLoader* aStreamLoader)
+{
+ int32_t loadTimeout;
+ uint8_t fontDisplay = GetFontDisplay();
+ if (fontDisplay == NS_FONT_DISPLAY_AUTO ||
+ fontDisplay == NS_FONT_DISPLAY_BLOCK) {
+ loadTimeout = GetFallbackDelay();
+ } else {
+ loadTimeout = GetShortFallbackDelay();
+ }
+
+ if (loadTimeout > 0) {
+ mLoadTimer = do_CreateInstance("@mozilla.org/timer;1");
+ if (mLoadTimer) {
+ mLoadTimer->InitWithFuncCallback(LoadTimerCallback,
+ static_cast<void*>(this),
+ loadTimeout,
+ nsITimer::TYPE_ONE_SHOT);
+ }
+ } else {
+ mUserFontEntry->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
+ }
+ mStreamLoader = aStreamLoader;
+}
+
+/* static */ void
+nsFontFaceLoader::LoadTimerCallback(nsITimer* aTimer, void* aClosure)
+{
+ nsFontFaceLoader* loader = static_cast<nsFontFaceLoader*>(aClosure);
+
+ if (!loader->mFontFaceSet) {
+ // We've been canceled
+ return;
+ }
+
+ gfxUserFontEntry* ufe = loader->mUserFontEntry.get();
+ uint8_t fontDisplay = loader->GetFontDisplay();
+
+ // Depending upon the value of the font-display descriptor for the font,
+ // their may be one or two timeouts associated with each font. The LOADING_SLOWLY
+ // state indicates that the fallback font is shown. The LOADING_TIMED_OUT
+ // state indicates that the fallback font is shown *and* the downloaded font
+ // resource will not replace the fallback font when the load completes.
+
+ bool updateUserFontSet = true;
+ switch (fontDisplay) {
+ case NS_FONT_DISPLAY_AUTO:
+ case NS_FONT_DISPLAY_BLOCK:
+ // If the entry is loading, check whether it's >75% done; if so,
+ // we allow another timeout period before showing a fallback font.
+ if (ufe->mFontDataLoadingState == gfxUserFontEntry::LOADING_STARTED) {
+ int64_t contentLength;
+ uint32_t numBytesRead;
+ if (NS_SUCCEEDED(loader->mChannel->GetContentLength(&contentLength)) &&
+ contentLength > 0 &&
+ contentLength < UINT32_MAX &&
+ NS_SUCCEEDED(loader->mStreamLoader->GetNumBytesRead(&numBytesRead)) &&
+ numBytesRead > 3 * (uint32_t(contentLength) >> 2))
+ {
+ // More than 3/4 the data has been downloaded, so allow 50% extra
+ // time and hope the remainder will arrive before the additional
+ // time expires.
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_ALMOST_DONE;
+ uint32_t delay;
+ loader->mLoadTimer->GetDelay(&delay);
+ loader->mLoadTimer->InitWithFuncCallback(LoadTimerCallback,
+ static_cast<void*>(loader),
+ delay >> 1,
+ nsITimer::TYPE_ONE_SHOT);
+ updateUserFontSet = false;
+ LOG(("userfonts (%p) 75%% done, resetting timer\n", loader));
+ }
+ }
+ if (updateUserFontSet) {
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
+ }
+ break;
+ case NS_FONT_DISPLAY_SWAP:
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
+ break;
+ case NS_FONT_DISPLAY_FALLBACK: {
+ if (ufe->mFontDataLoadingState == gfxUserFontEntry::LOADING_STARTED) {
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
+ } else {
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_TIMED_OUT;
+ updateUserFontSet = false;
+ }
+ break;
+ }
+ case NS_FONT_DISPLAY_OPTIONAL:
+ ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_TIMED_OUT;
+ break;
+
+ default:
+ NS_NOTREACHED("strange font-display value");
+ break;
+ }
+
+ // If the font is not 75% loaded, or if we've already timed out once
+ // before, we mark this entry as "loading slowly", so the fallback
+ // font will be used in the meantime, and tell the context to refresh.
+ if (updateUserFontSet) {
+ nsTArray<gfxUserFontSet*> fontSets;
+ ufe->GetUserFontSets(fontSets);
+ for (gfxUserFontSet* fontSet : fontSets) {
+ nsPresContext* ctx = FontFaceSet::GetPresContextFor(fontSet);
+ if (ctx) {
+ fontSet->IncrementGeneration();
+ ctx->UserFontSetUpdated(ufe);
+ LOG(("userfonts (%p) timeout reflow for pres context %p display %d\n",
+ loader, ctx, fontDisplay));
+ }
+ }
+ }
+}
+
+NS_IMPL_ISUPPORTS(nsFontFaceLoader, nsIStreamLoaderObserver)
+
+NS_IMETHODIMP
+nsFontFaceLoader::OnStreamComplete(nsIStreamLoader* aLoader,
+ nsISupports* aContext,
+ nsresult aStatus,
+ uint32_t aStringLen,
+ const uint8_t* aString)
+{
+ if (!mFontFaceSet) {
+ // We've been canceled
+ return aStatus;
+ }
+
+ mFontFaceSet->RemoveLoader(this);
+
+ TimeStamp doneTime = TimeStamp::Now();
+ TimeDuration downloadTime = doneTime - mStartTime;
+ uint32_t downloadTimeMS = uint32_t(downloadTime.ToMilliseconds());
+ Telemetry::Accumulate(Telemetry::WEBFONT_DOWNLOAD_TIME, downloadTimeMS);
+
+ if (GetFontDisplay() == NS_FONT_DISPLAY_FALLBACK) {
+ uint32_t loadTimeout = GetFallbackDelay();
+ if (downloadTimeMS > loadTimeout &&
+ (mUserFontEntry->mFontDataLoadingState ==
+ gfxUserFontEntry::LOADING_SLOWLY)) {
+ mUserFontEntry->mFontDataLoadingState =
+ gfxUserFontEntry::LOADING_TIMED_OUT;
+ }
+ }
+
+ if (LOG_ENABLED()) {
+ if (NS_SUCCEEDED(aStatus)) {
+ LOG(("userfonts (%p) download completed - font uri: (%s) time: %d ms\n",
+ this, mFontURI->GetSpecOrDefault().get(), downloadTimeMS));
+ } else {
+ LOG(("userfonts (%p) download failed - font uri: (%s) error: %8.8x\n",
+ this, mFontURI->GetSpecOrDefault().get(), aStatus));
+ }
+ }
+
+ if (NS_SUCCEEDED(aStatus)) {
+ // for HTTP requests, check whether the request _actually_ succeeded;
+ // the "request status" in aStatus does not necessarily indicate this,
+ // because HTTP responses such as 404 (Not Found) will still result in
+ // a success code and potentially an HTML error page from the server
+ // as the resulting data. We don't want to use that as a font.
+ nsCOMPtr<nsIRequest> request;
+ nsCOMPtr<nsIHttpChannel> httpChannel;
+ aLoader->GetRequest(getter_AddRefs(request));
+ httpChannel = do_QueryInterface(request);
+ if (httpChannel) {
+ bool succeeded;
+ nsresult rv = httpChannel->GetRequestSucceeded(&succeeded);
+ if (NS_SUCCEEDED(rv) && !succeeded) {
+ aStatus = NS_ERROR_NOT_AVAILABLE;
+ }
+ }
+ }
+
+ // The userFontEntry is responsible for freeing the downloaded data
+ // (aString) when finished with it; the pointer is no longer valid
+ // after FontDataDownloadComplete returns.
+ // This is called even in the case of a failed download (HTTP 404, etc),
+ // as there may still be data to be freed (e.g. an error page),
+ // and we need to load the next source.
+ bool fontUpdate =
+ mUserFontEntry->FontDataDownloadComplete(aString, aStringLen, aStatus);
+
+ mFontFaceSet->GetUserFontSet()->RecordFontLoadDone(aStringLen, doneTime);
+
+ // when new font loaded, need to reflow
+ if (fontUpdate) {
+ nsTArray<gfxUserFontSet*> fontSets;
+ mUserFontEntry->GetUserFontSets(fontSets);
+ for (gfxUserFontSet* fontSet : fontSets) {
+ nsPresContext* ctx = FontFaceSet::GetPresContextFor(fontSet);
+ if (ctx) {
+ // Update layout for the presence of the new font. Since this is
+ // asynchronous, reflows will coalesce.
+ ctx->UserFontSetUpdated(mUserFontEntry);
+ LOG(("userfonts (%p) reflow for pres context %p\n", this, ctx));
+ }
+ }
+ }
+
+ // done with font set
+ mFontFaceSet = nullptr;
+ if (mLoadTimer) {
+ mLoadTimer->Cancel();
+ mLoadTimer = nullptr;
+ }
+
+ return NS_SUCCESS_ADOPTED_DATA;
+}
+
+void
+nsFontFaceLoader::Cancel()
+{
+ mUserFontEntry->mFontDataLoadingState = gfxUserFontEntry::NOT_LOADING;
+ mUserFontEntry->mLoader = nullptr;
+ mFontFaceSet = nullptr;
+ if (mLoadTimer) {
+ mLoadTimer->Cancel();
+ mLoadTimer = nullptr;
+ }
+ mChannel->Cancel(NS_BINDING_ABORTED);
+}
+
+uint8_t
+nsFontFaceLoader::GetFontDisplay()
+{
+ uint8_t fontDisplay = NS_FONT_DISPLAY_AUTO;
+ if (Preferences::GetBool("layout.css.font-display.enabled")) {
+ fontDisplay = mUserFontEntry->GetFontDisplay();
+ }
+ return fontDisplay;
+}