Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 388 insertions, 0 deletions

diff --git a/layout/style/nsFontFaceLoader.cpp b/layout/style/nsFontFaceLoader.cpp
new file mode 100644
index 0000000000..35daf2eb4e
--- /dev/null
+++ b/layout/style/nsFontFaceLoader.cpp
@@ -0,0 +1,388 @@
+/* -*- 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
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* 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) {
+    nsIEventTarget* target;
+    auto* doc = mFontFaceSet->GetDocument();
+    if (doc) {
+      target = doc->EventTargetFor(TaskCategory::Other);
+    } else {
+      target = GetMainThreadSerialEventTarget();
+    }
+    NS_NewTimerWithFuncCallback(
+        getter_AddRefs(mLoadTimer), LoadTimerCallback, static_cast<void*>(this),
+        loadTimeout, nsITimer::TYPE_ONE_SHOT, "LoadTimerCallback", target);
+  } 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() {
+  if (!StaticPrefs::layout_css_font_display_enabled()) {
+    return StyleFontDisplay::Auto;
+  }
+  return mUserFontEntry->GetFontDisplay();
+}
+
+#undef LOG
+#undef LOG_ENABLED