Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 837 insertions, 0 deletions

diff --git a/toolkit/components/places/nsFaviconService.cpp b/toolkit/components/places/nsFaviconService.cpp
new file mode 100644
index 0000000000..cf708f136a
--- /dev/null
+++ b/toolkit/components/places/nsFaviconService.cpp
@@ -0,0 +1,837 @@
+/* -*- 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/. */
+
+/**
+ * This is the favicon service, which stores favicons for web pages with your
+ * history as you browse. It is also used to save the favicons for bookmarks.
+ *
+ * DANGER: The history query system makes assumptions about the favicon storage
+ * so that icons can be quickly generated for history/bookmark result sets. If
+ * you change the database layout at all, you will have to update both services.
+ */
+
+#include "nsFaviconService.h"
+
+#include "nsNavHistory.h"
+#include "nsPlacesMacros.h"
+#include "Helpers.h"
+
+#include "nsNetUtil.h"
+#include "nsReadableUtils.h"
+#include "nsStreamUtils.h"
+#include "plbase64.h"
+#include "nsIClassInfoImpl.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/Preferences.h"
+#include "nsILoadInfo.h"
+#include "nsIContentPolicy.h"
+#include "nsIProtocolHandler.h"
+#include "nsIScriptError.h"
+#include "nsContentUtils.h"
+#include "imgICache.h"
+
+#define UNASSOCIATED_FAVICONS_LENGTH 32
+
+// When replaceFaviconData is called, we store the icons in an in-memory cache
+// instead of in storage. Icons in the cache are expired according to this
+// interval.
+#define UNASSOCIATED_ICON_EXPIRY_INTERVAL 60000
+
+using namespace mozilla;
+using namespace mozilla::places;
+
+const uint16_t gFaviconSizes[7] = {192, 144, 96, 64, 48, 32, 16};
+
+/**
+ * Used to notify a topic to system observers on async execute completion.
+ * Will throw on error.
+ */
+class ExpireFaviconsStatementCallbackNotifier : public AsyncStatementCallback {
+ public:
+  ExpireFaviconsStatementCallbackNotifier();
+  NS_IMETHOD HandleCompletion(uint16_t aReason) override;
+};
+
+namespace {
+
+/**
+ * Extracts and filters native sizes from the given container, based on the
+ * list of sizes we are supposed to retain.
+ * All calculation is done considering square sizes and the largest side.
+ * In case of multiple frames of the same size, only the first one is retained.
+ */
+nsresult GetFramesInfoForContainer(imgIContainer* aContainer,
+                                   nsTArray<FrameData>& aFramesInfo) {
+  // Don't extract frames from animated images.
+  bool animated;
+  nsresult rv = aContainer->GetAnimated(&animated);
+  if (NS_FAILED(rv) || !animated) {
+    nsTArray<nsIntSize> nativeSizes;
+    rv = aContainer->GetNativeSizes(nativeSizes);
+    if (NS_SUCCEEDED(rv) && nativeSizes.Length() > 1) {
+      for (uint32_t i = 0; i < nativeSizes.Length(); ++i) {
+        nsIntSize nativeSize = nativeSizes[i];
+        // Only retain square frames.
+        if (nativeSize.width != nativeSize.height) {
+          continue;
+        }
+        // Check if it's one of the sizes we care about.
+        auto end = std::end(gFaviconSizes);
+        const uint16_t* matchingSize =
+            std::find(std::begin(gFaviconSizes), end, nativeSize.width);
+        if (matchingSize != end) {
+          // We must avoid duped sizes, an image could contain multiple frames
+          // of the same size, but we can only store one. We could use an
+          // hashtable, but considered the average low number of frames, we'll
+          // just do a linear search.
+          bool dupe = false;
+          for (const auto& frameInfo : aFramesInfo) {
+            if (frameInfo.width == *matchingSize) {
+              dupe = true;
+              break;
+            }
+          }
+          if (!dupe) {
+            aFramesInfo.AppendElement(FrameData(i, *matchingSize));
+          }
+        }
+      }
+    }
+  }
+
+  if (aFramesInfo.Length() == 0) {
+    // Always have at least the default size.
+    int32_t width;
+    rv = aContainer->GetWidth(&width);
+    NS_ENSURE_SUCCESS(rv, rv);
+    int32_t height;
+    rv = aContainer->GetHeight(&height);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // For non-square images, pick the largest side.
+    aFramesInfo.AppendElement(FrameData(0, std::max(width, height)));
+  }
+  return NS_OK;
+}
+
+}  // namespace
+
+PLACES_FACTORY_SINGLETON_IMPLEMENTATION(nsFaviconService, gFaviconService)
+
+NS_IMPL_CLASSINFO(nsFaviconService, nullptr, 0, NS_FAVICONSERVICE_CID)
+NS_IMPL_ISUPPORTS_CI(nsFaviconService, nsIFaviconService, nsITimerCallback,
+                     nsINamed)
+
+nsFaviconService::nsFaviconService()
+    : mUnassociatedIcons(UNASSOCIATED_FAVICONS_LENGTH),
+      mDefaultIconURIPreferredSize(UINT16_MAX) {
+  NS_ASSERTION(!gFaviconService,
+               "Attempting to create two instances of the service!");
+  gFaviconService = this;
+}
+
+nsFaviconService::~nsFaviconService() {
+  NS_ASSERTION(gFaviconService == this,
+               "Deleting a non-singleton instance of the service");
+  if (gFaviconService == this) gFaviconService = nullptr;
+}
+
+Atomic<int64_t> nsFaviconService::sLastInsertedIconId(0);
+
+void  // static
+nsFaviconService::StoreLastInsertedId(const nsACString& aTable,
+                                      const int64_t aLastInsertedId) {
+  MOZ_ASSERT(aTable.EqualsLiteral("moz_icons"));
+  sLastInsertedIconId = aLastInsertedId;
+}
+
+nsresult nsFaviconService::Init() {
+  mDB = Database::GetDatabase();
+  NS_ENSURE_STATE(mDB);
+
+  mExpireUnassociatedIconsTimer = NS_NewTimer();
+  NS_ENSURE_STATE(mExpireUnassociatedIconsTimer);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::ExpireAllFavicons() {
+  NS_ENSURE_STATE(mDB);
+
+  nsCOMPtr<mozIStorageAsyncStatement> removePagesStmt =
+      mDB->GetAsyncStatement("DELETE FROM moz_pages_w_icons");
+  NS_ENSURE_STATE(removePagesStmt);
+  nsCOMPtr<mozIStorageAsyncStatement> removeIconsStmt =
+      mDB->GetAsyncStatement("DELETE FROM moz_icons");
+  NS_ENSURE_STATE(removeIconsStmt);
+  nsCOMPtr<mozIStorageAsyncStatement> unlinkIconsStmt =
+      mDB->GetAsyncStatement("DELETE FROM moz_icons_to_pages");
+  NS_ENSURE_STATE(unlinkIconsStmt);
+
+  nsTArray<RefPtr<mozIStorageBaseStatement>> stmts = {
+      ToRefPtr(std::move(removePagesStmt)),
+      ToRefPtr(std::move(removeIconsStmt)),
+      ToRefPtr(std::move(unlinkIconsStmt))};
+  nsCOMPtr<mozIStorageConnection> conn = mDB->MainConn();
+  if (!conn) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  nsCOMPtr<mozIStoragePendingStatement> ps;
+  RefPtr<ExpireFaviconsStatementCallbackNotifier> callback =
+      new ExpireFaviconsStatementCallbackNotifier();
+  return conn->ExecuteAsync(stmts, callback, getter_AddRefs(ps));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsITimerCallback
+
+NS_IMETHODIMP
+nsFaviconService::Notify(nsITimer* timer) {
+  if (timer != mExpireUnassociatedIconsTimer.get()) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  PRTime now = PR_Now();
+  for (auto iter = mUnassociatedIcons.Iter(); !iter.Done(); iter.Next()) {
+    UnassociatedIconHashKey* iconKey = iter.Get();
+    if (now - iconKey->created >= UNASSOCIATED_ICON_EXPIRY_INTERVAL) {
+      iter.Remove();
+    }
+  }
+
+  // Re-init the expiry timer if the cache isn't empty.
+  if (mUnassociatedIcons.Count() > 0) {
+    mExpireUnassociatedIconsTimer->InitWithCallback(
+        this, UNASSOCIATED_ICON_EXPIRY_INTERVAL, nsITimer::TYPE_ONE_SHOT);
+  }
+
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+//// nsINamed
+
+NS_IMETHODIMP
+nsFaviconService::GetName(nsACString& aName) {
+  aName.AssignLiteral("nsFaviconService");
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// nsIFaviconService
+
+NS_IMETHODIMP
+nsFaviconService::GetDefaultFavicon(nsIURI** _retval) {
+  NS_ENSURE_ARG_POINTER(_retval);
+
+  // not found, use default
+  if (!mDefaultIcon) {
+    nsresult rv = NS_NewURI(getter_AddRefs(mDefaultIcon),
+                            nsLiteralCString(FAVICON_DEFAULT_URL));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  nsCOMPtr<nsIURI> uri = mDefaultIcon;
+  uri.forget(_retval);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::GetDefaultFaviconMimeType(nsACString& _retval) {
+  _retval = nsLiteralCString(FAVICON_DEFAULT_MIMETYPE);
+  return NS_OK;
+}
+
+void nsFaviconService::ClearImageCache(nsIURI* aImageURI) {
+  MOZ_ASSERT(aImageURI, "Must pass a non-null URI");
+  nsCOMPtr<imgICache> imgCache;
+  nsresult rv =
+      GetImgTools()->GetImgCacheForDocument(nullptr, getter_AddRefs(imgCache));
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+  if (NS_SUCCEEDED(rv)) {
+    Unused << imgCache->RemoveEntry(aImageURI, nullptr);
+  }
+}
+
+NS_IMETHODIMP
+nsFaviconService::SetAndFetchFaviconForPage(
+    nsIURI* aPageURI, nsIURI* aFaviconURI, bool aForceReload,
+    uint32_t aFaviconLoadType, nsIFaviconDataCallback* aCallback,
+    nsIPrincipal* aLoadingPrincipal, uint64_t aRequestContextID,
+    mozIPlacesPendingOperation** _canceler) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aPageURI);
+  NS_ENSURE_ARG(aFaviconURI);
+  NS_ENSURE_ARG_POINTER(_canceler);
+
+  nsCOMPtr<nsIPrincipal> loadingPrincipal = aLoadingPrincipal;
+  MOZ_ASSERT(loadingPrincipal,
+             "please provide aLoadingPrincipal for this favicon");
+  if (!loadingPrincipal) {
+    // Let's default to the nullPrincipal if no loadingPrincipal is provided.
+    AutoTArray<nsString, 2> params = {
+        u"nsFaviconService::setAndFetchFaviconForPage()"_ns,
+        u"nsFaviconService::setAndFetchFaviconForPage(..., "
+        "[optional aLoadingPrincipal])"_ns};
+    nsContentUtils::ReportToConsole(
+        nsIScriptError::warningFlag, "Security by Default"_ns,
+        nullptr,  // aDocument
+        nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning", params);
+    loadingPrincipal = NullPrincipal::CreateWithoutOriginAttributes();
+  }
+  NS_ENSURE_TRUE(loadingPrincipal, NS_ERROR_FAILURE);
+
+  bool loadPrivate =
+      aFaviconLoadType == nsIFaviconService::FAVICON_LOAD_PRIVATE;
+
+  // Build page data.
+  PageData page;
+  nsresult rv = aPageURI->GetSpec(page.spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // URIs can arguably lack a host.
+  Unused << aPageURI->GetHost(page.host);
+  if (StringBeginsWith(page.host, "www."_ns)) {
+    page.host.Cut(0, 4);
+  }
+  bool canAddToHistory;
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+  rv = navHistory->CanAddURI(aPageURI, &canAddToHistory);
+  NS_ENSURE_SUCCESS(rv, rv);
+  page.canAddToHistory = !!canAddToHistory && !loadPrivate;
+
+  // Build icon data.
+  IconData icon;
+  // If we have an in-memory icon payload, it overwrites the actual request.
+  UnassociatedIconHashKey* iconKey = mUnassociatedIcons.GetEntry(aFaviconURI);
+  if (iconKey) {
+    icon = iconKey->iconData;
+    mUnassociatedIcons.RemoveEntry(iconKey);
+  } else {
+    icon.fetchMode = aForceReload ? FETCH_ALWAYS : FETCH_IF_MISSING;
+    rv = aFaviconURI->GetSpec(icon.spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+    // URIs can arguably lack a host.
+    Unused << aFaviconURI->GetHost(icon.host);
+    if (StringBeginsWith(icon.host, "www."_ns)) {
+      icon.host.Cut(0, 4);
+    }
+  }
+
+  // A root icon is when the icon and page have the same host and the path
+  // is just /favicon.ico. These icons are considered valid for the whole
+  // origin and expired with the origin through a trigger.
+  nsAutoCString path;
+  if (NS_SUCCEEDED(aFaviconURI->GetPathQueryRef(path)) &&
+      !icon.host.IsEmpty() && icon.host.Equals(page.host) &&
+      path.EqualsLiteral("/favicon.ico")) {
+    icon.rootIcon = 1;
+  }
+
+  // If the page url points to an image, the icon's url will be the same.
+  // TODO (Bug 403651): store a resample of the image.  For now avoid that
+  // for database size and UX concerns.
+  // Don't store favicons for error pages either.
+  if (icon.spec.Equals(page.spec) ||
+      icon.spec.EqualsLiteral(FAVICON_CERTERRORPAGE_URL) ||
+      icon.spec.EqualsLiteral(FAVICON_ERRORPAGE_URL)) {
+    return NS_OK;
+  }
+
+  RefPtr<AsyncFetchAndSetIconForPage> event = new AsyncFetchAndSetIconForPage(
+      icon, page, loadPrivate, aCallback, aLoadingPrincipal, aRequestContextID);
+
+  // Get the target thread and start the work.
+  // DB will be updated and observers notified when data has finished loading.
+  RefPtr<Database> DB = Database::GetDatabase();
+  NS_ENSURE_STATE(DB);
+  DB->DispatchToAsyncThread(event);
+
+  // Return this event to the caller to allow aborting an eventual fetch.
+  event.forget(_canceler);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::ReplaceFaviconData(nsIURI* aFaviconURI,
+                                     const nsTArray<uint8_t>& aData,
+                                     const nsACString& aMimeType,
+                                     PRTime aExpiration) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aFaviconURI);
+  NS_ENSURE_ARG(aData.Length() > 0);
+  NS_ENSURE_ARG(aMimeType.Length() > 0);
+  NS_ENSURE_ARG(imgLoader::SupportImageWithMimeType(
+      aMimeType, AcceptedMimeTypes::IMAGES_AND_DOCUMENTS));
+
+  PRTime now = PR_Now();
+  if (aExpiration < now + MIN_FAVICON_EXPIRATION) {
+    // Invalid input, just use the default.
+    aExpiration = now + MAX_FAVICON_EXPIRATION;
+  }
+
+  UnassociatedIconHashKey* iconKey = mUnassociatedIcons.PutEntry(aFaviconURI);
+  if (!iconKey) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  iconKey->created = PR_Now();
+
+  // If the cache contains unassociated icons, an expiry timer should already
+  // exist, otherwise there may be a timer left hanging around, so make sure we
+  // fire a new one.
+  int32_t unassociatedCount = mUnassociatedIcons.Count();
+  if (unassociatedCount == 1) {
+    mExpireUnassociatedIconsTimer->Cancel();
+    mExpireUnassociatedIconsTimer->InitWithCallback(
+        this, UNASSOCIATED_ICON_EXPIRY_INTERVAL, nsITimer::TYPE_ONE_SHOT);
+  }
+
+  IconData* iconData = &(iconKey->iconData);
+  iconData->expiration = aExpiration;
+  iconData->status = ICON_STATUS_CACHED;
+  iconData->fetchMode = FETCH_NEVER;
+  nsresult rv = aFaviconURI->GetSpec(iconData->spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  // URIs can arguably lack a host.
+  Unused << aFaviconURI->GetHost(iconData->host);
+  if (StringBeginsWith(iconData->host, "www."_ns)) {
+    iconData->host.Cut(0, 4);
+  }
+
+  // Note we can't set rootIcon here, because don't know the page it will be
+  // associated with. We'll do that later in SetAndFetchFaviconForPage if the
+  // icon doesn't exist; otherwise, if AsyncReplaceFaviconData updates an
+  // existing icon, it will take care of not overwriting an existing
+  // root = 1 value.
+
+  IconPayload payload;
+  payload.mimeType = aMimeType;
+  payload.data.Assign(TO_CHARBUFFER(aData.Elements()), aData.Length());
+  if (payload.mimeType.EqualsLiteral(SVG_MIME_TYPE)) {
+    payload.width = UINT16_MAX;
+  }
+  // There may already be a previous payload, so ensure to only have one.
+  iconData->payloads.Clear();
+  iconData->payloads.AppendElement(payload);
+
+  rv = OptimizeIconSizes(*iconData);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // If there's not valid payload, don't store the icon into to the database.
+  if ((*iconData).payloads.Length() == 0) {
+    // We cannot optimize this favicon size and we are over the maximum size
+    // allowed, so we will not save data to the db to avoid bloating it.
+    mUnassociatedIcons.RemoveEntry(aFaviconURI);
+    return NS_ERROR_FAILURE;
+  }
+
+  // If the database contains an icon at the given url, we will update the
+  // database immediately so that the associated pages are kept in sync.
+  // Otherwise, do nothing and let the icon be picked up from the memory hash.
+  RefPtr<AsyncReplaceFaviconData> event =
+      new AsyncReplaceFaviconData(*iconData);
+  RefPtr<Database> DB = Database::GetDatabase();
+  NS_ENSURE_STATE(DB);
+  DB->DispatchToAsyncThread(event);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::ReplaceFaviconDataFromDataURL(
+    nsIURI* aFaviconURI, const nsAString& aDataURL, PRTime aExpiration,
+    nsIPrincipal* aLoadingPrincipal) {
+  NS_ENSURE_ARG(aFaviconURI);
+  NS_ENSURE_TRUE(aDataURL.Length() > 0, NS_ERROR_INVALID_ARG);
+  PRTime now = PR_Now();
+  if (aExpiration < now + MIN_FAVICON_EXPIRATION) {
+    // Invalid input, just use the default.
+    aExpiration = now + MAX_FAVICON_EXPIRATION;
+  }
+
+  nsCOMPtr<nsIURI> dataURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(dataURI), aDataURL);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Use the data: protocol handler to convert the data.
+  nsCOMPtr<nsIIOService> ioService = do_GetIOService(&rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsCOMPtr<nsIProtocolHandler> protocolHandler;
+  rv = ioService->GetProtocolHandler("data", getter_AddRefs(protocolHandler));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIPrincipal> loadingPrincipal = aLoadingPrincipal;
+  MOZ_ASSERT(loadingPrincipal,
+             "please provide aLoadingPrincipal for this favicon");
+  if (!loadingPrincipal) {
+    // Let's default to the nullPrincipal if no loadingPrincipal is provided.
+    AutoTArray<nsString, 2> params = {
+        u"nsFaviconService::ReplaceFaviconDataFromDataURL()"_ns,
+        u"nsFaviconService::ReplaceFaviconDataFromDataURL(...,"
+        " [optional aLoadingPrincipal])"_ns};
+    nsContentUtils::ReportToConsole(
+        nsIScriptError::warningFlag, "Security by Default"_ns,
+        nullptr,  // aDocument
+        nsContentUtils::eNECKO_PROPERTIES, "APIDeprecationWarning", params);
+
+    loadingPrincipal = NullPrincipal::CreateWithoutOriginAttributes();
+  }
+  NS_ENSURE_TRUE(loadingPrincipal, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsILoadInfo> loadInfo = new mozilla::net::LoadInfo(
+      loadingPrincipal,
+      nullptr,  // aTriggeringPrincipal
+      nullptr,  // aLoadingNode
+      nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_INHERITS_SEC_CONTEXT |
+          nsILoadInfo::SEC_ALLOW_CHROME | nsILoadInfo::SEC_DISALLOW_SCRIPT,
+      nsIContentPolicy::TYPE_INTERNAL_IMAGE_FAVICON);
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = protocolHandler->NewChannel(dataURI, loadInfo, getter_AddRefs(channel));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Blocking stream is OK for data URIs.
+  nsCOMPtr<nsIInputStream> stream;
+  rv = channel->Open(getter_AddRefs(stream));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  uint64_t available64;
+  rv = stream->Available(&available64);
+  NS_ENSURE_SUCCESS(rv, rv);
+  if (available64 == 0 || available64 > UINT32_MAX / sizeof(uint8_t))
+    return NS_ERROR_FILE_TOO_BIG;
+  uint32_t available = (uint32_t)available64;
+
+  // Read all the decoded data.
+  nsTArray<uint8_t> buffer;
+  buffer.SetLength(available);
+  uint32_t numRead;
+  rv = stream->Read(TO_CHARBUFFER(buffer.Elements()), available, &numRead);
+  if (NS_FAILED(rv) || numRead != available) {
+    return rv;
+  }
+
+  nsAutoCString mimeType;
+  rv = channel->GetContentType(mimeType);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  // ReplaceFaviconData can now do the dirty work.
+  rv = ReplaceFaviconData(aFaviconURI, buffer, mimeType, aExpiration);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::GetFaviconURLForPage(nsIURI* aPageURI,
+                                       nsIFaviconDataCallback* aCallback,
+                                       uint16_t aPreferredWidth) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aPageURI);
+  NS_ENSURE_ARG(aCallback);
+  // Use the default value, may be UINT16_MAX if a default is not set.
+  if (aPreferredWidth == 0) {
+    aPreferredWidth = mDefaultIconURIPreferredSize;
+  }
+
+  nsAutoCString pageSpec;
+  nsresult rv = aPageURI->GetSpec(pageSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString pageHost;
+  // It's expected that some domains may not have a host.
+  Unused << aPageURI->GetHost(pageHost);
+
+  RefPtr<AsyncGetFaviconURLForPage> event = new AsyncGetFaviconURLForPage(
+      pageSpec, pageHost, aPreferredWidth, aCallback);
+
+  RefPtr<Database> DB = Database::GetDatabase();
+  NS_ENSURE_STATE(DB);
+  DB->DispatchToAsyncThread(event);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::GetFaviconDataForPage(nsIURI* aPageURI,
+                                        nsIFaviconDataCallback* aCallback,
+                                        uint16_t aPreferredWidth) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aPageURI);
+  NS_ENSURE_ARG(aCallback);
+  // Use the default value, may be UINT16_MAX if a default is not set.
+  if (aPreferredWidth == 0) {
+    aPreferredWidth = mDefaultIconURIPreferredSize;
+  }
+
+  nsAutoCString pageSpec;
+  nsresult rv = aPageURI->GetSpec(pageSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  nsAutoCString pageHost;
+  // It's expected that some domains may not have a host.
+  Unused << aPageURI->GetHost(pageHost);
+
+  RefPtr<AsyncGetFaviconDataForPage> event = new AsyncGetFaviconDataForPage(
+      pageSpec, pageHost, aPreferredWidth, aCallback);
+  RefPtr<Database> DB = Database::GetDatabase();
+  NS_ENSURE_STATE(DB);
+  DB->DispatchToAsyncThread(event);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::CopyFavicons(nsIURI* aFromPageURI, nsIURI* aToPageURI,
+                               uint32_t aFaviconLoadType,
+                               nsIFaviconDataCallback* aCallback) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ENSURE_ARG(aFromPageURI);
+  NS_ENSURE_ARG(aToPageURI);
+  NS_ENSURE_TRUE(
+      aFaviconLoadType >= nsIFaviconService::FAVICON_LOAD_PRIVATE &&
+          aFaviconLoadType <= nsIFaviconService::FAVICON_LOAD_NON_PRIVATE,
+      NS_ERROR_INVALID_ARG);
+
+  PageData fromPage;
+  nsresult rv = aFromPageURI->GetSpec(fromPage.spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+  PageData toPage;
+  rv = aToPageURI->GetSpec(toPage.spec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  bool canAddToHistory;
+  nsNavHistory* navHistory = nsNavHistory::GetHistoryService();
+  NS_ENSURE_TRUE(navHistory, NS_ERROR_OUT_OF_MEMORY);
+  rv = navHistory->CanAddURI(aToPageURI, &canAddToHistory);
+  NS_ENSURE_SUCCESS(rv, rv);
+  toPage.canAddToHistory =
+      !!canAddToHistory &&
+      aFaviconLoadType != nsIFaviconService::FAVICON_LOAD_PRIVATE;
+
+  RefPtr<AsyncCopyFavicons> event =
+      new AsyncCopyFavicons(fromPage, toPage, aCallback);
+
+  // Get the target thread and start the work.
+  // DB will be updated and observers notified when done.
+  RefPtr<Database> DB = Database::GetDatabase();
+  NS_ENSURE_STATE(DB);
+  DB->DispatchToAsyncThread(event);
+
+  return NS_OK;
+}
+
+nsresult nsFaviconService::GetFaviconLinkForIcon(nsIURI* aFaviconURI,
+                                                 nsIURI** aOutputURI) {
+  NS_ENSURE_ARG(aFaviconURI);
+  NS_ENSURE_ARG_POINTER(aOutputURI);
+
+  nsAutoCString spec;
+  if (aFaviconURI) {
+    nsresult rv = aFaviconURI->GetSpec(spec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  return GetFaviconLinkForIconString(spec, aOutputURI);
+}
+
+// nsFaviconService::GetFaviconLinkForIconString
+//
+//    This computes a favicon URL with string input and using the cached
+//    default one to minimize parsing.
+
+nsresult nsFaviconService::GetFaviconLinkForIconString(const nsCString& aSpec,
+                                                       nsIURI** aOutput) {
+  if (aSpec.IsEmpty()) {
+    return GetDefaultFavicon(aOutput);
+  }
+
+  if (StringBeginsWith(aSpec, "chrome:"_ns)) {
+    // pass through for chrome URLs, since they can be referenced without
+    // this service
+    return NS_NewURI(aOutput, aSpec);
+  }
+
+  nsAutoCString annoUri;
+  annoUri.AssignLiteral("moz-anno:" FAVICON_ANNOTATION_NAME ":");
+  annoUri += aSpec;
+  return NS_NewURI(aOutput, annoUri);
+}
+
+/**
+ * Checks the icon and evaluates if it needs to be optimized.
+ *
+ * @param aIcon
+ *        The icon to be evaluated.
+ */
+nsresult nsFaviconService::OptimizeIconSizes(IconData& aIcon) {
+  // TODO (bug 1346139): move optimization to the async thread.
+  MOZ_ASSERT(NS_IsMainThread());
+  // There should only be a single payload at this point, it may have to be
+  // split though, if it's an ico file.
+  MOZ_ASSERT(aIcon.payloads.Length() == 1);
+
+  // Even if the page provides a large image for the favicon (eg, a highres
+  // image or a multiresolution .ico file), don't try to store more data than
+  // needed.
+  IconPayload payload = aIcon.payloads[0];
+  if (payload.mimeType.EqualsLiteral(SVG_MIME_TYPE)) {
+    // Nothing to optimize, but check the payload size.
+    if (payload.data.Length() >= nsIFaviconService::MAX_FAVICON_BUFFER_SIZE) {
+      aIcon.payloads.Clear();
+    }
+    return NS_OK;
+  }
+
+  // Make space for the optimized payloads.
+  aIcon.payloads.Clear();
+
+  // decode image
+  nsCOMPtr<imgIContainer> container;
+  nsresult rv = GetImgTools()->DecodeImageFromBuffer(
+      payload.data.get(), payload.data.Length(), payload.mimeType,
+      getter_AddRefs(container));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // For ICO files, we must evaluate each of the frames we care about.
+  nsTArray<FrameData> framesInfo;
+  rv = GetFramesInfoForContainer(container, framesInfo);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (const auto& frameInfo : framesInfo) {
+    IconPayload newPayload;
+    newPayload.mimeType = nsLiteralCString(PNG_MIME_TYPE);
+    newPayload.width = frameInfo.width;
+    for (uint16_t size : gFaviconSizes) {
+      // The icon could be smaller than 16, that is our minimum.
+      // Icons smaller than 16px are kept as-is.
+      if (frameInfo.width >= 16) {
+        if (size > frameInfo.width) {
+          continue;
+        }
+        newPayload.width = size;
+      }
+
+      // If the original payload is png, the size is the same and not animated,
+      // rescale the image only if it's larger than the maximum allowed.
+      bool animated;
+      if (newPayload.mimeType.Equals(payload.mimeType) &&
+          newPayload.width == frameInfo.width &&
+          payload.data.Length() < nsIFaviconService::MAX_FAVICON_BUFFER_SIZE &&
+          (NS_FAILED(container->GetAnimated(&animated)) || !animated)) {
+        newPayload.data = payload.data;
+        break;
+      }
+
+      // Otherwise, scale and recompress. Rescaling will also take care of
+      // extracting a static image from an animated one.
+      // Since EncodeScaledImage uses SYNC_DECODE, it will pick the best
+      // frame.
+      nsCOMPtr<nsIInputStream> iconStream;
+      rv = GetImgTools()->EncodeScaledImage(container, newPayload.mimeType,
+                                            newPayload.width, newPayload.width,
+                                            u""_ns, getter_AddRefs(iconStream));
+      NS_ENSURE_SUCCESS(rv, rv);
+      // Read the stream into the new buffer.
+      rv = NS_ConsumeStream(iconStream, UINT32_MAX, newPayload.data);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      // If the icon size is good, we are done, otherwise try the next size.
+      if (newPayload.data.Length() <
+          nsIFaviconService::MAX_FAVICON_BUFFER_SIZE) {
+        break;
+      }
+    }
+
+    MOZ_ASSERT(newPayload.data.Length() <
+               nsIFaviconService::MAX_FAVICON_BUFFER_SIZE);
+    if (newPayload.data.Length() < nsIFaviconService::MAX_FAVICON_BUFFER_SIZE) {
+      aIcon.payloads.AppendElement(newPayload);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult nsFaviconService::GetFaviconDataAsync(
+    const nsCString& aFaviconURI, mozIStorageStatementCallback* aCallback) {
+  MOZ_ASSERT(aCallback, "Doesn't make sense to call this without a callback");
+
+  nsCOMPtr<mozIStorageAsyncStatement> stmt = mDB->GetAsyncStatement(
+      "/*Do not warn (bug no: not worth adding an index */ "
+      "SELECT data, width FROM moz_icons "
+      "WHERE fixed_icon_url_hash = hash(fixup_url(:url)) AND icon_url = :url "
+      "ORDER BY width DESC");
+  NS_ENSURE_STATE(stmt);
+
+  nsresult rv = URIBinder::Bind(stmt, "url"_ns, aFaviconURI);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<mozIStoragePendingStatement> pendingStatement;
+  return stmt->ExecuteAsync(aCallback, getter_AddRefs(pendingStatement));
+}
+
+NS_IMETHODIMP
+nsFaviconService::SetDefaultIconURIPreferredSize(uint16_t aDefaultSize) {
+  mDefaultIconURIPreferredSize = aDefaultSize > 0 ? aDefaultSize : UINT16_MAX;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFaviconService::PreferredSizeFromURI(nsIURI* aURI, uint16_t* _size) {
+  NS_ENSURE_ARG(aURI);
+  *_size = mDefaultIconURIPreferredSize;
+  nsAutoCString ref;
+  // Check for a ref first.
+  if (NS_FAILED(aURI->GetRef(ref)) || ref.Length() == 0) return NS_OK;
+
+  // Look for a "size=" fragment.
+  int32_t start = ref.RFind("size=");
+  if (start >= 0 && ref.Length() > static_cast<uint32_t>(start) + 5) {
+    nsDependentCSubstring size;
+    // This is safe regardless, since Rebind checks start is not over Length().
+    size.Rebind(ref, start + 5);
+    // Check if the string contains any non-digit.
+    auto begin = size.BeginReading(), end = size.EndReading();
+    for (auto ch = begin; ch < end; ++ch) {
+      if (*ch < '0' || *ch > '9') {
+        // Not a digit.
+        return NS_OK;
+      }
+    }
+    // Convert the string to an integer value.
+    nsresult rv;
+    uint16_t val = PromiseFlatCString(size).ToInteger(&rv);
+    if (NS_SUCCEEDED(rv)) {
+      *_size = val;
+    }
+  }
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//// ExpireFaviconsStatementCallbackNotifier
+
+ExpireFaviconsStatementCallbackNotifier::
+    ExpireFaviconsStatementCallbackNotifier() = default;
+
+NS_IMETHODIMP
+ExpireFaviconsStatementCallbackNotifier::HandleCompletion(uint16_t aReason) {
+  // We should dispatch only if expiration has been successful.
+  if (aReason != mozIStorageStatementCallback::REASON_FINISHED) return NS_OK;
+
+  nsCOMPtr<nsIObserverService> observerService =
+      mozilla::services::GetObserverService();
+  if (observerService) {
+    (void)observerService->NotifyObservers(
+        nullptr, NS_PLACES_FAVICONS_EXPIRED_TOPIC_ID, nullptr);
+  }
+
+  return NS_OK;
+}