import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

dom/base/ImportManager.cpp

@@ -0,0 +1,748 @@
+/* -*- 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 "ImportManager.h"
+
+#include "mozilla/EventListenerManager.h"
+#include "HTMLLinkElement.h"
+#include "nsContentPolicyUtils.h"
+#include "nsContentUtils.h"
+#include "nsIChannel.h"
+#include "nsIContentPolicy.h"
+#include "nsIContentSecurityPolicy.h"
+#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
+#include "nsIDOMEvent.h"
+#include "nsIPrincipal.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsScriptLoader.h"
+#include "nsNetUtil.h"
+
+//-----------------------------------------------------------------------------
+// AutoError
+//-----------------------------------------------------------------------------
+
+class AutoError {
+public:
+  explicit AutoError(mozilla::dom::ImportLoader* loader, bool scriptsBlocked = true)
+    : mLoader(loader)
+    , mPassed(false)
+    , mScriptsBlocked(scriptsBlocked)
+  {}
+
+  ~AutoError()
+  {
+    if (!mPassed) {
+      mLoader->Error(mScriptsBlocked);
+    }
+  }
+
+  void Pass() { mPassed = true; }
+
+private:
+  mozilla::dom::ImportLoader* mLoader;
+  bool mPassed;
+  bool mScriptsBlocked;
+};
+
+namespace mozilla {
+namespace dom {
+
+//-----------------------------------------------------------------------------
+// ImportLoader::Updater
+//-----------------------------------------------------------------------------
+
+void
+ImportLoader::Updater::GetReferrerChain(nsINode* aNode,
+                                        nsTArray<nsINode*>& aResult)
+{
+  // We fill up the array backward. First the last link: aNode.
+  MOZ_ASSERT(mLoader->mLinks.Contains(aNode));
+
+  aResult.AppendElement(aNode);
+  nsINode* node = aNode;
+  RefPtr<ImportManager> manager = mLoader->Manager();
+  for (ImportLoader* referrersLoader = manager->Find(node->OwnerDoc());
+       referrersLoader;
+       referrersLoader = manager->Find(node->OwnerDoc()))
+  {
+    // Then walking up the main referrer chain and append each link
+    // to the array.
+    node = referrersLoader->GetMainReferrer();
+    MOZ_ASSERT(node);
+    aResult.AppendElement(node);
+  }
+
+  // The reversed order is more useful for consumers.
+  // XXX: This should probably go to nsTArray or some generic utility
+  // lib for our containers that we don't have... I would really like to
+  // get rid of this part...
+  uint32_t l = aResult.Length();
+  for (uint32_t i = 0; i < l / 2; i++) {
+    Swap(aResult[i], aResult[l - i - 1]);
+  }
+}
+
+bool
+ImportLoader::Updater::ShouldUpdate(nsTArray<nsINode*>& aNewPath)
+{
+  if (mLoader->Manager()->GetNearestPredecessor(mLoader->GetMainReferrer()) !=
+      mLoader->mBlockingPredecessor) {
+    return true;
+  }
+  // Let's walk down on the main referrer chains of both the current main and
+  // the new link, and find the last pair of links that are from the same
+  // document. This is the junction point between the two referrer chain. Their
+  // order in the subimport list of that document will determine if we have to
+  // update the spanning tree or this new edge changes nothing in the script
+  // execution order.
+  nsTArray<nsINode*> oldPath;
+  GetReferrerChain(mLoader->mLinks[mLoader->mMainReferrer], oldPath);
+  uint32_t max = std::min(oldPath.Length(), aNewPath.Length());
+  MOZ_ASSERT(max > 0);
+  uint32_t lastCommonImportAncestor = 0;
+
+  for (uint32_t i = 0;
+       i < max && oldPath[i]->OwnerDoc() == aNewPath[i]->OwnerDoc();
+       i++)
+  {
+    lastCommonImportAncestor = i;
+  }
+
+  MOZ_ASSERT(lastCommonImportAncestor < max);
+  nsINode* oldLink = oldPath[lastCommonImportAncestor];
+  nsINode* newLink = aNewPath[lastCommonImportAncestor];
+
+  if ((lastCommonImportAncestor == max - 1) &&
+      newLink == oldLink ) {
+    // If one chain contains the other entirely, then this is a simple cycle,
+    // nothing to be done here.
+    MOZ_ASSERT(oldPath.Length() != aNewPath.Length(),
+               "This would mean that new link == main referrer link");
+    return false;
+  }
+
+  MOZ_ASSERT(aNewPath != oldPath,
+             "How could this happen?");
+  nsIDocument* doc = oldLink->OwnerDoc();
+  MOZ_ASSERT(doc->HasSubImportLink(newLink));
+  MOZ_ASSERT(doc->HasSubImportLink(oldLink));
+
+  return doc->IndexOfSubImportLink(newLink) < doc->IndexOfSubImportLink(oldLink);
+}
+
+void
+ImportLoader::Updater::UpdateMainReferrer(uint32_t aNewIdx)
+{
+  MOZ_ASSERT(aNewIdx < mLoader->mLinks.Length());
+  nsINode* newMainReferrer = mLoader->mLinks[aNewIdx];
+
+  // This new link means we have to execute our scripts sooner...
+  // Let's make sure that unblocking a loader does not trigger a script execution.
+  // So we start with placing the new blockers and only then will we remove any
+  // blockers.
+  if (mLoader->IsBlocking()) {
+    // Our import parent is changed, let's block the new one and later unblock
+    // the old one.
+    newMainReferrer->OwnerDoc()->
+      ScriptLoader()->AddParserBlockingScriptExecutionBlocker();
+    newMainReferrer->OwnerDoc()->BlockDOMContentLoaded();
+  }
+
+  if (mLoader->mDocument) {
+    // Our nearest predecessor has changed. So let's add the ScriptLoader to the
+    // new one if there is any. And remove it from the old one.
+    RefPtr<ImportManager> manager = mLoader->Manager();
+    nsScriptLoader* loader = mLoader->mDocument->ScriptLoader();
+    ImportLoader*& pred = mLoader->mBlockingPredecessor;
+    ImportLoader* newPred = manager->GetNearestPredecessor(newMainReferrer);
+    if (pred) {
+      if (newPred) {
+        newPred->AddBlockedScriptLoader(loader);
+      }
+      pred->RemoveBlockedScriptLoader(loader);
+    }
+  }
+
+  if (mLoader->IsBlocking()) {
+    mLoader->mImportParent->
+      ScriptLoader()->RemoveParserBlockingScriptExecutionBlocker();
+    mLoader->mImportParent->UnblockDOMContentLoaded();
+  }
+
+  // Finally update mMainReferrer to point to the newly added link.
+  mLoader->mMainReferrer = aNewIdx;
+  mLoader->mImportParent = newMainReferrer->OwnerDoc();
+}
+
+nsINode*
+ImportLoader::Updater::NextDependant(nsINode* aCurrentLink,
+                                     nsTArray<nsINode*>& aPath,
+                                     NodeTable& aVisitedNodes, bool aSkipChildren)
+{
+  // Depth first graph traversal.
+  if (!aSkipChildren) {
+    // "first child"
+    ImportLoader* loader = mLoader->Manager()->Find(aCurrentLink);
+    if (loader && loader->GetDocument()) {
+      nsINode* firstSubImport = loader->GetDocument()->GetSubImportLink(0);
+      if (firstSubImport && !aVisitedNodes.Contains(firstSubImport)) {
+        aPath.AppendElement(aCurrentLink);
+        aVisitedNodes.PutEntry(firstSubImport);
+        return firstSubImport;
+      }
+    }
+  }
+
+  aPath.AppendElement(aCurrentLink);
+  // "(parent's) next sibling"
+  while(aPath.Length() > 1) {
+    aCurrentLink = aPath[aPath.Length() - 1];
+    aPath.RemoveElementAt(aPath.Length() - 1);
+
+    // Let's find the next "sibling"
+    ImportLoader* loader =  mLoader->Manager()->Find(aCurrentLink->OwnerDoc());
+    MOZ_ASSERT(loader && loader->GetDocument(), "How can this happend?");
+    nsIDocument* doc = loader->GetDocument();
+    MOZ_ASSERT(doc->HasSubImportLink(aCurrentLink));
+    uint32_t idx = doc->IndexOfSubImportLink(aCurrentLink);
+    nsINode* next = doc->GetSubImportLink(idx + 1);
+    if (next) {
+      // Note: If we found an already visited link that means the parent links has
+      // closed the circle it's always the "first child" section that should find
+      // the first already visited node. Let's just assert that.
+      MOZ_ASSERT(!aVisitedNodes.Contains(next));
+      aVisitedNodes.PutEntry(next);
+      return next;
+    }
+  }
+
+  return nullptr;
+}
+
+void
+ImportLoader::Updater::UpdateDependants(nsINode* aNode,
+                                        nsTArray<nsINode*>& aPath)
+{
+  NodeTable visitedNodes;
+  nsINode* current = aNode;
+  uint32_t initialLength = aPath.Length();
+  bool neededUpdate = true;
+  while ((current = NextDependant(current, aPath, visitedNodes, !neededUpdate))) {
+    if (!current || aPath.Length() <= initialLength) {
+      break;
+    }
+    ImportLoader* loader = mLoader->Manager()->Find(current);
+    if (!loader) {
+      continue;
+    }
+    Updater& updater = loader->mUpdater;
+    neededUpdate = updater.ShouldUpdate(aPath);
+    if (neededUpdate) {
+      updater.UpdateMainReferrer(loader->mLinks.IndexOf(current));
+    }
+  }
+}
+
+void
+ImportLoader::Updater::UpdateSpanningTree(nsINode* aNode)
+{
+  if (mLoader->mReady || mLoader->mStopped) {
+    // Scripts already executed, nothing to be done here.
+    return;
+  }
+
+  if (mLoader->mLinks.Length() == 1) {
+    // If this is the first referrer, let's mark it.
+    mLoader->mMainReferrer = 0;
+    return;
+  }
+
+  nsTArray<nsINode*> newReferrerChain;
+  GetReferrerChain(aNode, newReferrerChain);
+  if (ShouldUpdate(newReferrerChain)) {
+    UpdateMainReferrer(mLoader->mLinks.Length() - 1);
+    UpdateDependants(aNode, newReferrerChain);
+  }
+}
+
+//-----------------------------------------------------------------------------
+// ImportLoader
+//-----------------------------------------------------------------------------
+
+NS_INTERFACE_MAP_BEGIN(ImportLoader)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
+  NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
+  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(ImportLoader)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ImportLoader)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ImportLoader)
+
+NS_IMPL_CYCLE_COLLECTION(ImportLoader,
+                         mDocument,
+                         mImportParent,
+                         mLinks)
+
+ImportLoader::ImportLoader(nsIURI* aURI, nsIDocument* aImportParent)
+  : mURI(aURI)
+  , mImportParent(aImportParent)
+  , mBlockingPredecessor(nullptr)
+  , mReady(false)
+  , mStopped(false)
+  , mBlockingScripts(false)
+  , mUpdater(this)
+{
+}
+
+void
+ImportLoader::BlockScripts()
+{
+  MOZ_ASSERT(!mBlockingScripts);
+  mImportParent->ScriptLoader()->AddParserBlockingScriptExecutionBlocker();
+  mImportParent->BlockDOMContentLoaded();
+  mBlockingScripts = true;
+}
+
+void
+ImportLoader::UnblockScripts()
+{
+  MOZ_ASSERT(mBlockingScripts);
+  mImportParent->ScriptLoader()->RemoveParserBlockingScriptExecutionBlocker();
+  mImportParent->UnblockDOMContentLoaded();
+  for (uint32_t i = 0; i < mBlockedScriptLoaders.Length(); i++) {
+    mBlockedScriptLoaders[i]->RemoveParserBlockingScriptExecutionBlocker();
+  }
+  mBlockedScriptLoaders.Clear();
+  mBlockingScripts = false;
+}
+
+void
+ImportLoader::SetBlockingPredecessor(ImportLoader* aLoader)
+{
+  mBlockingPredecessor = aLoader;
+}
+
+void
+ImportLoader::DispatchEventIfFinished(nsINode* aNode)
+{
+  MOZ_ASSERT(!(mReady && mStopped));
+  if (mReady) {
+    DispatchLoadEvent(aNode);
+  }
+  if (mStopped) {
+    DispatchErrorEvent(aNode);
+  }
+}
+
+void
+ImportLoader::AddBlockedScriptLoader(nsScriptLoader* aScriptLoader)
+{
+  if (mBlockedScriptLoaders.Contains(aScriptLoader)) {
+    return;
+  }
+
+  aScriptLoader->AddParserBlockingScriptExecutionBlocker();
+
+  // Let's keep track of the pending script loaders.
+  mBlockedScriptLoaders.AppendElement(aScriptLoader);
+}
+
+bool
+ImportLoader::RemoveBlockedScriptLoader(nsScriptLoader* aScriptLoader)
+{
+  aScriptLoader->RemoveParserBlockingScriptExecutionBlocker();
+  return mBlockedScriptLoaders.RemoveElement(aScriptLoader);
+}
+
+void
+ImportLoader::AddLinkElement(nsINode* aNode)
+{
+  // If a new link element is added to the import tree that
+  // refers to an import that is already finished loading or
+  // stopped trying, we need to fire the corresponding event
+  // on it.
+  mLinks.AppendElement(aNode);
+  mUpdater.UpdateSpanningTree(aNode);
+  DispatchEventIfFinished(aNode);
+}
+
+void
+ImportLoader::RemoveLinkElement(nsINode* aNode)
+{
+  mLinks.RemoveElement(aNode);
+}
+
+// Events has to be fired with a script runner, so mImport can
+// be set on the link element before the load event is fired even
+// if ImportLoader::Get returns an already loaded import and we
+// fire the load event immediately on the new referring link element.
+class AsyncEvent : public Runnable {
+public:
+  AsyncEvent(nsINode* aNode, bool aSuccess)
+    : mNode(aNode)
+    , mSuccess(aSuccess)
+  {
+    MOZ_ASSERT(mNode);
+  }
+
+  NS_IMETHOD Run() override {
+    return nsContentUtils::DispatchTrustedEvent(mNode->OwnerDoc(),
+                                                mNode,
+                                                mSuccess ? NS_LITERAL_STRING("load")
+                                                         : NS_LITERAL_STRING("error"),
+                                                /* aCanBubble = */ false,
+                                                /* aCancelable = */ false);
+  }
+
+private:
+  nsCOMPtr<nsINode> mNode;
+  bool mSuccess;
+};
+
+void
+ImportLoader::DispatchErrorEvent(nsINode* aNode)
+{
+  nsContentUtils::AddScriptRunner(new AsyncEvent(aNode, /* aSuccess = */ false));
+}
+
+void
+ImportLoader::DispatchLoadEvent(nsINode* aNode)
+{
+  nsContentUtils::AddScriptRunner(new AsyncEvent(aNode, /* aSuccess = */ true));
+}
+
+void
+ImportLoader::Done()
+{
+  mReady = true;
+  uint32_t l = mLinks.Length();
+  for (uint32_t i = 0; i < l; i++) {
+    DispatchLoadEvent(mLinks[i]);
+  }
+  UnblockScripts();
+  ReleaseResources();
+}
+
+void
+ImportLoader::Error(bool aUnblockScripts)
+{
+  mDocument = nullptr;
+  mStopped = true;
+  uint32_t l = mLinks.Length();
+  for (uint32_t i = 0; i < l; i++) {
+    DispatchErrorEvent(mLinks[i]);
+  }
+  if (aUnblockScripts) {
+    UnblockScripts();
+  }
+  ReleaseResources();
+}
+
+// Release all the resources we don't need after there is no more
+// data available on the channel, and the parser is done.
+void ImportLoader::ReleaseResources()
+{
+  mParserStreamListener = nullptr;
+  mImportParent = nullptr;
+}
+
+nsIPrincipal*
+ImportLoader::Principal()
+{
+  MOZ_ASSERT(mImportParent);
+  nsCOMPtr<nsIDocument> master = mImportParent->MasterDocument();
+  nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(master);
+  MOZ_ASSERT(sop);
+  return sop->GetPrincipal();
+}
+
+void
+ImportLoader::Open()
+{
+  AutoError ae(this, false);
+
+  nsCOMPtr<nsILoadGroup> loadGroup =
+    mImportParent->MasterDocument()->GetDocumentLoadGroup();
+
+  nsCOMPtr<nsIChannel> channel;
+  nsresult rv = NS_NewChannel(getter_AddRefs(channel),
+                              mURI,
+                              mImportParent,
+                              nsILoadInfo::SEC_REQUIRE_CORS_DATA_INHERITS,
+                              nsIContentPolicy::TYPE_SUBDOCUMENT,
+                              loadGroup,
+                              nullptr,  // aCallbacks
+                              nsIRequest::LOAD_BACKGROUND);
+
+  NS_ENSURE_SUCCESS_VOID(rv);
+  rv = channel->AsyncOpen2(this);
+  NS_ENSURE_SUCCESS_VOID(rv);
+
+  BlockScripts();
+  ae.Pass();
+}
+
+NS_IMETHODIMP
+ImportLoader::OnDataAvailable(nsIRequest* aRequest,
+                              nsISupports* aContext,
+                              nsIInputStream* aStream,
+                              uint64_t aOffset,
+                              uint32_t aCount)
+{
+  MOZ_ASSERT(mParserStreamListener);
+
+  AutoError ae(this);
+  nsresult rv;
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  rv = mParserStreamListener->OnDataAvailable(channel, aContext,
+                                              aStream, aOffset,
+                                              aCount);
+  NS_ENSURE_SUCCESS(rv, rv);
+  ae.Pass();
+  return rv;
+}
+
+NS_IMETHODIMP
+ImportLoader::HandleEvent(nsIDOMEvent *aEvent)
+{
+#ifdef DEBUG
+  nsAutoString type;
+  aEvent->GetType(type);
+  MOZ_ASSERT(type.EqualsLiteral("DOMContentLoaded"));
+#endif
+  Done();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImportLoader::OnStopRequest(nsIRequest* aRequest,
+                            nsISupports* aContext,
+                            nsresult aStatus)
+{
+  // OnStartRequest throws a special error code to let us know that we
+  // shouldn't do anything else.
+  if (aStatus == NS_ERROR_DOM_ABORT_ERR) {
+    // We failed in OnStartRequest, nothing more to do (we've already
+    // dispatched an error event) just return here.
+    MOZ_ASSERT(mStopped);
+    return NS_OK;
+  }
+
+  if (mParserStreamListener) {
+    mParserStreamListener->OnStopRequest(aRequest, aContext, aStatus);
+  }
+
+  if (!mDocument) {
+    // If at this point we don't have a document, then the error was
+    // already reported.
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  nsCOMPtr<EventTarget> eventTarget = do_QueryInterface(mDocument);
+  EventListenerManager* manager = eventTarget->GetOrCreateListenerManager();
+  manager->AddEventListenerByType(this,
+                                  NS_LITERAL_STRING("DOMContentLoaded"),
+                                  TrustedEventsAtSystemGroupBubble());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImportLoader::OnStartRequest(nsIRequest* aRequest, nsISupports* aContext)
+{
+  AutoError ae(this);
+  nsIPrincipal* principal = Principal();
+
+  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+  if (!channel) {
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  if (nsContentUtils::IsSystemPrincipal(principal)) {
+    // We should never import non-system documents and run their scripts with system principal!
+    nsCOMPtr<nsIPrincipal> channelPrincipal;
+    nsContentUtils::GetSecurityManager()->GetChannelResultPrincipal(channel,
+                                                                    getter_AddRefs(channelPrincipal));
+    if (!nsContentUtils::IsSystemPrincipal(channelPrincipal)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+  channel->SetOwner(principal);
+
+  nsAutoCString type;
+  channel->GetContentType(type);
+  if (!type.EqualsLiteral("text/html")) {
+    NS_WARNING("ImportLoader wrong content type");
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  // The scope object is same for all the imports in an import tree,
+  // let's get it form the import parent.
+  nsCOMPtr<nsIGlobalObject> global = mImportParent->GetScopeObject();
+  nsCOMPtr<nsIDOMDocument> importDoc;
+  nsCOMPtr<nsIURI> baseURI = mImportParent->GetBaseURI();
+  const nsAString& emptyStr = EmptyString();
+  nsresult rv = NS_NewDOMDocument(getter_AddRefs(importDoc),
+                                  emptyStr, emptyStr, nullptr, mURI,
+                                  baseURI, principal, false, global,
+                                  DocumentFlavorHTML);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+
+  // The imported document must know which master document it belongs to.
+  mDocument = do_QueryInterface(importDoc);
+  nsCOMPtr<nsIDocument> master = mImportParent->MasterDocument();
+  mDocument->SetMasterDocument(master);
+
+  // We want to inherit the sandbox flags and fullscreen enabled flag
+  // from the master document.
+  mDocument->SetSandboxFlags(master->GetSandboxFlags());
+
+  // We have to connect the blank document we created with the channel we opened,
+  // and create its own LoadGroup for it.
+  nsCOMPtr<nsIStreamListener> listener;
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  channel->GetLoadGroup(getter_AddRefs(loadGroup));
+  nsCOMPtr<nsILoadGroup> newLoadGroup = do_CreateInstance(NS_LOADGROUP_CONTRACTID);
+  NS_ENSURE_TRUE(newLoadGroup, NS_ERROR_OUT_OF_MEMORY);
+  newLoadGroup->SetLoadGroup(loadGroup);
+  rv = mDocument->StartDocumentLoad("import", channel, newLoadGroup,
+                                    nullptr, getter_AddRefs(listener),
+                                    true);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+
+  nsCOMPtr<nsIURI> originalURI;
+  rv = channel->GetOriginalURI(getter_AddRefs(originalURI));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+
+  nsCOMPtr<nsIURI> URI;
+  rv = channel->GetURI(getter_AddRefs(URI));
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+  MOZ_ASSERT(URI, "URI of a channel should never be null");
+
+  bool equals;
+  rv = URI->Equals(originalURI, &equals);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+
+  if (!equals) {
+    // In case of a redirection we must add the new URI to the import map.
+    Manager()->AddLoaderWithNewURI(this, URI);
+  }
+
+  // Let's start the parser.
+  mParserStreamListener = listener;
+  rv = listener->OnStartRequest(aRequest, aContext);
+  NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_ABORT_ERR);
+
+  ae.Pass();
+  return NS_OK;
+}
+
+//-----------------------------------------------------------------------------
+// ImportManager
+//-----------------------------------------------------------------------------
+
+NS_IMPL_CYCLE_COLLECTION(ImportManager,
+                         mImports)
+
+NS_INTERFACE_MAP_BEGIN(ImportManager)
+  NS_INTERFACE_MAP_ENTRIES_CYCLE_COLLECTION(ImportManager)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ImportManager)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ImportManager)
+
+already_AddRefed<ImportLoader>
+ImportManager::Get(nsIURI* aURI, nsINode* aNode, nsIDocument* aOrigDocument)
+{
+  // Check if we have a loader for that URI, if not create one,
+  // and start it up.
+  RefPtr<ImportLoader> loader;
+  mImports.Get(aURI, getter_AddRefs(loader));
+  bool needToStart = false;
+  if (!loader) {
+    loader = new ImportLoader(aURI, aOrigDocument);
+    mImports.Put(aURI, loader);
+    needToStart = true;
+  }
+
+  MOZ_ASSERT(loader);
+  // Let's keep track of the sub imports links in each document. It will
+  // be used later for scrip execution order calculation. (see UpdateSpanningTree)
+  // NOTE: removing and adding back the link to the tree somewhere else will
+  // NOT have an effect on script execution order.
+  if (!aOrigDocument->HasSubImportLink(aNode)) {
+    aOrigDocument->AddSubImportLink(aNode);
+  }
+
+  loader->AddLinkElement(aNode);
+
+  if (needToStart) {
+    loader->Open();
+  }
+
+  return loader.forget();
+}
+
+ImportLoader*
+ImportManager::Find(nsIDocument* aImport)
+{
+  return mImports.GetWeak(aImport->GetDocumentURIObject());
+}
+
+ImportLoader*
+ImportManager::Find(nsINode* aLink)
+{
+  HTMLLinkElement* linkElement = static_cast<HTMLLinkElement*>(aLink);
+  nsCOMPtr<nsIURI> uri = linkElement->GetHrefURI();
+  return mImports.GetWeak(uri);
+}
+
+void
+ImportManager::AddLoaderWithNewURI(ImportLoader* aLoader, nsIURI* aNewURI)
+{
+  mImports.Put(aNewURI, aLoader);
+}
+
+ImportLoader* ImportManager::GetNearestPredecessor(nsINode* aNode)
+{
+  // Return the previous link if there is any in the same document.
+  nsIDocument* doc = aNode->OwnerDoc();
+  int32_t idx = doc->IndexOfSubImportLink(aNode);
+  MOZ_ASSERT(idx != -1, "aNode must be a sub import link of its owner document");
+
+  for (; idx > 0; idx--) {
+    HTMLLinkElement* link =
+      static_cast<HTMLLinkElement*>(doc->GetSubImportLink(idx - 1));
+    nsCOMPtr<nsIURI> uri = link->GetHrefURI();
+    RefPtr<ImportLoader> ret;
+    mImports.Get(uri, getter_AddRefs(ret));
+    // Only main referrer links are interesting.
+    if (ret->GetMainReferrer() == link) {
+      return ret;
+    }
+  }
+
+  if (idx == 0) {
+    if (doc->IsMasterDocument()) {
+      // If there is no previous one, and it was the master document, then
+      // there is no predecessor.
+      return nullptr;
+    }
+    // Else we find the main referrer of the import parent of the link's document.
+    // And do a recursion.
+    ImportLoader* owner = Find(doc);
+    MOZ_ASSERT(owner);
+    nsCOMPtr<nsINode> mainReferrer = owner->GetMainReferrer();
+    return GetNearestPredecessor(mainReferrer);
+  }
+
+  return nullptr;
+}
+
+} // namespace dom
+} // namespace mozilla