Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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
/* code for loading in @font-face defined font data */
#include "mozilla/IntegerPrintfMacros.h"
#include "mozilla/Logging.h"
#include "nsFontFaceLoader.h"
#include "nsError.h"
#include "mozilla/AutoRestore.h"
#include "mozilla/Preferences.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/TaskQueue.h"
#include "mozilla/Telemetry.h"
#include "mozilla/Unused.h"
#include "FontFaceSet.h"
#include "nsPresContext.h"
#include "nsIHttpChannel.h"
#include "nsIThreadRetargetableRequest.h"
#include "nsContentPolicyUtils.h"
#include "nsNetCID.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,
uint32_t aSrcIndex,
FontFaceSetImpl* aFontFaceSet,
nsIChannel* aChannel)
: mUserFontEntry(aUserFontEntry),
mFontFaceSet(aFontFaceSet),
mChannel(aChannel),
mStreamLoader(nullptr),
mSrcIndex(aSrcIndex) {
MOZ_ASSERT(mFontFaceSet,
"We should get a valid FontFaceSet from the caller!");
const gfxFontFaceSrc& src = aUserFontEntry->SourceAt(mSrcIndex);
MOZ_ASSERT(src.mSourceType == gfxFontFaceSrc::eSourceType_URL);
mFontURI = src.mURI->get();
mStartTime = TimeStamp::Now();
// We add an explicit load block rather than just rely on the network
// request's block, since we need to do some OMT work after the load
// is finished before we unblock load.
auto* doc = mFontFaceSet->GetDocument();
if (doc) {
doc->BlockOnload();
}
}
nsFontFaceLoader::~nsFontFaceLoader() {
MOZ_DIAGNOSTIC_ASSERT(!mInLoadTimerCallback);
MOZ_DIAGNOSTIC_ASSERT(!mInStreamComplete);
if (mUserFontEntry) {
mUserFontEntry->mLoader = nullptr;
}
if (mLoadTimer) {
mLoadTimer->Cancel();
mLoadTimer = nullptr;
}
if (mFontFaceSet) {
mFontFaceSet->RemoveLoader(this);
auto* doc = mFontFaceSet->GetDocument();
if (doc) {
doc->UnblockOnload(false);
}
}
}
void nsFontFaceLoader::StartedLoading(nsIStreamLoader* aStreamLoader) {
int32_t loadTimeout;
StyleFontDisplay fontDisplay = GetFontDisplay();
if (fontDisplay == StyleFontDisplay::Auto ||
fontDisplay == StyleFontDisplay::Block) {
loadTimeout = GetFallbackDelay();
} else {
loadTimeout = GetShortFallbackDelay();
}
if (loadTimeout > 0) {
NS_NewTimerWithFuncCallback(getter_AddRefs(mLoadTimer), LoadTimerCallback,
static_cast<void*>(this), loadTimeout,
nsITimer::TYPE_ONE_SHOT, "LoadTimerCallback",
GetMainThreadSerialEventTarget());
} else {
mUserFontEntry->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
}
mStreamLoader = aStreamLoader;
}
/* static */
void nsFontFaceLoader::LoadTimerCallback(nsITimer* aTimer, void* aClosure) {
nsFontFaceLoader* loader = static_cast<nsFontFaceLoader*>(aClosure);
MOZ_DIAGNOSTIC_ASSERT(!loader->mInLoadTimerCallback);
MOZ_DIAGNOSTIC_ASSERT(!loader->mInStreamComplete);
AutoRestore<bool> scope{loader->mInLoadTimerCallback};
loader->mInLoadTimerCallback = true;
if (!loader->mFontFaceSet) {
// We've been canceled
return;
}
gfxUserFontEntry* ufe = loader->mUserFontEntry.get();
StyleFontDisplay 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 StyleFontDisplay::Auto:
case StyleFontDisplay::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->InitWithNamedFuncCallback(
LoadTimerCallback, static_cast<void*>(loader), delay >> 1,
nsITimer::TYPE_ONE_SHOT, "nsFontFaceLoader::LoadTimerCallback");
updateUserFontSet = false;
LOG(("userfonts (%p) 75%% done, resetting timer\n", loader));
}
}
if (updateUserFontSet) {
ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
}
break;
case StyleFontDisplay::Swap:
ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
break;
case StyleFontDisplay::Fallback: {
if (ufe->mFontDataLoadingState == gfxUserFontEntry::LOADING_STARTED) {
ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_SLOWLY;
} else {
ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_TIMED_OUT;
updateUserFontSet = false;
}
break;
}
case StyleFontDisplay::Optional:
ufe->mFontDataLoadingState = gfxUserFontEntry::LOADING_TIMED_OUT;
break;
default:
MOZ_ASSERT_UNREACHABLE("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<RefPtr<gfxUserFontSet>> fontSets;
ufe->GetUserFontSets(fontSets);
for (gfxUserFontSet* fontSet : fontSets) {
nsPresContext* ctx = FontFaceSetImpl::GetPresContextFor(fontSet);
if (ctx) {
fontSet->IncrementGeneration();
ctx->UserFontSetUpdated(ufe);
LOG(("userfonts (%p) timeout reflow for pres context %p display %d\n",
loader, ctx, static_cast<int>(fontDisplay)));
}
}
}
}
NS_IMPL_ISUPPORTS(nsFontFaceLoader, nsIStreamLoaderObserver, nsIRequestObserver)
// nsIStreamLoaderObserver
NS_IMETHODIMP
nsFontFaceLoader::OnStreamComplete(nsIStreamLoader* aLoader,
nsISupports* aContext, nsresult aStatus,
uint32_t aStringLen,
const uint8_t* aString) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_DIAGNOSTIC_ASSERT(!mInLoadTimerCallback);
MOZ_DIAGNOSTIC_ASSERT(!mInStreamComplete);
AutoRestore<bool> scope{mInStreamComplete};
mInStreamComplete = true;
DropChannel();
if (mLoadTimer) {
mLoadTimer->Cancel();
mLoadTimer = nullptr;
}
if (!mFontFaceSet) {
// We've been canceled
return aStatus;
}
TimeStamp doneTime = TimeStamp::Now();
TimeDuration downloadTime = doneTime - mStartTime;
uint32_t downloadTimeMS = uint32_t(downloadTime.ToMilliseconds());
Telemetry::Accumulate(Telemetry::WEBFONT_DOWNLOAD_TIME, downloadTimeMS);
if (GetFontDisplay() == StyleFontDisplay::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.8" PRIx32
"\n",
this, mFontURI->GetSpecOrDefault().get(),
static_cast<uint32_t>(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;
}
}
}
mFontFaceSet->RecordFontLoadDone(aStringLen, doneTime);
// 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.
// FontDataDownloadComplete will load the platform font on a worker thread,
// and will call FontLoadComplete when it has finished its work.
mUserFontEntry->FontDataDownloadComplete(mSrcIndex, aString, aStringLen,
aStatus, this);
return NS_SUCCESS_ADOPTED_DATA;
}
nsresult nsFontFaceLoader::FontLoadComplete() {
MOZ_ASSERT(NS_IsMainThread());
if (!mFontFaceSet) {
// We've been canceled
return NS_OK;
}
// when new font loaded, need to reflow
nsTArray<RefPtr<gfxUserFontSet>> fontSets;
mUserFontEntry->GetUserFontSets(fontSets);
for (gfxUserFontSet* fontSet : fontSets) {
nsPresContext* ctx = FontFaceSetImpl::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));
}
}
MOZ_DIAGNOSTIC_ASSERT(mFontFaceSet);
mFontFaceSet->RemoveLoader(this);
auto* doc = mFontFaceSet->GetDocument();
if (doc) {
doc->UnblockOnload(false);
}
mFontFaceSet = nullptr;
return NS_OK;
}
// nsIRequestObserver
NS_IMETHODIMP
nsFontFaceLoader::OnStartRequest(nsIRequest* aRequest) {
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIThreadRetargetableRequest> req = do_QueryInterface(aRequest);
if (req) {
nsCOMPtr<nsIEventTarget> sts =
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
RefPtr<TaskQueue> queue =
TaskQueue::Create(sts.forget(), "nsFontFaceLoader STS Delivery Queue");
Unused << NS_WARN_IF(NS_FAILED(req->RetargetDeliveryTo(queue)));
}
return NS_OK;
}
NS_IMETHODIMP
nsFontFaceLoader::OnStopRequest(nsIRequest* aRequest, nsresult aStatusCode) {
MOZ_ASSERT(NS_IsMainThread());
DropChannel();
return NS_OK;
}
void nsFontFaceLoader::Cancel() {
MOZ_DIAGNOSTIC_ASSERT(!mInLoadTimerCallback);
MOZ_DIAGNOSTIC_ASSERT(!mInStreamComplete);
MOZ_DIAGNOSTIC_ASSERT(mFontFaceSet);
mUserFontEntry->LoadCanceled();
mUserFontEntry = nullptr;
auto* doc = mFontFaceSet->GetDocument();
if (doc) {
doc->UnblockOnload(false);
}
mFontFaceSet = nullptr;
if (mLoadTimer) {
mLoadTimer->Cancel();
mLoadTimer = nullptr;
}
if (nsCOMPtr<nsIChannel> channel = std::move(mChannel)) {
channel->CancelWithReason(NS_BINDING_ABORTED,
"nsFontFaceLoader::OnStopRequest"_ns);
}
}
StyleFontDisplay nsFontFaceLoader::GetFontDisplay() {
return mUserFontEntry->GetFontDisplay();
}
#undef LOG
#undef LOG_ENABLED