Add m-esr52 at 52.6.0

1 files changed, 1087 insertions, 0 deletions

diff --git a/dom/base/nsHostObjectProtocolHandler.cpp b/dom/base/nsHostObjectProtocolHandler.cpp
new file mode 100644
index 000000000..f2fdfc530
--- /dev/null
+++ b/dom/base/nsHostObjectProtocolHandler.cpp
@@ -0,0 +1,1087 @@
+/* -*- 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/. */
+
+#include "nsHostObjectProtocolHandler.h"
+
+#include "DOMMediaStream.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Exceptions.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/ipc/BlobChild.h"
+#include "mozilla/dom/ipc/BlobParent.h"
+#include "mozilla/dom/MediaSource.h"
+#include "mozilla/LoadInfo.h"
+#include "mozilla/ModuleUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsClassHashtable.h"
+#include "nsContentUtils.h"
+#include "nsError.h"
+#include "nsHostObjectURI.h"
+#include "nsIMemoryReporter.h"
+#include "nsIPrincipal.h"
+#include "nsIUUIDGenerator.h"
+#include "nsNetUtil.h"
+
+#define RELEASING_TIMER 1000
+
+using mozilla::DOMMediaStream;
+using mozilla::dom::BlobImpl;
+using mozilla::dom::MediaSource;
+using mozilla::ErrorResult;
+using mozilla::net::LoadInfo;
+using mozilla::Move;
+using mozilla::Unused;
+
+// -----------------------------------------------------------------------
+// Hash table
+struct DataInfo
+{
+  enum ObjectType {
+    eBlobImpl,
+    eMediaStream,
+    eMediaSource
+  };
+
+  DataInfo(BlobImpl* aBlobImpl, nsIPrincipal* aPrincipal)
+    : mObjectType(eBlobImpl)
+    , mBlobImpl(aBlobImpl)
+    , mPrincipal(aPrincipal)
+  {}
+
+  DataInfo(DOMMediaStream* aMediaStream, nsIPrincipal* aPrincipal)
+    : mObjectType(eMediaStream)
+    , mMediaStream(aMediaStream)
+    , mPrincipal(aPrincipal)
+  {}
+
+  DataInfo(MediaSource* aMediaSource, nsIPrincipal* aPrincipal)
+    : mObjectType(eMediaSource)
+    , mMediaSource(aMediaSource)
+    , mPrincipal(aPrincipal)
+  {}
+
+  ObjectType mObjectType;
+
+  RefPtr<BlobImpl> mBlobImpl;
+  RefPtr<DOMMediaStream> mMediaStream;
+  RefPtr<MediaSource> mMediaSource;
+
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCString mStack;
+
+  // WeakReferences of nsHostObjectURI objects.
+  nsTArray<nsWeakPtr> mURIs;
+};
+
+static nsClassHashtable<nsCStringHashKey, DataInfo>* gDataTable;
+
+static DataInfo*
+GetDataInfo(const nsACString& aUri)
+{
+  if (!gDataTable) {
+    return nullptr;
+  }
+
+  DataInfo* res;
+
+  // Let's remove any fragment and query from this URI.
+  int32_t hasFragmentPos = aUri.FindChar('#');
+  int32_t hasQueryPos = aUri.FindChar('?');
+
+  int32_t pos = -1;
+  if (hasFragmentPos >= 0 && hasQueryPos >= 0) {
+    pos = std::min(hasFragmentPos, hasQueryPos);
+  } else if (hasFragmentPos >= 0) {
+    pos = hasFragmentPos;
+  } else {
+    pos = hasQueryPos;
+  }
+
+  if (pos < 0) {
+    gDataTable->Get(aUri, &res);
+  } else {
+    gDataTable->Get(StringHead(aUri, pos), &res);
+  }
+
+  return res;
+}
+
+static DataInfo*
+GetDataInfoFromURI(nsIURI* aURI)
+{
+  if (!aURI) {
+    return nullptr;
+  }
+
+  nsCString spec;
+  nsresult rv = aURI->GetSpec(spec);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return nullptr;
+  }
+
+  return GetDataInfo(spec);
+}
+
+// Memory reporting for the hash table.
+namespace mozilla {
+
+void
+BroadcastBlobURLRegistration(const nsACString& aURI,
+                             BlobImpl* aBlobImpl,
+                             nsIPrincipal* aPrincipal)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aBlobImpl);
+
+  if (XRE_IsParentProcess()) {
+    dom::ContentParent::BroadcastBlobURLRegistration(aURI, aBlobImpl,
+                                                     aPrincipal);
+    return;
+  }
+
+  dom::ContentChild* cc = dom::ContentChild::GetSingleton();
+  dom::BlobChild* actor = cc->GetOrCreateActorForBlobImpl(aBlobImpl);
+  if (NS_WARN_IF(!actor)) {
+    return;
+  }
+
+  Unused << NS_WARN_IF(!cc->SendStoreAndBroadcastBlobURLRegistration(
+    nsCString(aURI), actor, IPC::Principal(aPrincipal)));
+}
+
+void
+BroadcastBlobURLUnregistration(const nsACString& aURI, DataInfo* aInfo)
+{
+  MOZ_ASSERT(aInfo);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (XRE_IsParentProcess()) {
+    dom::ContentParent::BroadcastBlobURLUnregistration(aURI);
+    return;
+  }
+
+  dom::ContentChild* cc = dom::ContentChild::GetSingleton();
+  Unused << NS_WARN_IF(!cc->SendUnstoreAndBroadcastBlobURLUnregistration(
+    nsCString(aURI)));
+}
+
+class HostObjectURLsReporter final : public nsIMemoryReporter
+{
+  ~HostObjectURLsReporter() {}
+
+ public:
+  NS_DECL_ISUPPORTS
+
+  NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
+                            nsISupports* aData, bool aAnonymize) override
+  {
+    MOZ_COLLECT_REPORT(
+      "host-object-urls", KIND_OTHER, UNITS_COUNT,
+      gDataTable ? gDataTable->Count() : 0,
+      "The number of host objects stored for access via URLs "
+      "(e.g. blobs passed to URL.createObjectURL).");
+
+    return NS_OK;
+  }
+};
+
+NS_IMPL_ISUPPORTS(HostObjectURLsReporter, nsIMemoryReporter)
+
+class BlobURLsReporter final : public nsIMemoryReporter
+{
+ public:
+  NS_DECL_ISUPPORTS
+
+  NS_IMETHOD CollectReports(nsIHandleReportCallback* aCallback,
+                            nsISupports* aData, bool aAnonymize) override
+  {
+    if (!gDataTable) {
+      return NS_OK;
+    }
+
+    nsDataHashtable<nsPtrHashKey<BlobImpl>, uint32_t> refCounts;
+
+    // Determine number of URLs per BlobImpl, to handle the case where it's > 1.
+    for (auto iter = gDataTable->Iter(); !iter.Done(); iter.Next()) {
+      if (iter.UserData()->mObjectType != DataInfo::eBlobImpl) {
+        continue;
+      }
+
+      BlobImpl* blobImpl = iter.UserData()->mBlobImpl;
+      MOZ_ASSERT(blobImpl);
+
+      refCounts.Put(blobImpl, refCounts.Get(blobImpl) + 1);
+    }
+
+    for (auto iter = gDataTable->Iter(); !iter.Done(); iter.Next()) {
+      nsCStringHashKey::KeyType key = iter.Key();
+      DataInfo* info = iter.UserData();
+
+      if (iter.UserData()->mObjectType == DataInfo::eBlobImpl) {
+        BlobImpl* blobImpl = iter.UserData()->mBlobImpl;
+        MOZ_ASSERT(blobImpl);
+
+        NS_NAMED_LITERAL_CSTRING(desc,
+          "A blob URL allocated with URL.createObjectURL; the referenced "
+          "blob cannot be freed until all URLs for it have been explicitly "
+          "invalidated with URL.revokeObjectURL.");
+        nsAutoCString path, url, owner, specialDesc;
+        uint64_t size = 0;
+        uint32_t refCount = 1;
+        DebugOnly<bool> blobImplWasCounted;
+
+        blobImplWasCounted = refCounts.Get(blobImpl, &refCount);
+        MOZ_ASSERT(blobImplWasCounted);
+        MOZ_ASSERT(refCount > 0);
+
+        bool isMemoryFile = blobImpl->IsMemoryFile();
+
+        if (isMemoryFile) {
+          ErrorResult rv;
+          size = blobImpl->GetSize(rv);
+          if (NS_WARN_IF(rv.Failed())) {
+            rv.SuppressException();
+            size = 0;
+          }
+        }
+
+        path = isMemoryFile ? "memory-blob-urls/" : "file-blob-urls/";
+        BuildPath(path, key, info, aAnonymize);
+
+        if (refCount > 1) {
+          nsAutoCString addrStr;
+
+          addrStr = "0x";
+          addrStr.AppendInt((uint64_t)(BlobImpl*)blobImpl, 16);
+
+          path += " ";
+          path.AppendInt(refCount);
+          path += "@";
+          path += addrStr;
+
+          specialDesc = desc;
+          specialDesc += "\n\nNOTE: This blob (address ";
+          specialDesc += addrStr;
+          specialDesc += ") has ";
+          specialDesc.AppendInt(refCount);
+          specialDesc += " URLs.";
+          if (isMemoryFile) {
+            specialDesc += " Its size is divided ";
+            specialDesc += refCount > 2 ? "among" : "between";
+            specialDesc += " them in this report.";
+          }
+        }
+
+        const nsACString& descString = specialDesc.IsEmpty()
+            ? static_cast<const nsACString&>(desc)
+            : static_cast<const nsACString&>(specialDesc);
+        if (isMemoryFile) {
+          aCallback->Callback(EmptyCString(),
+              path,
+              KIND_OTHER,
+              UNITS_BYTES,
+              size / refCount,
+              descString,
+              aData);
+        } else {
+          aCallback->Callback(EmptyCString(),
+              path,
+              KIND_OTHER,
+              UNITS_COUNT,
+              1,
+              descString,
+              aData);
+        }
+        continue;
+      }
+
+      // Just report the path for the DOMMediaStream or MediaSource.
+      nsAutoCString path;
+      path = iter.UserData()->mObjectType == DataInfo::eMediaSource
+               ? "media-source-urls/" : "dom-media-stream-urls/";
+      BuildPath(path, key, info, aAnonymize);
+
+      NS_NAMED_LITERAL_CSTRING(desc,
+        "An object URL allocated with URL.createObjectURL; the referenced "
+        "data cannot be freed until all URLs for it have been explicitly "
+        "invalidated with URL.revokeObjectURL.");
+
+      aCallback->Callback(EmptyCString(), path, KIND_OTHER, UNITS_COUNT, 1,
+                          desc, aData);
+    }
+
+    return NS_OK;
+  }
+
+  // Initialize info->mStack to record JS stack info, if enabled.
+  // The string generated here is used in ReportCallback, below.
+  static void GetJSStackForBlob(DataInfo* aInfo)
+  {
+    nsCString& stack = aInfo->mStack;
+    MOZ_ASSERT(stack.IsEmpty());
+    const uint32_t maxFrames = Preferences::GetUint("memory.blob_report.stack_frames");
+
+    if (maxFrames == 0) {
+      return;
+    }
+
+    nsCOMPtr<nsIStackFrame> frame = dom::GetCurrentJSStack(maxFrames);
+
+    nsAutoCString origin;
+    nsCOMPtr<nsIURI> principalURI;
+    if (NS_SUCCEEDED(aInfo->mPrincipal->GetURI(getter_AddRefs(principalURI)))
+        && principalURI) {
+      principalURI->GetPrePath(origin);
+    }
+
+    // If we got a frame, we better have a current JSContext.  This is cheating
+    // a bit; ideally we'd have our caller pass in a JSContext, or have
+    // GetCurrentJSStack() hand out the JSContext it found.
+    JSContext* cx = frame ? nsContentUtils::GetCurrentJSContext() : nullptr;
+
+    for (uint32_t i = 0; frame; ++i) {
+      nsString fileNameUTF16;
+      int32_t lineNumber = 0;
+
+      frame->GetFilename(cx, fileNameUTF16);
+      frame->GetLineNumber(cx, &lineNumber);
+
+      if (!fileNameUTF16.IsEmpty()) {
+        NS_ConvertUTF16toUTF8 fileName(fileNameUTF16);
+        stack += "js(";
+        if (!origin.IsEmpty()) {
+          // Make the file name root-relative for conciseness if possible.
+          const char* originData;
+          uint32_t originLen;
+
+          originLen = origin.GetData(&originData);
+          // If fileName starts with origin + "/", cut up to that "/".
+          if (fileName.Length() >= originLen + 1 &&
+              memcmp(fileName.get(), originData, originLen) == 0 &&
+              fileName[originLen] == '/') {
+            fileName.Cut(0, originLen);
+          }
+        }
+        fileName.ReplaceChar('/', '\\');
+        stack += fileName;
+        if (lineNumber > 0) {
+          stack += ", line=";
+          stack.AppendInt(lineNumber);
+        }
+        stack += ")/";
+      }
+
+      nsCOMPtr<nsIStackFrame> caller;
+      nsresult rv = frame->GetCaller(cx, getter_AddRefs(caller));
+      NS_ENSURE_SUCCESS_VOID(rv);
+      caller.swap(frame);
+    }
+  }
+
+ private:
+  ~BlobURLsReporter() {}
+
+  static void BuildPath(nsAutoCString& path,
+                        nsCStringHashKey::KeyType aKey,
+                        DataInfo* aInfo,
+                        bool anonymize)
+  {
+    nsCOMPtr<nsIURI> principalURI;
+    nsAutoCString url, owner;
+    if (NS_SUCCEEDED(aInfo->mPrincipal->GetURI(getter_AddRefs(principalURI))) &&
+        principalURI != nullptr &&
+        NS_SUCCEEDED(principalURI->GetSpec(owner)) &&
+        !owner.IsEmpty()) {
+      owner.ReplaceChar('/', '\\');
+      path += "owner(";
+      if (anonymize) {
+        path += "<anonymized>";
+      } else {
+        path += owner;
+      }
+      path += ")";
+    } else {
+      path += "owner unknown";
+    }
+    path += "/";
+    if (anonymize) {
+      path += "<anonymized-stack>";
+    } else {
+      path += aInfo->mStack;
+    }
+    url = aKey;
+    url.ReplaceChar('/', '\\');
+    if (anonymize) {
+      path += "<anonymized-url>";
+    } else {
+      path += url;
+    }
+  }
+};
+
+NS_IMPL_ISUPPORTS(BlobURLsReporter, nsIMemoryReporter)
+
+class ReleasingTimerHolder final : public nsITimerCallback
+{
+public:
+  NS_DECL_ISUPPORTS
+
+  static void
+  Create(nsTArray<nsWeakPtr>&& aArray)
+  {
+    RefPtr<ReleasingTimerHolder> holder = new ReleasingTimerHolder(Move(aArray));
+    holder->mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+
+    // If we are shutting down, we are not able to create a timer.
+    if (!holder->mTimer) {
+      return;
+    }
+
+    nsresult rv = holder->mTimer->InitWithCallback(holder, RELEASING_TIMER,
+                                                   nsITimer::TYPE_ONE_SHOT);
+    NS_ENSURE_SUCCESS_VOID(rv);
+  }
+
+  NS_IMETHOD
+  Notify(nsITimer* aTimer) override
+  {
+    for (uint32_t i = 0; i < mURIs.Length(); ++i) {
+      nsCOMPtr<nsIURI> uri = do_QueryReferent(mURIs[i]);
+      if (uri) {
+        static_cast<nsHostObjectURI*>(uri.get())->ForgetBlobImpl();
+      }
+    }
+
+    return NS_OK;
+  }
+
+private:
+  explicit ReleasingTimerHolder(nsTArray<nsWeakPtr>&& aArray)
+    : mURIs(aArray)
+  {}
+
+  ~ReleasingTimerHolder()
+  {}
+
+  nsTArray<nsWeakPtr> mURIs;
+  nsCOMPtr<nsITimer> mTimer;
+};
+
+NS_IMPL_ISUPPORTS(ReleasingTimerHolder, nsITimerCallback)
+
+} // namespace mozilla
+
+template<typename T>
+static nsresult
+AddDataEntryInternal(const nsACString& aURI, T aObject,
+                     nsIPrincipal* aPrincipal)
+{
+  if (!gDataTable) {
+    gDataTable = new nsClassHashtable<nsCStringHashKey, DataInfo>;
+  }
+
+  DataInfo* info = new DataInfo(aObject, aPrincipal);
+  mozilla::BlobURLsReporter::GetJSStackForBlob(info);
+
+  gDataTable->Put(aURI, info);
+  return NS_OK;
+}
+
+void
+nsHostObjectProtocolHandler::Init(void)
+{
+  static bool initialized = false;
+
+  if (!initialized) {
+    initialized = true;
+    RegisterStrongMemoryReporter(new mozilla::HostObjectURLsReporter());
+    RegisterStrongMemoryReporter(new mozilla::BlobURLsReporter());
+  }
+}
+
+nsHostObjectProtocolHandler::nsHostObjectProtocolHandler()
+{
+  Init();
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::AddDataEntry(BlobImpl* aBlobImpl,
+                                          nsIPrincipal* aPrincipal,
+                                          nsACString& aUri)
+{
+  Init();
+
+  nsresult rv = GenerateURIStringForBlobURL(aPrincipal, aUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = AddDataEntryInternal(aUri, aBlobImpl, aPrincipal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mozilla::BroadcastBlobURLRegistration(aUri, aBlobImpl, aPrincipal);
+  return NS_OK;
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::AddDataEntry(DOMMediaStream* aMediaStream,
+                                          nsIPrincipal* aPrincipal,
+                                          nsACString& aUri)
+{
+  Init();
+
+  nsresult rv = GenerateURIStringForBlobURL(aPrincipal, aUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = AddDataEntryInternal(aUri, aMediaStream, aPrincipal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::AddDataEntry(MediaSource* aMediaSource,
+                                          nsIPrincipal* aPrincipal,
+                                          nsACString& aUri)
+{
+  Init();
+
+  nsresult rv = GenerateURIStringForBlobURL(aPrincipal, aUri);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = AddDataEntryInternal(aUri, aMediaSource, aPrincipal);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::AddDataEntry(const nsACString& aURI,
+                                          nsIPrincipal* aPrincipal,
+                                          mozilla::dom::BlobImpl* aBlobImpl)
+{
+  return AddDataEntryInternal(aURI, aBlobImpl, aPrincipal);
+}
+
+/* static */ bool
+nsHostObjectProtocolHandler::GetAllBlobURLEntries(
+  nsTArray<mozilla::dom::BlobURLRegistrationData>& aRegistrations,
+  mozilla::dom::ContentParent* aCP)
+{
+  MOZ_ASSERT(aCP);
+
+  if (!gDataTable) {
+    return true;
+  }
+
+  for (auto iter = gDataTable->ConstIter(); !iter.Done(); iter.Next()) {
+    DataInfo* info = iter.UserData();
+    MOZ_ASSERT(info);
+
+    if (info->mObjectType != DataInfo::eBlobImpl) {
+      continue;
+    }
+
+    MOZ_ASSERT(info->mBlobImpl);
+    mozilla::dom::PBlobParent* blobParent =
+      aCP->GetOrCreateActorForBlobImpl(info->mBlobImpl);
+    if (!blobParent) {
+      return false;
+    }
+
+    aRegistrations.AppendElement(mozilla::dom::BlobURLRegistrationData(
+      nsCString(iter.Key()), blobParent, nullptr,
+      IPC::Principal(info->mPrincipal)));
+  }
+
+  return true;
+}
+
+/*static */ void
+nsHostObjectProtocolHandler::RemoveDataEntry(const nsACString& aUri,
+                                             bool aBroadcastToOtherProcesses)
+{
+  if (!gDataTable) {
+    return;
+  }
+
+  DataInfo* info = GetDataInfo(aUri);
+  if (!info) {
+    return;
+  }
+
+  if (aBroadcastToOtherProcesses && info->mObjectType == DataInfo::eBlobImpl) {
+    mozilla::BroadcastBlobURLUnregistration(aUri, info);
+  }
+
+  if (!info->mURIs.IsEmpty()) {
+    mozilla::ReleasingTimerHolder::Create(Move(info->mURIs));
+  }
+
+  gDataTable->Remove(aUri);
+  if (gDataTable->Count() == 0) {
+    delete gDataTable;
+    gDataTable = nullptr;
+  }
+}
+
+/* static */ void
+nsHostObjectProtocolHandler::RemoveDataEntries()
+{
+  MOZ_ASSERT(XRE_IsContentProcess());
+
+  if (!gDataTable) {
+    return;
+  }
+
+  gDataTable->Clear();
+  delete gDataTable;
+  gDataTable = nullptr;
+}
+
+/* static */ bool
+nsHostObjectProtocolHandler::HasDataEntry(const nsACString& aUri)
+{
+  return !!GetDataInfo(aUri);
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::GenerateURIString(const nsACString &aScheme,
+                                               nsIPrincipal* aPrincipal,
+                                               nsACString& aUri)
+{
+  nsresult rv;
+  nsCOMPtr<nsIUUIDGenerator> uuidgen =
+    do_GetService("@mozilla.org/uuid-generator;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsID id;
+  rv = uuidgen->GenerateUUIDInPlace(&id);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  char chars[NSID_LENGTH];
+  id.ToProvidedString(chars);
+
+  aUri = aScheme;
+  aUri.Append(':');
+
+  if (aPrincipal) {
+    nsAutoCString origin;
+    rv = nsContentUtils::GetASCIIOrigin(aPrincipal, origin);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    aUri.Append(origin);
+    aUri.Append('/');
+  }
+
+  aUri += Substring(chars + 1, chars + NSID_LENGTH - 2);
+
+  return NS_OK;
+}
+
+/* static */ nsresult
+nsHostObjectProtocolHandler::GenerateURIStringForBlobURL(nsIPrincipal* aPrincipal,
+                                                         nsACString& aUri)
+{
+  return
+    GenerateURIString(NS_LITERAL_CSTRING(BLOBURI_SCHEME), aPrincipal, aUri);
+}
+
+/* static */ nsIPrincipal*
+nsHostObjectProtocolHandler::GetDataEntryPrincipal(const nsACString& aUri)
+{
+  if (!gDataTable) {
+    return nullptr;
+  }
+
+  DataInfo* res = GetDataInfo(aUri);
+
+  if (!res) {
+    return nullptr;
+  }
+
+  return res->mPrincipal;
+}
+
+/* static */ void
+nsHostObjectProtocolHandler::Traverse(const nsACString& aUri,
+                                      nsCycleCollectionTraversalCallback& aCallback)
+{
+  if (!gDataTable) {
+    return;
+  }
+
+  DataInfo* res;
+  gDataTable->Get(aUri, &res);
+  if (!res) {
+    return;
+  }
+
+  NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCallback, "HostObjectProtocolHandler DataInfo.mBlobImpl");
+  aCallback.NoteXPCOMChild(res->mBlobImpl);
+
+  NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCallback, "HostObjectProtocolHandler DataInfo.mMediaSource");
+  aCallback.NoteXPCOMChild(res->mMediaSource);
+
+  NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCallback, "HostObjectProtocolHandler DataInfo.mMediaStream");
+  aCallback.NoteXPCOMChild(res->mMediaStream);
+}
+
+// -----------------------------------------------------------------------
+// Protocol handler
+
+NS_IMPL_ISUPPORTS(nsHostObjectProtocolHandler, nsIProtocolHandler)
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::GetDefaultPort(int32_t *result)
+{
+  *result = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::GetProtocolFlags(uint32_t *result)
+{
+  *result = URI_NORELATIVE | URI_NOAUTH | URI_LOADABLE_BY_SUBSUMERS |
+            URI_NON_PERSISTABLE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::GetFlagsForURI(nsIURI *aURI, uint32_t *aResult)
+{
+  Unused << nsHostObjectProtocolHandler::GetProtocolFlags(aResult);
+  if (IsFontTableURI(aURI) || IsBlobURI(aURI)) {
+    *aResult |= URI_IS_LOCAL_RESOURCE;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBlobProtocolHandler::GetProtocolFlags(uint32_t *result)
+{
+  Unused << nsHostObjectProtocolHandler::GetProtocolFlags(result);
+  *result |= URI_IS_LOCAL_RESOURCE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::NewURI(const nsACString& aSpec,
+                                    const char *aCharset,
+                                    nsIURI *aBaseURI,
+                                    nsIURI **aResult)
+{
+  *aResult = nullptr;
+  nsresult rv;
+
+  DataInfo* info = GetDataInfo(aSpec);
+
+  RefPtr<nsHostObjectURI> uri;
+  if (info && info->mObjectType == DataInfo::eBlobImpl) {
+    MOZ_ASSERT(info->mBlobImpl);
+    uri = new nsHostObjectURI(info->mPrincipal, info->mBlobImpl);
+  } else {
+    uri = new nsHostObjectURI(nullptr, nullptr);
+  }
+
+  rv = uri->SetSpec(aSpec);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_TryToSetImmutable(uri);
+  uri.forget(aResult);
+
+  if (info && info->mObjectType == DataInfo::eBlobImpl) {
+    info->mURIs.AppendElement(do_GetWeakReference(*aResult));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::NewChannel2(nsIURI* uri,
+                                         nsILoadInfo* aLoadInfo,
+                                         nsIChannel** result)
+{
+  *result = nullptr;
+
+  nsCOMPtr<nsIURIWithBlobImpl> uriBlobImpl = do_QueryInterface(uri);
+  if (!uriBlobImpl) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+  nsCOMPtr<nsISupports> tmp;
+  MOZ_ALWAYS_SUCCEEDS(uriBlobImpl->GetBlobImpl(getter_AddRefs(tmp)));
+  nsCOMPtr<BlobImpl> blobImpl = do_QueryInterface(tmp);
+  if (!blobImpl) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+#ifdef DEBUG
+  DataInfo* info = GetDataInfoFromURI(uri);
+
+  // Info can be null, in case this blob URL has been revoked already.
+  if (info) {
+    nsCOMPtr<nsIURIWithPrincipal> uriPrinc = do_QueryInterface(uri);
+    nsCOMPtr<nsIPrincipal> principal;
+    uriPrinc->GetPrincipal(getter_AddRefs(principal));
+    NS_ASSERTION(info->mPrincipal == principal, "Wrong principal!");
+  }
+#endif
+
+  ErrorResult rv;
+  nsCOMPtr<nsIInputStream> stream;
+  blobImpl->GetInternalStream(getter_AddRefs(stream), rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  nsAutoString contentType;
+  blobImpl->GetType(contentType);
+
+  nsCOMPtr<nsIChannel> channel;
+  rv = NS_NewInputStreamChannelInternal(getter_AddRefs(channel),
+                                        uri,
+                                        stream,
+                                        NS_ConvertUTF16toUTF8(contentType),
+                                        EmptyCString(), // aContentCharset
+                                        aLoadInfo);
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  if (blobImpl->IsFile()) {
+    nsString filename;
+    blobImpl->GetName(filename);
+    channel->SetContentDispositionFilename(filename);
+  }
+
+  uint64_t size = blobImpl->GetSize(rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  channel->SetOriginalURI(uri);
+  channel->SetContentType(NS_ConvertUTF16toUTF8(contentType));
+  channel->SetContentLength(size);
+
+  channel.forget(result);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::NewChannel(nsIURI* uri, nsIChannel* *result)
+{
+  return NewChannel2(uri, nullptr, result);
+}
+
+NS_IMETHODIMP
+nsHostObjectProtocolHandler::AllowPort(int32_t port, const char *scheme,
+                                       bool *_retval)
+{
+  // don't override anything.
+  *_retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBlobProtocolHandler::GetScheme(nsACString &result)
+{
+  result.AssignLiteral(BLOBURI_SCHEME);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFontTableProtocolHandler::GetProtocolFlags(uint32_t *result)
+{
+  Unused << nsHostObjectProtocolHandler::GetProtocolFlags(result);
+  *result |= URI_IS_LOCAL_RESOURCE;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFontTableProtocolHandler::GetScheme(nsACString &result)
+{
+  result.AssignLiteral(FONTTABLEURI_SCHEME);
+  return NS_OK;
+}
+
+nsresult
+NS_GetBlobForBlobURI(nsIURI* aURI, BlobImpl** aBlob)
+{
+  NS_ASSERTION(IsBlobURI(aURI), "Only call this with blob URIs");
+
+  *aBlob = nullptr;
+
+  DataInfo* info = GetDataInfoFromURI(aURI);
+  if (!info || info->mObjectType != DataInfo::eBlobImpl) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+  RefPtr<BlobImpl> blob = info->mBlobImpl;
+  blob.forget(aBlob);
+  return NS_OK;
+}
+
+nsresult
+NS_GetBlobForBlobURISpec(const nsACString& aSpec, BlobImpl** aBlob)
+{
+  *aBlob = nullptr;
+
+  DataInfo* info = GetDataInfo(aSpec);
+  if (!info || info->mObjectType != DataInfo::eBlobImpl) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+  RefPtr<BlobImpl> blob = info->mBlobImpl;
+  blob.forget(aBlob);
+  return NS_OK;
+}
+
+nsresult
+NS_GetStreamForBlobURI(nsIURI* aURI, nsIInputStream** aStream)
+{
+  RefPtr<BlobImpl> blobImpl;
+  ErrorResult rv;
+  rv = NS_GetBlobForBlobURI(aURI, getter_AddRefs(blobImpl));
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  blobImpl->GetInternalStream(aStream, rv);
+  if (NS_WARN_IF(rv.Failed())) {
+    return rv.StealNSResult();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+NS_GetStreamForMediaStreamURI(nsIURI* aURI, mozilla::DOMMediaStream** aStream)
+{
+  NS_ASSERTION(IsMediaStreamURI(aURI), "Only call this with mediastream URIs");
+
+  DataInfo* info = GetDataInfoFromURI(aURI);
+  if (!info || info->mObjectType != DataInfo::eMediaStream) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+  RefPtr<DOMMediaStream> mediaStream = info->mMediaStream;
+  mediaStream.forget(aStream);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsFontTableProtocolHandler::NewURI(const nsACString& aSpec,
+                                   const char *aCharset,
+                                   nsIURI *aBaseURI,
+                                   nsIURI **aResult)
+{
+  RefPtr<nsIURI> uri;
+
+  // Either you got here via a ref or a fonttable: uri
+  if (aSpec.Length() && aSpec.CharAt(0) == '#') {
+    nsresult rv = aBaseURI->CloneIgnoringRef(getter_AddRefs(uri));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    uri->SetRef(aSpec);
+  } else {
+    // Relative URIs (other than #ref) are not meaningful within the
+    // fonttable: scheme.
+    // If aSpec is a relative URI -other- than a bare #ref,
+    // this will leave uri empty, and we'll return a failure code below.
+    uri = new mozilla::net::nsSimpleURI();
+    nsresult rv = uri->SetSpec(aSpec);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  bool schemeIs;
+  if (NS_FAILED(uri->SchemeIs(FONTTABLEURI_SCHEME, &schemeIs)) || !schemeIs) {
+    NS_WARNING("Non-fonttable spec in nsFontTableProtocolHander");
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  uri.forget(aResult);
+  return NS_OK;
+}
+
+nsresult
+NS_GetSourceForMediaSourceURI(nsIURI* aURI, mozilla::dom::MediaSource** aSource)
+{
+  NS_ASSERTION(IsMediaSourceURI(aURI), "Only call this with mediasource URIs");
+
+  *aSource = nullptr;
+
+  DataInfo* info = GetDataInfoFromURI(aURI);
+  if (!info || info->mObjectType != DataInfo::eMediaSource) {
+    return NS_ERROR_DOM_BAD_URI;
+  }
+
+  RefPtr<MediaSource> mediaSource = info->mMediaSource;
+  mediaSource.forget(aSource);
+  return NS_OK;
+}
+
+#define NS_BLOBPROTOCOLHANDLER_CID \
+{ 0xb43964aa, 0xa078, 0x44b2, \
+  { 0xb0, 0x6b, 0xfd, 0x4d, 0x1b, 0x17, 0x2e, 0x66 } }
+
+#define NS_FONTTABLEPROTOCOLHANDLER_CID \
+{ 0x3fc8f04e, 0xd719, 0x43ca, \
+  { 0x9a, 0xd0, 0x18, 0xee, 0x32, 0x02, 0x11, 0xf2 } }
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsBlobProtocolHandler)
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsFontTableProtocolHandler)
+
+NS_DEFINE_NAMED_CID(NS_BLOBPROTOCOLHANDLER_CID);
+NS_DEFINE_NAMED_CID(NS_FONTTABLEPROTOCOLHANDLER_CID);
+
+static const mozilla::Module::CIDEntry kHostObjectProtocolHandlerCIDs[] = {
+  { &kNS_BLOBPROTOCOLHANDLER_CID, false, nullptr, nsBlobProtocolHandlerConstructor },
+  { &kNS_FONTTABLEPROTOCOLHANDLER_CID, false, nullptr, nsFontTableProtocolHandlerConstructor },
+  { nullptr }
+};
+
+static const mozilla::Module::ContractIDEntry kHostObjectProtocolHandlerContracts[] = {
+  { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX BLOBURI_SCHEME, &kNS_BLOBPROTOCOLHANDLER_CID },
+  { NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX FONTTABLEURI_SCHEME, &kNS_FONTTABLEPROTOCOLHANDLER_CID },
+  { nullptr }
+};
+
+static const mozilla::Module kHostObjectProtocolHandlerModule = {
+  mozilla::Module::kVersion,
+  kHostObjectProtocolHandlerCIDs,
+  kHostObjectProtocolHandlerContracts
+};
+
+NSMODULE_DEFN(HostObjectProtocolHandler) = &kHostObjectProtocolHandlerModule;
+
+bool IsType(nsIURI* aUri, DataInfo::ObjectType aType)
+{
+  DataInfo* info = GetDataInfoFromURI(aUri);
+  if (!info) {
+    return false;
+  }
+
+  return info->mObjectType == aType;
+}
+
+bool IsBlobURI(nsIURI* aUri)
+{
+  return IsType(aUri, DataInfo::eBlobImpl);
+}
+
+bool IsMediaStreamURI(nsIURI* aUri)
+{
+  return IsType(aUri, DataInfo::eMediaStream);
+}
+
+bool IsMediaSourceURI(nsIURI* aUri)
+{
+  return IsType(aUri, DataInfo::eMediaSource);
+}