The Tor Browser: content/base/src/nsDocument.cpp@deefc01c0e14 (annotated)

content/base/src/nsDocument.cpp@deefc01c0e14 (annotated)

content/base/src/nsDocument.cpp

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et tw=78: */
 /* 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/. */
 /*
  * Base class for all our document implementations.
  */
 #include "nsDocument.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/AutoRestore.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Likely.h"
 #include <algorithm>
 #ifdef MOZ_LOGGING
 // so we can get logging even in release builds
 #define FORCE_PR_LOG 1
 #endif
 #include "prlog.h"
 #include "plstr.h"
 #include "prprf.h"
 #include "mozilla/Telemetry.h"
 #include "nsIInterfaceRequestor.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsContentList.h"
 #include "nsIObserver.h"
 #include "nsIBaseWindow.h"
 #include "mozilla/css/Loader.h"
 #include "mozilla/css/ImageLoader.h"
 #include "nsDocShell.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsCOMArray.h"
 #include "nsDOMClassInfo.h"
 #include "nsCxPusher.h"
 #include "mozilla/AsyncEventDispatcher.h"
 #include "mozilla/BasicEvents.h"
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/EventStateManager.h"
 #include "nsIDOMNodeFilter.h"
 #include "nsIDOMStyleSheet.h"
 #include "mozilla/dom/Attr.h"
 #include "nsIDOMDOMImplementation.h"
 #include "nsIDOMDocumentXBL.h"
 #include "mozilla/dom/Element.h"
 #include "nsGenericHTMLElement.h"
 #include "mozilla/dom/CDATASection.h"
 #include "mozilla/dom/ProcessingInstruction.h"
 #include "nsDOMString.h"
 #include "nsNodeUtils.h"
 #include "nsLayoutUtils.h" // for GetFrameForPoint
 #include "nsIFrame.h"
 #include "nsITabChild.h"
 #include "nsRange.h"
 #include "nsIDOMText.h"
 #include "nsIDOMComment.h"
 #include "mozilla/dom/DocumentType.h"
 #include "mozilla/dom/NodeIterator.h"
 #include "mozilla/dom/TreeWalker.h"
 #include "nsIServiceManager.h"
 #include "nsContentCID.h"
 #include "nsError.h"
 #include "nsPresShell.h"
 #include "nsPresContext.h"
 #include "nsIJSON.h"
 #include "nsThreadUtils.h"
 #include "nsNodeInfoManager.h"
 #include "nsIFileChannel.h"
 #include "nsIMultiPartChannel.h"
 #include "nsIRefreshURI.h"
 #include "nsIWebNavigation.h"
 #include "nsIScriptError.h"
 #include "nsStyleSheetService.h"
 #include "nsNetUtil.h"     // for NS_MakeAbsoluteURI
 #include "nsIScriptSecurityManager.h"
 #include "nsIPrincipal.h"
 #include "nsIDOMWindow.h"
 #include "nsPIDOMWindow.h"
 #include "nsIDOMElement.h"
 #include "nsFocusManager.h"
 // for radio group stuff
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIRadioVisitor.h"
 #include "nsIFormControl.h"
 #include "nsBidiUtils.h"
 #include "nsIDOMUserDataHandler.h"
 #include "nsIDOMXPathExpression.h"
 #include "nsIDOMXPathNSResolver.h"
 #include "nsIParserService.h"
 #include "nsContentCreatorFunctions.h"
 #include "nsIScriptContext.h"
 #include "nsBindingManager.h"
 #include "nsIDOMHTMLDocument.h"
 #include "nsHTMLDocument.h"
 #include "nsIDOMHTMLFormElement.h"
 #include "nsIRequest.h"
 #include "nsHostObjectProtocolHandler.h"
 #include "nsCharsetAlias.h"
 #include "nsCharsetSource.h"
 #include "nsIParser.h"
 #include "nsIContentSink.h"
 #include "nsDateTimeFormatCID.h"
 #include "nsIDateTimeFormat.h"
 #include "mozilla/EventDispatcher.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/InternalMutationEvent.h"
 #include "nsDOMCID.h"
 #include "jsapi.h"
 #include "nsIXPConnect.h"
 #include "nsCCUncollectableMarker.h"
 #include "nsIContentPolicy.h"
 #include "nsContentPolicyUtils.h"
 #include "nsICategoryManager.h"
 #include "nsIDocumentLoaderFactory.h"
 #include "nsIDocumentLoader.h"
 #include "nsIContentViewer.h"
 #include "nsIXMLContentSink.h"
 #include "nsIXULDocument.h"
 #include "nsIPrompt.h"
 #include "nsIPropertyBag2.h"
 #include "nsIDOMPageTransitionEvent.h"
 #include "nsIDOMStyleRuleChangeEvent.h"
 #include "nsIDOMStyleSheetChangeEvent.h"
 #include "nsIDOMStyleSheetApplicableStateChangeEvent.h"
 #include "nsJSUtils.h"
 #include "nsFrameLoader.h"
 #include "nsEscape.h"
 #include "nsObjectLoadingContent.h"
 #include "nsHtml5TreeOpExecutor.h"
 #include "nsIDOMElementReplaceEvent.h"
 #include "mozilla/dom/HTMLLinkElement.h"
 #include "mozilla/dom/HTMLMediaElement.h"
 #ifdef MOZ_MEDIA_NAVIGATOR
 #include "mozilla/MediaManager.h"
 #endif // MOZ_MEDIA_NAVIGATOR
 #ifdef MOZ_WEBRTC
 #include "IPeerConnection.h"
 #endif // MOZ_WEBRTC
 #include "mozAutoDocUpdate.h"
 #include "nsGlobalWindow.h"
 #include "mozilla/dom/EncodingUtils.h"
 #include "mozilla/dom/quota/QuotaManager.h"
 #include "nsDOMNavigationTiming.h"
 #include "nsSMILAnimationController.h"
 #include "imgIContainer.h"
 #include "nsSVGUtils.h"
 #include "SVGElementFactory.h"
 #include "nsRefreshDriver.h"
 // FOR CSP (autogenerated by xpidl)
 #include "nsIContentSecurityPolicy.h"
 #include "nsCSPService.h"
 #include "nsHTMLStyleSheet.h"
 #include "nsHTMLCSSStyleSheet.h"
 #include "mozilla/dom/DOMImplementation.h"
 #include "mozilla/dom/ShadowRoot.h"
 #include "mozilla/dom/Comment.h"
 #include "nsTextNode.h"
 #include "mozilla/dom/Link.h"
 #include "mozilla/dom/HTMLElementBinding.h"
 #include "mozilla/dom/SVGElementBinding.h"
 #include "nsXULAppAPI.h"
 #include "mozilla/dom/Touch.h"
 #include "mozilla/dom/TouchEvent.h"
 #include "GeneratedEvents.h"
 #include "mozilla/Preferences.h"
 #include "imgILoader.h"
 #include "imgRequestProxy.h"
 #include "nsWrapperCacheInlines.h"
 #include "nsSandboxFlags.h"
 #include "nsIAppsService.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/DocumentFragment.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/HTMLBodyElement.h"
 #include "mozilla/dom/HTMLInputElement.h"
 #include "mozilla/dom/NodeFilterBinding.h"
 #include "mozilla/dom/OwningNonNull.h"
 #include "mozilla/dom/UndoManager.h"
 #include "mozilla/dom/WebComponentsBinding.h"
 #include "nsFrame.h"
 #include "nsDOMCaretPosition.h"
 #include "nsIDOMHTMLTextAreaElement.h"
 #include "nsViewportInfo.h"
 #include "nsIContentPermissionPrompt.h"
 #include "mozilla/StaticPtr.h"
 #include "nsITextControlElement.h"
 #include "nsIDOMNSEditableElement.h"
 #include "nsIEditor.h"
 #include "nsIDOMCSSStyleRule.h"
 #include "mozilla/css/Rule.h"
 #include "nsIDOMLocation.h"
 #include "nsIHttpChannelInternal.h"
 #include "nsISecurityConsoleMessage.h"
 #include "nsCharSeparatedTokenizer.h"
 #include "mozilla/dom/XPathEvaluator.h"
 #include "nsIDocumentEncoder.h"
 #include "nsIStructuredCloneContainer.h"
 #include "nsIMutableArray.h"
 #include "nsContentPermissionHelper.h"
 #include "mozilla/dom/DOMStringList.h"
 #include "nsWindowMemoryReporter.h"
 using namespace mozilla;
 using namespace mozilla::dom;
 typedef nsTArray<Link*> LinkArray;
 #ifdef PR_LOGGING
 static PRLogModuleInfo* gDocumentLeakPRLog;
 static PRLogModuleInfo* gCspPRLog;
 #endif
 #define NAME_NOT_VALID ((nsSimpleContentList*)1)
 nsIdentifierMapEntry::~nsIdentifierMapEntry()
 {
 }
 void
 nsIdentifierMapEntry::Traverse(nsCycleCollectionTraversalCallback* aCallback)
 {
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*aCallback,
                                      "mIdentifierMap mNameContentList");
   aCallback->NoteXPCOMChild(static_cast<nsIDOMNodeList*>(mNameContentList));
   if (mImageElement) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*aCallback,
                                        "mIdentifierMap mImageElement element");
     nsIContent* imageElement = mImageElement;
     aCallback->NoteXPCOMChild(imageElement);
   }
 }
 bool
 nsIdentifierMapEntry::IsEmpty()
 {
   return mIdContentList.Count() == 0 && !mNameContentList &&
          !mChangeCallbacks && !mImageElement;
 }
 Element*
 nsIdentifierMapEntry::GetIdElement()
 {
   return static_cast<Element*>(mIdContentList.SafeElementAt(0));
 }
 Element*
 nsIdentifierMapEntry::GetImageIdElement()
 {
   return mImageElement ? mImageElement.get() : GetIdElement();
 }
 void
 nsIdentifierMapEntry::AppendAllIdContent(nsCOMArray<nsIContent>* aElements)
 {
   for (int32_t i = 0; i < mIdContentList.Count(); ++i) {
     aElements->AppendObject(static_cast<Element*>(mIdContentList[i]));
   }
 }
 void
 nsIdentifierMapEntry::AddContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
                                                void* aData, bool aForImage)
 {
   if (!mChangeCallbacks) {
     mChangeCallbacks = new nsTHashtable<ChangeCallbackEntry>;
     if (!mChangeCallbacks)
       return;
   }
   ChangeCallback cc = { aCallback, aData, aForImage };
   mChangeCallbacks->PutEntry(cc);
 }
 void
 nsIdentifierMapEntry::RemoveContentChangeCallback(nsIDocument::IDTargetObserver aCallback,
                                                   void* aData, bool aForImage)
 {
   if (!mChangeCallbacks)
     return;
   ChangeCallback cc = { aCallback, aData, aForImage };
   mChangeCallbacks->RemoveEntry(cc);
   if (mChangeCallbacks->Count() == 0) {
     mChangeCallbacks = nullptr;
   }
 }
 struct FireChangeArgs {
   Element* mFrom;
   Element* mTo;
   bool mImageOnly;
   bool mHaveImageOverride;
 };
 namespace mozilla {
 namespace dom {
 static PLDHashOperator
 CustomDefinitionsTraverse(CustomElementHashKey* aKey,
                           CustomElementDefinition* aDefinition,
                           void* aArg)
 {
   nsCycleCollectionTraversalCallback* cb =
     static_cast<nsCycleCollectionTraversalCallback*>(aArg);
   nsAutoPtr<LifecycleCallbacks>& callbacks = aDefinition->mCallbacks;
   if (callbacks->mAttributeChangedCallback.WasPassed()) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
       "mCustomDefinitions->mCallbacks->mAttributeChangedCallback");
     cb->NoteXPCOMChild(aDefinition->mCallbacks->mAttributeChangedCallback.Value());
   }
   if (callbacks->mCreatedCallback.WasPassed()) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
       "mCustomDefinitions->mCallbacks->mCreatedCallback");
     cb->NoteXPCOMChild(aDefinition->mCallbacks->mCreatedCallback.Value());
   }
   if (callbacks->mAttachedCallback.WasPassed()) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
       "mCustomDefinitions->mCallbacks->mAttachedCallback");
     cb->NoteXPCOMChild(aDefinition->mCallbacks->mAttachedCallback.Value());
   }
   if (callbacks->mDetachedCallback.WasPassed()) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
       "mCustomDefinitions->mCallbacks->mDetachedCallback");
     cb->NoteXPCOMChild(aDefinition->mCallbacks->mDetachedCallback.Value());
   }
   return PL_DHASH_NEXT;
 }
 static PLDHashOperator
 CandidatesTraverse(CustomElementHashKey* aKey,
                    nsTArray<nsRefPtr<Element>>* aData,
                    void* aArg)
 {
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(aArg);
   for (size_t i = 0; i < aData->Length(); ++i) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mCandidatesMap->Element");
     cb->NoteXPCOMChild(aData->ElementAt(i));
   }
   return PL_DHASH_NEXT;
 }
 struct CustomDefinitionTraceArgs
 {
   const TraceCallbacks& callbacks;
   void* closure;
 };
 static PLDHashOperator
 CustomDefinitionTrace(CustomElementHashKey *aKey,
                       CustomElementDefinition *aData,
                       void *aArg)
 {
   CustomDefinitionTraceArgs* traceArgs = static_cast<CustomDefinitionTraceArgs*>(aArg);
   MOZ_ASSERT(aData, "Definition must not be null");
   traceArgs->callbacks.Trace(&aData->mPrototype, "mCustomDefinitions prototype",
                              traceArgs->closure);
   return PL_DHASH_NEXT;
 }
 NS_IMPL_CYCLE_COLLECTION_CLASS(Registry)
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(Registry)
   CustomDefinitionTraceArgs customDefinitionArgs = { aCallbacks, aClosure };
   tmp->mCustomDefinitions.EnumerateRead(CustomDefinitionTrace,
                                         &customDefinitionArgs);
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(Registry)
   tmp->mCustomDefinitions.EnumerateRead(CustomDefinitionsTraverse, &cb);
   tmp->mCandidatesMap.EnumerateRead(CandidatesTraverse, &cb);
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(Registry)
   tmp->mCustomDefinitions.Clear();
   tmp->mCandidatesMap.Clear();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Registry)
   NS_INTERFACE_MAP_ENTRY(nsISupports)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTING_ADDREF(Registry)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(Registry)
 Registry::Registry()
 {
   mozilla::HoldJSObjects(this);
 }
 Registry::~Registry()
 {
   mozilla::DropJSObjects(this);
 }
 void
 CustomElementCallback::Call()
 {
   ErrorResult rv;
   switch (mType) {
     case nsIDocument::eCreated:
       // For the duration of this callback invocation, the element is being created
       // flag must be set to true.
       mOwnerData->mElementIsBeingCreated = true;
       mOwnerData->mCreatedCallbackInvoked = true;
       static_cast<LifecycleCreatedCallback *>(mCallback.get())->Call(mThisObject, rv);
       mOwnerData->mElementIsBeingCreated = false;
       break;
     case nsIDocument::eAttached:
       static_cast<LifecycleAttachedCallback *>(mCallback.get())->Call(mThisObject, rv);
       break;
     case nsIDocument::eDetached:
       static_cast<LifecycleDetachedCallback *>(mCallback.get())->Call(mThisObject, rv);
       break;
     case nsIDocument::eAttributeChanged:
       static_cast<LifecycleAttributeChangedCallback *>(mCallback.get())->Call(mThisObject,
         mArgs.name, mArgs.oldValue, mArgs.newValue, rv);
       break;
   }
 }
 void
 CustomElementCallback::Traverse(nsCycleCollectionTraversalCallback& aCb) const
 {
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mThisObject");
   aCb.NoteXPCOMChild(mThisObject);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(aCb, "mCallback");
   aCb.NoteXPCOMChild(mCallback);
 }
 CustomElementCallback::CustomElementCallback(Element* aThisObject,
                                              nsIDocument::ElementCallbackType aCallbackType,
                                              mozilla::dom::CallbackFunction* aCallback,
                                              CustomElementData* aOwnerData)
   : mThisObject(aThisObject),
     mCallback(aCallback),
     mType(aCallbackType),
     mOwnerData(aOwnerData)
 {
 }
 CustomElementDefinition::CustomElementDefinition(JSObject* aPrototype,
                                                  nsIAtom* aType,
                                                  nsIAtom* aLocalName,
                                                  LifecycleCallbacks* aCallbacks,
                                                  uint32_t aNamespaceID,
                                                  uint32_t aDocOrder)
   : mPrototype(aPrototype),
     mType(aType),
     mLocalName(aLocalName),
     mCallbacks(aCallbacks),
     mNamespaceID(aNamespaceID),
     mDocOrder(aDocOrder)
 {
 }
 CustomElementData::CustomElementData(nsIAtom* aType)
   : mType(aType),
     mCurrentCallback(-1),
     mElementIsBeingCreated(false),
     mCreatedCallbackInvoked(true),
     mAssociatedMicroTask(-1)
 {
 }
 void
 CustomElementData::RunCallbackQueue()
 {
   // Note: It's possible to re-enter this method.
   while (static_cast<uint32_t>(++mCurrentCallback) < mCallbackQueue.Length()) {
     mCallbackQueue[mCurrentCallback]->Call();
   }
   mCallbackQueue.Clear();
   mCurrentCallback = -1;
 }
 } // namespace dom
 } // namespace mozilla
 static PLDHashOperator
 FireChangeEnumerator(nsIdentifierMapEntry::ChangeCallbackEntry *aEntry, void *aArg)
 {
   FireChangeArgs* args = static_cast<FireChangeArgs*>(aArg);
   // Don't fire image changes for non-image observers, and don't fire element
   // changes for image observers when an image override is active.
   if (aEntry->mKey.mForImage ? (args->mHaveImageOverride && !args->mImageOnly) :
                                args->mImageOnly)
     return PL_DHASH_NEXT;
   return aEntry->mKey.mCallback(args->mFrom, args->mTo, aEntry->mKey.mData)
       ? PL_DHASH_NEXT : PL_DHASH_REMOVE;
 }
 void
 nsIdentifierMapEntry::FireChangeCallbacks(Element* aOldElement,
                                           Element* aNewElement,
                                           bool aImageOnly)
 {
   if (!mChangeCallbacks)
     return;
   FireChangeArgs args = { aOldElement, aNewElement, aImageOnly, !!mImageElement };
   mChangeCallbacks->EnumerateEntries(FireChangeEnumerator, &args);
 }
 bool
 nsIdentifierMapEntry::AddIdElement(Element* aElement)
 {
   NS_PRECONDITION(aElement, "Must have element");
   NS_PRECONDITION(mIdContentList.IndexOf(nullptr) < 0,
                   "Why is null in our list?");
 #ifdef DEBUG
   Element* currentElement =
     static_cast<Element*>(mIdContentList.SafeElementAt(0));
 #endif
   // Common case
   if (mIdContentList.Count() == 0) {
     if (!mIdContentList.AppendElement(aElement))
       return false;
     NS_ASSERTION(currentElement == nullptr, "How did that happen?");
     FireChangeCallbacks(nullptr, aElement);
     return true;
   }
   // We seem to have multiple content nodes for the same id, or XUL is messing
   // with us.  Search for the right place to insert the content.
   int32_t start = 0;
   int32_t end = mIdContentList.Count();
   do {
     NS_ASSERTION(start < end, "Bogus start/end");
     int32_t cur = (start + end) / 2;
     NS_ASSERTION(cur >= start && cur < end, "What happened here?");
     Element* curElement = static_cast<Element*>(mIdContentList[cur]);
     if (curElement == aElement) {
       // Already in the list, so already in the right spot.  Get out of here.
       // XXXbz this only happens because XUL does all sorts of random
       // UpdateIdTableEntry calls.  Hate, hate, hate!
       return true;
     }
     if (nsContentUtils::PositionIsBefore(aElement, curElement)) {
       end = cur;
     } else {
       start = cur + 1;
     }
   } while (start != end);
   if (!mIdContentList.InsertElementAt(aElement, start))
     return false;
   if (start == 0) {
     Element* oldElement =
       static_cast<Element*>(mIdContentList.SafeElementAt(1));
     NS_ASSERTION(currentElement == oldElement, "How did that happen?");
     FireChangeCallbacks(oldElement, aElement);
   }
   return true;
 }
 void
 nsIdentifierMapEntry::RemoveIdElement(Element* aElement)
 {
   NS_PRECONDITION(aElement, "Missing element");
   // This should only be called while the document is in an update.
   // Assertions near the call to this method guarantee this.
   // This could fire in OOM situations
   // Only assert this in HTML documents for now as XUL does all sorts of weird
   // crap.
   NS_ASSERTION(!aElement->OwnerDoc()->IsHTML() ||
                mIdContentList.IndexOf(aElement) >= 0,
                "Removing id entry that doesn't exist");
   // XXXbz should this ever Compact() I guess when all the content is gone
   // we'll just get cleaned up in the natural order of things...
   Element* currentElement =
     static_cast<Element*>(mIdContentList.SafeElementAt(0));
   mIdContentList.RemoveElement(aElement);
   if (currentElement == aElement) {
     FireChangeCallbacks(currentElement,
                         static_cast<Element*>(mIdContentList.SafeElementAt(0)));
   }
 }
 void
 nsIdentifierMapEntry::SetImageElement(Element* aElement)
 {
   Element* oldElement = GetImageIdElement();
   mImageElement = aElement;
   Element* newElement = GetImageIdElement();
   if (oldElement != newElement) {
     FireChangeCallbacks(oldElement, newElement, true);
   }
 }
 void
 nsIdentifierMapEntry::AddNameElement(nsINode* aNode, Element* aElement)
 {
   if (!mNameContentList) {
     mNameContentList = new nsSimpleContentList(aNode);
   }
   mNameContentList->AppendElement(aElement);
 }
 void
 nsIdentifierMapEntry::RemoveNameElement(Element* aElement)
 {
   if (mNameContentList) {
     mNameContentList->RemoveElement(aElement);
   }
 }
 bool
 nsIdentifierMapEntry::HasIdElementExposedAsHTMLDocumentProperty()
 {
   Element* idElement = GetIdElement();
   return idElement &&
          nsGenericHTMLElement::ShouldExposeIdAsHTMLDocumentProperty(idElement);
 }
 // static
 size_t
 nsIdentifierMapEntry::SizeOfExcludingThis(nsIdentifierMapEntry* aEntry,
                                           MallocSizeOf aMallocSizeOf,
                                           void*)
 {
   return aEntry->GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
 }
 // Helper structs for the content->subdoc map
 class SubDocMapEntry : public PLDHashEntryHdr
 {
 public:
   // Both of these are strong references
   Element *mKey; // must be first, to look like PLDHashEntryStub
   nsIDocument *mSubDocument;
 };
 struct FindContentData
 {
   FindContentData(nsIDocument *aSubDoc)
     : mSubDocument(aSubDoc), mResult(nullptr)
   {
   }
   nsISupports *mSubDocument;
   Element *mResult;
 };
 /**
  * A struct that holds all the information about a radio group.
  */
 struct nsRadioGroupStruct
 {
   nsRadioGroupStruct()
     : mRequiredRadioCount(0)
     , mGroupSuffersFromValueMissing(false)
   {}
   /**
    * A strong pointer to the currently selected radio button.
    */
   nsRefPtr<HTMLInputElement> mSelectedRadioButton;
   nsCOMArray<nsIFormControl> mRadioButtons;
   uint32_t mRequiredRadioCount;
   bool mGroupSuffersFromValueMissing;
 };
 nsDOMStyleSheetList::nsDOMStyleSheetList(nsIDocument *aDocument)
 {
   mLength = -1;
   // Not reference counted to avoid circular references.
   // The document will tell us when its going away.
   mDocument = aDocument;
   mDocument->AddObserver(this);
 }
 nsDOMStyleSheetList::~nsDOMStyleSheetList()
 {
   if (mDocument) {
     mDocument->RemoveObserver(this);
   }
 }
 NS_IMPL_ISUPPORTS_INHERITED(nsDOMStyleSheetList, StyleSheetList,
                             nsIDocumentObserver,
                             nsIMutationObserver)
 uint32_t
 nsDOMStyleSheetList::Length()
 {
   if (!mDocument) {
     return 0;
   }
   // XXX Find the number and then cache it. We'll use the
   // observer notification to figure out if new ones have
   // been added or removed.
   if (-1 == mLength) {
     mLength = mDocument->GetNumberOfStyleSheets();
 #ifdef DEBUG
     int32_t i;
     for (i = 0; i < mLength; i++) {
       nsIStyleSheet *sheet = mDocument->GetStyleSheetAt(i);
       nsCOMPtr<nsIDOMStyleSheet> domss(do_QueryInterface(sheet));
       NS_ASSERTION(domss, "All \"normal\" sheets implement nsIDOMStyleSheet");
     }
 #endif
   }
   return mLength;
 }
 nsCSSStyleSheet*
 nsDOMStyleSheetList::IndexedGetter(uint32_t aIndex, bool& aFound)
 {
   if (!mDocument || aIndex >= (uint32_t)mDocument->GetNumberOfStyleSheets()) {
     aFound = false;
     return nullptr;
   }
   aFound = true;
   nsIStyleSheet *sheet = mDocument->GetStyleSheetAt(aIndex);
   NS_ASSERTION(sheet, "Must have a sheet");
   return static_cast<nsCSSStyleSheet*>(sheet);
 }
 void
 nsDOMStyleSheetList::NodeWillBeDestroyed(const nsINode *aNode)
 {
   mDocument = nullptr;
 }
 void
 nsDOMStyleSheetList::StyleSheetAdded(nsIDocument *aDocument,
                                      nsIStyleSheet* aStyleSheet,
                                      bool aDocumentSheet)
 {
   if (aDocumentSheet && -1 != mLength) {
     nsCOMPtr<nsIDOMStyleSheet> domss(do_QueryInterface(aStyleSheet));
     if (domss) {
       mLength++;
     }
   }
 }
 void
 nsDOMStyleSheetList::StyleSheetRemoved(nsIDocument *aDocument,
                                        nsIStyleSheet* aStyleSheet,
                                        bool aDocumentSheet)
 {
   if (aDocumentSheet && -1 != mLength) {
     nsCOMPtr<nsIDOMStyleSheet> domss(do_QueryInterface(aStyleSheet));
     if (domss) {
       mLength--;
     }
   }
 }
 // nsOnloadBlocker implementation
 NS_IMPL_ISUPPORTS(nsOnloadBlocker, nsIRequest)
 NS_IMETHODIMP
 nsOnloadBlocker::GetName(nsACString &aResult)
 {
   aResult.AssignLiteral("about:document-onload-blocker");
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::IsPending(bool *_retval)
 {
   *_retval = true;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::GetStatus(nsresult *status)
 {
   *status = NS_OK;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::Cancel(nsresult status)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::Suspend(void)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::Resume(void)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::GetLoadGroup(nsILoadGroup * *aLoadGroup)
 {
   *aLoadGroup = nullptr;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::SetLoadGroup(nsILoadGroup * aLoadGroup)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::GetLoadFlags(nsLoadFlags *aLoadFlags)
 {
   *aLoadFlags = nsIRequest::LOAD_NORMAL;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsOnloadBlocker::SetLoadFlags(nsLoadFlags aLoadFlags)
 {
   return NS_OK;
 }
 // ==================================================================
 nsExternalResourceMap::nsExternalResourceMap()
   : mHaveShutDown(false)
 {
 }
 nsIDocument*
 nsExternalResourceMap::RequestResource(nsIURI* aURI,
                                        nsINode* aRequestingNode,
                                        nsDocument* aDisplayDocument,
                                        ExternalResourceLoad** aPendingLoad)
 {
   // If we ever start allowing non-same-origin loads here, we might need to do
   // something interesting with aRequestingPrincipal even for the hashtable
   // gets.
   NS_PRECONDITION(aURI, "Must have a URI");
   NS_PRECONDITION(aRequestingNode, "Must have a node");
   *aPendingLoad = nullptr;
   if (mHaveShutDown) {
     return nullptr;
   }
   // First, make sure we strip the ref from aURI.
   nsCOMPtr<nsIURI> clone;
   nsresult rv = aURI->CloneIgnoringRef(getter_AddRefs(clone));
   if (NS_FAILED(rv) || !clone) {
     return nullptr;
   }
   ExternalResource* resource;
   mMap.Get(clone, &resource);
   if (resource) {
     return resource->mDocument;
   }
   nsRefPtr<PendingLoad> load;
   mPendingLoads.Get(clone, getter_AddRefs(load));
   if (load) {
     load.forget(aPendingLoad);
     return nullptr;
   }
   load = new PendingLoad(aDisplayDocument);
   mPendingLoads.Put(clone, load);
   if (NS_FAILED(load->StartLoad(clone, aRequestingNode))) {
     // Make sure we don't thrash things by trying this load again, since
     // chances are it failed for good reasons (security check, etc).
     AddExternalResource(clone, nullptr, nullptr, aDisplayDocument);
   } else {
     load.forget(aPendingLoad);
   }
   return nullptr;
 }
 struct
 nsExternalResourceEnumArgs
 {
   nsIDocument::nsSubDocEnumFunc callback;
   void *data;
 };
 static PLDHashOperator
 ExternalResourceEnumerator(nsIURI* aKey,
                            nsExternalResourceMap::ExternalResource* aData,
                            void* aClosure)
 {
   nsExternalResourceEnumArgs* args =
     static_cast<nsExternalResourceEnumArgs*>(aClosure);
   bool next =
     aData->mDocument ? args->callback(aData->mDocument, args->data) : true;
   return next ? PL_DHASH_NEXT : PL_DHASH_STOP;
 }
 void
 nsExternalResourceMap::EnumerateResources(nsIDocument::nsSubDocEnumFunc aCallback,
                                           void* aData)
 {
   nsExternalResourceEnumArgs args = { aCallback, aData };
   mMap.EnumerateRead(ExternalResourceEnumerator, &args);
 }
 static PLDHashOperator
 ExternalResourceTraverser(nsIURI* aKey,
                           nsExternalResourceMap::ExternalResource* aData,
                           void* aClosure)
 {
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
                                      "mExternalResourceMap.mMap entry"
                                      "->mDocument");
   cb->NoteXPCOMChild(aData->mDocument);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
                                      "mExternalResourceMap.mMap entry"
                                      "->mViewer");
   cb->NoteXPCOMChild(aData->mViewer);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
                                      "mExternalResourceMap.mMap entry"
                                      "->mLoadGroup");
   cb->NoteXPCOMChild(aData->mLoadGroup);
   return PL_DHASH_NEXT;
 }
 void
 nsExternalResourceMap::Traverse(nsCycleCollectionTraversalCallback* aCallback) const
 {
   // mPendingLoads will get cleared out as the requests complete, so
   // no need to worry about those here.
   mMap.EnumerateRead(ExternalResourceTraverser, aCallback);
 }
 static PLDHashOperator
 ExternalResourceHider(nsIURI* aKey,
                       nsExternalResourceMap::ExternalResource* aData,
                       void* aClosure)
 {
   if (aData->mViewer) {
     aData->mViewer->Hide();
   }
   return PL_DHASH_NEXT;
 }
 void
 nsExternalResourceMap::HideViewers()
 {
   mMap.EnumerateRead(ExternalResourceHider, nullptr);
 }
 static PLDHashOperator
 ExternalResourceShower(nsIURI* aKey,
                        nsExternalResourceMap::ExternalResource* aData,
                        void* aClosure)
 {
   if (aData->mViewer) {
     aData->mViewer->Show();
   }
   return PL_DHASH_NEXT;
 }
 void
 nsExternalResourceMap::ShowViewers()
 {
   mMap.EnumerateRead(ExternalResourceShower, nullptr);
 }
 void
 TransferZoomLevels(nsIDocument* aFromDoc,
                    nsIDocument* aToDoc)
 {
   NS_ABORT_IF_FALSE(aFromDoc && aToDoc,
                     "transferring zoom levels from/to null doc");
   nsIPresShell* fromShell = aFromDoc->GetShell();
   if (!fromShell)
     return;
   nsPresContext* fromCtxt = fromShell->GetPresContext();
   if (!fromCtxt)
     return;
   nsIPresShell* toShell = aToDoc->GetShell();
   if (!toShell)
     return;
   nsPresContext* toCtxt = toShell->GetPresContext();
   if (!toCtxt)
     return;
   toCtxt->SetFullZoom(fromCtxt->GetFullZoom());
   toCtxt->SetBaseMinFontSize(fromCtxt->BaseMinFontSize());
   toCtxt->SetTextZoom(fromCtxt->TextZoom());
 }
 void
 TransferShowingState(nsIDocument* aFromDoc, nsIDocument* aToDoc)
 {
   NS_ABORT_IF_FALSE(aFromDoc && aToDoc,
                     "transferring showing state from/to null doc");
   if (aFromDoc->IsShowing()) {
     aToDoc->OnPageShow(true, nullptr);
   }
 }
 nsresult
 nsExternalResourceMap::AddExternalResource(nsIURI* aURI,
                                            nsIContentViewer* aViewer,
                                            nsILoadGroup* aLoadGroup,
                                            nsIDocument* aDisplayDocument)
 {
   NS_PRECONDITION(aURI, "Unexpected call");
   NS_PRECONDITION((aViewer && aLoadGroup) || (!aViewer && !aLoadGroup),
                   "Must have both or neither");
   nsRefPtr<PendingLoad> load;
   mPendingLoads.Get(aURI, getter_AddRefs(load));
   mPendingLoads.Remove(aURI);
   nsresult rv = NS_OK;
   nsCOMPtr<nsIDocument> doc;
   if (aViewer) {
     doc = aViewer->GetDocument();
     NS_ASSERTION(doc, "Must have a document");
     nsCOMPtr<nsIXULDocument> xulDoc = do_QueryInterface(doc);
     if (xulDoc) {
       // We don't handle XUL stuff here yet.
       rv = NS_ERROR_NOT_AVAILABLE;
     } else {
       doc->SetDisplayDocument(aDisplayDocument);
       // Make sure that hiding our viewer will tear down its presentation.
       aViewer->SetSticky(false);
       rv = aViewer->Init(nullptr, nsIntRect(0, 0, 0, 0));
       if (NS_SUCCEEDED(rv)) {
         rv = aViewer->Open(nullptr, nullptr);
       }
     }
     if (NS_FAILED(rv)) {
       doc = nullptr;
       aViewer = nullptr;
       aLoadGroup = nullptr;
     }
   }
   ExternalResource* newResource = new ExternalResource();
   mMap.Put(aURI, newResource);
   newResource->mDocument = doc;
   newResource->mViewer = aViewer;
   newResource->mLoadGroup = aLoadGroup;
   if (doc) {
     TransferZoomLevels(aDisplayDocument, doc);
     TransferShowingState(aDisplayDocument, doc);
   }
   const nsTArray< nsCOMPtr<nsIObserver> > & obs = load->Observers();
   for (uint32_t i = 0; i < obs.Length(); ++i) {
     obs[i]->Observe(doc, "external-resource-document-created", nullptr);
   }
   return rv;
 }
 NS_IMPL_ISUPPORTS(nsExternalResourceMap::PendingLoad,
                   nsIStreamListener,
                   nsIRequestObserver)
 NS_IMETHODIMP
 nsExternalResourceMap::PendingLoad::OnStartRequest(nsIRequest *aRequest,
                                                    nsISupports *aContext)
 {
   nsExternalResourceMap& map = mDisplayDocument->ExternalResourceMap();
   if (map.HaveShutDown()) {
     return NS_BINDING_ABORTED;
   }
   nsCOMPtr<nsIContentViewer> viewer;
   nsCOMPtr<nsILoadGroup> loadGroup;
   nsresult rv = SetupViewer(aRequest, getter_AddRefs(viewer),
                             getter_AddRefs(loadGroup));
   // Make sure to do this no matter what
   nsresult rv2 = map.AddExternalResource(mURI, viewer, loadGroup,
                                          mDisplayDocument);
   if (NS_FAILED(rv)) {
     return rv;
   }
   if (NS_FAILED(rv2)) {
     mTargetListener = nullptr;
     return rv2;
   }
   return mTargetListener->OnStartRequest(aRequest, aContext);
 }
 nsresult
 nsExternalResourceMap::PendingLoad::SetupViewer(nsIRequest* aRequest,
                                                 nsIContentViewer** aViewer,
                                                 nsILoadGroup** aLoadGroup)
 {
   NS_PRECONDITION(!mTargetListener, "Unexpected call to OnStartRequest");
   *aViewer = nullptr;
   *aLoadGroup = nullptr;
   nsCOMPtr<nsIChannel> chan(do_QueryInterface(aRequest));
   NS_ENSURE_TRUE(chan, NS_ERROR_UNEXPECTED);
   nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aRequest));
   if (httpChannel) {
     bool requestSucceeded;
     if (NS_FAILED(httpChannel->GetRequestSucceeded(&requestSucceeded)) ||
         !requestSucceeded) {
       // Bail out on this load, since it looks like we have an HTTP error page
       return NS_BINDING_ABORTED;
     }
   }
   nsAutoCString type;
   chan->GetContentType(type);
   nsCOMPtr<nsILoadGroup> loadGroup;
   chan->GetLoadGroup(getter_AddRefs(loadGroup));
   // Give this document its own loadgroup
   nsCOMPtr<nsILoadGroup> newLoadGroup =
         do_CreateInstance(NS_LOADGROUP_CONTRACTID);
   NS_ENSURE_TRUE(newLoadGroup, NS_ERROR_OUT_OF_MEMORY);
   newLoadGroup->SetLoadGroup(loadGroup);
   nsCOMPtr<nsIInterfaceRequestor> callbacks;
   loadGroup->GetNotificationCallbacks(getter_AddRefs(callbacks));
   nsCOMPtr<nsIInterfaceRequestor> newCallbacks =
     new LoadgroupCallbacks(callbacks);
   newLoadGroup->SetNotificationCallbacks(newCallbacks);
   // This is some serious hackery cribbed from docshell
   nsCOMPtr<nsICategoryManager> catMan =
     do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
   NS_ENSURE_TRUE(catMan, NS_ERROR_NOT_AVAILABLE);
   nsXPIDLCString contractId;
   nsresult rv = catMan->GetCategoryEntry("Gecko-Content-Viewers", type.get(),
                                          getter_Copies(contractId));
   NS_ENSURE_SUCCESS(rv, rv);
   nsCOMPtr<nsIDocumentLoaderFactory> docLoaderFactory =
     do_GetService(contractId);
   NS_ENSURE_TRUE(docLoaderFactory, NS_ERROR_NOT_AVAILABLE);
   nsCOMPtr<nsIContentViewer> viewer;
   nsCOMPtr<nsIStreamListener> listener;
   rv = docLoaderFactory->CreateInstance("external-resource", chan, newLoadGroup,
                                         type.get(), nullptr, nullptr,
                                         getter_AddRefs(listener),
                                         getter_AddRefs(viewer));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(viewer, NS_ERROR_UNEXPECTED);
   nsCOMPtr<nsIParser> parser = do_QueryInterface(listener);
   if (!parser) {
     /// We don't want to deal with the various fake documents yet
     return NS_ERROR_NOT_IMPLEMENTED;
   }
   // We can't handle HTML and other weird things here yet.
   nsIContentSink* sink = parser->GetContentSink();
   nsCOMPtr<nsIXMLContentSink> xmlSink = do_QueryInterface(sink);
   if (!xmlSink) {
     return NS_ERROR_NOT_IMPLEMENTED;
   }
   listener.swap(mTargetListener);
   viewer.forget(aViewer);
   newLoadGroup.forget(aLoadGroup);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsExternalResourceMap::PendingLoad::OnDataAvailable(nsIRequest* aRequest,
                                                     nsISupports* aContext,
                                                     nsIInputStream* aStream,
                                                     uint64_t aOffset,
                                                     uint32_t aCount)
 {
   NS_PRECONDITION(mTargetListener, "Shouldn't be getting called!");
   if (mDisplayDocument->ExternalResourceMap().HaveShutDown()) {
     return NS_BINDING_ABORTED;
   }
   return mTargetListener->OnDataAvailable(aRequest, aContext, aStream, aOffset,
                                           aCount);
 }
 NS_IMETHODIMP
 nsExternalResourceMap::PendingLoad::OnStopRequest(nsIRequest* aRequest,
                                                   nsISupports* aContext,
                                                   nsresult aStatus)
 {
   // mTargetListener might be null if SetupViewer or AddExternalResource failed
   if (mTargetListener) {
     nsCOMPtr<nsIStreamListener> listener;
     mTargetListener.swap(listener);
     return listener->OnStopRequest(aRequest, aContext, aStatus);
   }
   return NS_OK;
 }
 nsresult
 nsExternalResourceMap::PendingLoad::StartLoad(nsIURI* aURI,
                                               nsINode* aRequestingNode)
 {
   NS_PRECONDITION(aURI, "Must have a URI");
   NS_PRECONDITION(aRequestingNode, "Must have a node");
   // Time to start a load.  First, the security checks.
   nsIPrincipal* requestingPrincipal = aRequestingNode->NodePrincipal();
   nsresult rv = nsContentUtils::GetSecurityManager()->
     CheckLoadURIWithPrincipal(requestingPrincipal, aURI,
                               nsIScriptSecurityManager::STANDARD);
   NS_ENSURE_SUCCESS(rv, rv);
   // Allow data URIs and other URI's that inherit their principal by passing
   // true as the 3rd argument of CheckMayLoad, since we want
   // to allow external resources from data URIs regardless of the difference
   // in URI scheme.
   rv = requestingPrincipal->CheckMayLoad(aURI, true, true);
   NS_ENSURE_SUCCESS(rv, rv);
   int16_t shouldLoad = nsIContentPolicy::ACCEPT;
   rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_OTHER,
                                  aURI,
                                  requestingPrincipal,
                                  aRequestingNode,
                                  EmptyCString(), //mime guess
                                  nullptr,         //extra
                                  &shouldLoad,
                                  nsContentUtils::GetContentPolicy(),
                                  nsContentUtils::GetSecurityManager());
   if (NS_FAILED(rv)) return rv;
   if (NS_CP_REJECTED(shouldLoad)) {
     // Disallowed by content policy
     return NS_ERROR_CONTENT_BLOCKED;
   }
   nsIDocument* doc = aRequestingNode->OwnerDoc();
   nsCOMPtr<nsIInterfaceRequestor> req = nsContentUtils::GetSameOriginChecker();
   NS_ENSURE_TRUE(req, NS_ERROR_OUT_OF_MEMORY);
   nsCOMPtr<nsILoadGroup> loadGroup = doc->GetDocumentLoadGroup();
   nsCOMPtr<nsIChannel> channel;
   rv = NS_NewChannel(getter_AddRefs(channel), aURI, nullptr, loadGroup, req);
   NS_ENSURE_SUCCESS(rv, rv);
   mURI = aURI;
   return channel->AsyncOpen(this, nullptr);
 }
 NS_IMPL_ISUPPORTS(nsExternalResourceMap::LoadgroupCallbacks,
                   nsIInterfaceRequestor)
 #define IMPL_SHIM(_i) \
   NS_IMPL_ISUPPORTS(nsExternalResourceMap::LoadgroupCallbacks::_i##Shim, _i)
 IMPL_SHIM(nsILoadContext)
 IMPL_SHIM(nsIProgressEventSink)
 IMPL_SHIM(nsIChannelEventSink)
 IMPL_SHIM(nsISecurityEventSink)
 IMPL_SHIM(nsIApplicationCacheContainer)
 #undef IMPL_SHIM
 #define IID_IS(_i) aIID.Equals(NS_GET_IID(_i))
 #define TRY_SHIM(_i)                                                       \
   PR_BEGIN_MACRO                                                           \
     if (IID_IS(_i)) {                                                      \
       nsCOMPtr<_i> real = do_GetInterface(mCallbacks);                     \
       if (!real) {                                                         \
         return NS_NOINTERFACE;                                             \
       }                                                                    \
       nsCOMPtr<_i> shim = new _i##Shim(this, real);                        \
       if (!shim) {                                                         \
         return NS_ERROR_OUT_OF_MEMORY;                                     \
       }                                                                    \
       shim.forget(aSink);                                                  \
       return NS_OK;                                                        \
     }                                                                      \
   PR_END_MACRO
 NS_IMETHODIMP
 nsExternalResourceMap::LoadgroupCallbacks::GetInterface(const nsIID & aIID,
                                                         void **aSink)
 {
   if (mCallbacks &&
       (IID_IS(nsIPrompt) || IID_IS(nsIAuthPrompt) || IID_IS(nsIAuthPrompt2) ||
        IID_IS(nsITabChild))) {
     return mCallbacks->GetInterface(aIID, aSink);
   }
   *aSink = nullptr;
   TRY_SHIM(nsILoadContext);
   TRY_SHIM(nsIProgressEventSink);
   TRY_SHIM(nsIChannelEventSink);
   TRY_SHIM(nsISecurityEventSink);
   TRY_SHIM(nsIApplicationCacheContainer);
   return NS_NOINTERFACE;
 }
 #undef TRY_SHIM
 #undef IID_IS
 nsExternalResourceMap::ExternalResource::~ExternalResource()
 {
   if (mViewer) {
     mViewer->Close(nullptr);
     mViewer->Destroy();
   }
 }
 // ==================================================================
 // =
 // ==================================================================
 // If we ever have an nsIDocumentObserver notification for stylesheet title
 // changes we should update the list from that instead of overriding
 // EnsureFresh.
 class nsDOMStyleSheetSetList MOZ_FINAL : public DOMStringList
 {
 public:
   nsDOMStyleSheetSetList(nsIDocument* aDocument);
   void Disconnect()
   {
     mDocument = nullptr;
   }
   virtual void EnsureFresh() MOZ_OVERRIDE;
 protected:
   nsIDocument* mDocument;  // Our document; weak ref.  It'll let us know if it
                            // dies.
 };
 nsDOMStyleSheetSetList::nsDOMStyleSheetSetList(nsIDocument* aDocument)
   : mDocument(aDocument)
 {
   NS_ASSERTION(mDocument, "Must have document!");
 }
 void
 nsDOMStyleSheetSetList::EnsureFresh()
 {
   mNames.Clear();
   if (!mDocument) {
     return; // Spec says "no exceptions", and we have no style sets if we have
             // no document, for sure
   }
   int32_t count = mDocument->GetNumberOfStyleSheets();
   nsAutoString title;
   for (int32_t index = 0; index < count; index++) {
     nsIStyleSheet* sheet = mDocument->GetStyleSheetAt(index);
     NS_ASSERTION(sheet, "Null sheet in sheet list!");
     sheet->GetTitle(title);
     if (!title.IsEmpty() && !mNames.Contains(title) && !Add(title)) {
       return;
     }
   }
 }
 // ==================================================================
 nsIDocument::SelectorCache::SelectorCache()
   : nsExpirationTracker<SelectorCacheKey, 4>(1000) { }
 // CacheList takes ownership of aSelectorList.
 void nsIDocument::SelectorCache::CacheList(const nsAString& aSelector,
                                            nsCSSSelectorList* aSelectorList)
 {
   SelectorCacheKey* key = new SelectorCacheKey(aSelector);
   mTable.Put(key->mKey, aSelectorList);
   AddObject(key);
 }
 class nsIDocument::SelectorCacheKeyDeleter MOZ_FINAL : public nsRunnable
 {
 public:
   explicit SelectorCacheKeyDeleter(SelectorCacheKey* aToDelete)
     : mSelector(aToDelete)
   {
     MOZ_COUNT_CTOR(SelectorCacheKeyDeleter);
   }
   ~SelectorCacheKeyDeleter()
   {
     MOZ_COUNT_DTOR(SelectorCacheKeyDeleter);
   }
   NS_IMETHOD Run()
   {
     return NS_OK;
   }
 private:
   nsAutoPtr<SelectorCacheKey> mSelector;
 };
 void nsIDocument::SelectorCache::NotifyExpired(SelectorCacheKey* aSelector)
 {
   RemoveObject(aSelector);
   mTable.Remove(aSelector->mKey);
   nsCOMPtr<nsIRunnable> runnable = new SelectorCacheKeyDeleter(aSelector);
   NS_DispatchToCurrentThread(runnable);
 }
 struct nsIDocument::FrameRequest
 {
   FrameRequest(const FrameRequestCallbackHolder& aCallback,
                int32_t aHandle) :
     mCallback(aCallback),
     mHandle(aHandle)
   {}
   // Conversion operator so that we can append these to a
   // FrameRequestCallbackList
   operator const FrameRequestCallbackHolder& () const {
     return mCallback;
   }
   // Comparator operators to allow RemoveElementSorted with an
   // integer argument on arrays of FrameRequest
   bool operator==(int32_t aHandle) const {
     return mHandle == aHandle;
   }
   bool operator<(int32_t aHandle) const {
     return mHandle < aHandle;
   }
   FrameRequestCallbackHolder mCallback;
   int32_t mHandle;
 };
 static already_AddRefed<nsINodeInfo> nullNodeInfo(nullptr);
 // ==================================================================
 // =
 // ==================================================================
 nsIDocument::nsIDocument()
   : nsINode(nullNodeInfo),
     mCharacterSet(NS_LITERAL_CSTRING("ISO-8859-1")),
     mNodeInfoManager(nullptr),
     mCompatMode(eCompatibility_FullStandards),
     mVisibilityState(dom::VisibilityState::Hidden),
     mIsInitialDocumentInWindow(false),
     mMayStartLayout(true),
     mVisible(true),
     mRemovedFromDocShell(false),
     // mAllowDNSPrefetch starts true, so that we can always reliably && it
     // with various values that might disable it.  Since we never prefetch
     // unless we get a window, and in that case the docshell value will get
     // &&-ed in, this is safe.
     mAllowDNSPrefetch(true),
     mIsBeingUsedAsImage(false),
     mHasLinksToUpdate(false),
     mPartID(0),
     mDidFireDOMContentLoaded(true)
 {
   SetInDocument();
 }
 // NOTE! nsDocument::operator new() zeroes out all members, so don't
 // bother initializing members to 0.
 nsDocument::nsDocument(const char* aContentType)
   : nsIDocument()
   , mAnimatingImages(true)
   , mViewportType(Unknown)
 {
   SetContentTypeInternal(nsDependentCString(aContentType));
 #ifdef PR_LOGGING
   if (!gDocumentLeakPRLog)
     gDocumentLeakPRLog = PR_NewLogModule("DocumentLeak");
   if (gDocumentLeakPRLog)
     PR_LOG(gDocumentLeakPRLog, PR_LOG_DEBUG,
            ("DOCUMENT %p created", this));
   if (!gCspPRLog)
     gCspPRLog = PR_NewLogModule("CSP");
 #endif
   // Start out mLastStyleSheetSet as null, per spec
   SetDOMStringToNull(mLastStyleSheetSet);
   if (sProcessingStack.empty()) {
     sProcessingStack.construct();
     // Add the base queue sentinel to the processing stack.
     sProcessingStack.ref().AppendElement((CustomElementData*) nullptr);
   }
 }
 static PLDHashOperator
 ClearAllBoxObjects(nsIContent* aKey, nsPIBoxObject* aBoxObject, void* aUserArg)
 {
   if (aBoxObject) {
     aBoxObject->Clear();
   }
   return PL_DHASH_NEXT;
 }
 nsIDocument::~nsIDocument()
 {
   if (mNodeInfoManager) {
     mNodeInfoManager->DropDocumentReference();
   }
 }
 nsDocument::~nsDocument()
 {
 #ifdef PR_LOGGING
   if (gDocumentLeakPRLog)
     PR_LOG(gDocumentLeakPRLog, PR_LOG_DEBUG,
            ("DOCUMENT %p destroyed", this));
 #endif
   NS_ASSERTION(!mIsShowing, "Destroying a currently-showing document");
   if (IsTopLevelContentDocument()) {
     //don't report for about: pages
     nsCOMPtr<nsIPrincipal> principal = GetPrincipal();
     nsCOMPtr<nsIURI> uri;
     principal->GetURI(getter_AddRefs(uri));
     bool isAboutScheme = true;
     if (uri) {
       uri->SchemeIs("about", &isAboutScheme);
     }
     if (!isAboutScheme) {
       // Record the page load
       uint32_t pageLoaded = 1;
       Accumulate(Telemetry::MIXED_CONTENT_UNBLOCK_COUNTER, pageLoaded);
       // Record the mixed content status of the docshell in Telemetry
       enum {
         NO_MIXED_CONTENT = 0, // There is no Mixed Content on the page
         MIXED_DISPLAY_CONTENT = 1, // The page attempted to load Mixed Display Content
         MIXED_ACTIVE_CONTENT = 2, // The page attempted to load Mixed Active Content
         MIXED_DISPLAY_AND_ACTIVE_CONTENT = 3 // The page attempted to load Mixed Display & Mixed Active Content
       };
       bool mixedActiveLoaded = GetHasMixedActiveContentLoaded();
       bool mixedActiveBlocked = GetHasMixedActiveContentBlocked();
       bool mixedDisplayLoaded = GetHasMixedDisplayContentLoaded();
       bool mixedDisplayBlocked = GetHasMixedDisplayContentBlocked();
       bool hasMixedDisplay = (mixedDisplayBlocked || mixedDisplayLoaded);
       bool hasMixedActive = (mixedActiveBlocked || mixedActiveLoaded);
       uint32_t mixedContentLevel = NO_MIXED_CONTENT;
       if (hasMixedDisplay && hasMixedActive) {
         mixedContentLevel = MIXED_DISPLAY_AND_ACTIVE_CONTENT;
       } else if (hasMixedActive){
         mixedContentLevel = MIXED_ACTIVE_CONTENT;
       } else if (hasMixedDisplay) {
         mixedContentLevel = MIXED_DISPLAY_CONTENT;
       }
       Accumulate(Telemetry::MIXED_CONTENT_PAGE_LOAD, mixedContentLevel);
     }
   }
   mInDestructor = true;
   mInUnlinkOrDeletion = true;
   mRegistry = nullptr;
   mozilla::DropJSObjects(this);
   // Clear mObservers to keep it in sync with the mutationobserver list
   mObservers.Clear();
   if (mStyleSheetSetList) {
     mStyleSheetSetList->Disconnect();
   }
   if (mAnimationController) {
     mAnimationController->Disconnect();
   }
   mParentDocument = nullptr;
   // Kill the subdocument map, doing this will release its strong
   // references, if any.
   if (mSubDocuments) {
     PL_DHashTableDestroy(mSubDocuments);
     mSubDocuments = nullptr;
   }
   // Destroy link map now so we don't waste time removing
   // links one by one
   DestroyElementMaps();
   nsAutoScriptBlocker scriptBlocker;
   int32_t indx; // must be signed
   uint32_t count = mChildren.ChildCount();
   for (indx = int32_t(count) - 1; indx >= 0; --indx) {
     mChildren.ChildAt(indx)->UnbindFromTree();
     mChildren.RemoveChildAt(indx);
   }
   mFirstChild = nullptr;
   mCachedRootElement = nullptr;
   // Let the stylesheets know we're going away
   indx = mStyleSheets.Count();
   while (--indx >= 0) {
     mStyleSheets[indx]->SetOwningDocument(nullptr);
   }
   indx = mCatalogSheets.Count();
   while (--indx >= 0) {
     static_cast<nsCSSStyleSheet*>(mCatalogSheets[indx])->SetOwningNode(nullptr);
     mCatalogSheets[indx]->SetOwningDocument(nullptr);
   }
   if (mAttrStyleSheet) {
     mAttrStyleSheet->SetOwningDocument(nullptr);
   }
   if (mListenerManager) {
     mListenerManager->Disconnect();
     UnsetFlags(NODE_HAS_LISTENERMANAGER);
   }
   if (mScriptLoader) {
     mScriptLoader->DropDocumentReference();
   }
   if (mCSSLoader) {
     // Could be null here if Init() failed
     mCSSLoader->DropDocumentReference();
   }
   if (mStyleImageLoader) {
     mStyleImageLoader->DropDocumentReference();
   }
   delete mHeaderData;
   if (mBoxObjectTable) {
     mBoxObjectTable->EnumerateRead(ClearAllBoxObjects, nullptr);
     delete mBoxObjectTable;
   }
   mPendingTitleChangeEvent.Revoke();
   for (uint32_t i = 0; i < mHostObjectURIs.Length(); ++i) {
     nsHostObjectProtocolHandler::RemoveDataEntry(mHostObjectURIs[i]);
   }
   // We don't want to leave residual locks on images. Make sure we're in an
   // unlocked state, and then clear the table.
   SetImageLockingState(false);
   mImageTracker.Clear();
   mPlugins.Clear();
 }
 NS_INTERFACE_TABLE_HEAD(nsDocument)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_TABLE_BEGIN
     NS_INTERFACE_TABLE_ENTRY_AMBIGUOUS(nsDocument, nsISupports, nsINode)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsINode)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDocument)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocument)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMNode)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMDocumentXBL)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIScriptObjectPrincipal)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMEventTarget)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, mozilla::dom::EventTarget)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsISupportsWeakReference)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIRadioGroupContainer)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIMutationObserver)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIApplicationCacheContainer)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIObserver)
     NS_INTERFACE_TABLE_ENTRY(nsDocument, nsIDOMXPathEvaluator)
   NS_INTERFACE_TABLE_END
   NS_INTERFACE_TABLE_TO_MAP_SEGUE_CYCLE_COLLECTION(nsDocument)
   NS_INTERFACE_MAP_ENTRY_TEAROFF(nsIDOMXPathNSResolver,
                                  new nsNode3Tearoff(this))
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDocument)
 NS_IMETHODIMP_(MozExternalRefCountType)
 nsDocument::Release()
 {
   NS_PRECONDITION(0 != mRefCnt, "dup release");
   NS_ASSERT_OWNINGTHREAD(nsDocument);
   nsISupports* base = NS_CYCLE_COLLECTION_CLASSNAME(nsDocument)::Upcast(this);
   bool shouldDelete = false;
   nsrefcnt count = mRefCnt.decr(base, &shouldDelete);
   NS_LOG_RELEASE(this, count, "nsDocument");
   if (count == 0) {
     if (mStackRefCnt && !mNeedsReleaseAfterStackRefCntRelease) {
       mNeedsReleaseAfterStackRefCntRelease = true;
       NS_ADDREF_THIS();
       return mRefCnt.get();
     }
     mRefCnt.incr(base);
     nsNodeUtils::LastRelease(this);
     mRefCnt.decr(base);
     if (shouldDelete) {
       mRefCnt.stabilizeForDeletion();
       DeleteCycleCollectable();
     }
   }
   return count;
 }
 NS_IMETHODIMP_(void)
 nsDocument::DeleteCycleCollectable()
 {
   delete this;
 }
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(nsDocument)
   if (Element::CanSkip(tmp, aRemovingAllowed)) {
     EventListenerManager* elm = tmp->GetExistingListenerManager();
     if (elm) {
       elm->MarkForCC();
     }
     return true;
   }
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(nsDocument)
   return Element::CanSkipInCC(tmp);
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(nsDocument)
   return Element::CanSkipThis(tmp);
 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
 static PLDHashOperator
 SubDocTraverser(PLDHashTable *table, PLDHashEntryHdr *hdr, uint32_t number,
                 void *arg)
 {
   SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(arg);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mKey");
   cb->NoteXPCOMChild(entry->mKey);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mSubDocuments entry->mSubDocument");
   cb->NoteXPCOMChild(entry->mSubDocument);
   return PL_DHASH_NEXT;
 }
 static PLDHashOperator
 RadioGroupsTraverser(const nsAString& aKey, nsRadioGroupStruct* aData,
                      void* aClosure)
 {
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
                                    "mRadioGroups entry->mSelectedRadioButton");
   cb->NoteXPCOMChild(ToSupports(aData->mSelectedRadioButton));
   uint32_t i, count = aData->mRadioButtons.Count();
   for (i = 0; i < count; ++i) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
                                        "mRadioGroups entry->mRadioButtons[i]");
     cb->NoteXPCOMChild(aData->mRadioButtons[i]);
   }
   return PL_DHASH_NEXT;
 }
 static PLDHashOperator
 BoxObjectTraverser(nsIContent* key, nsPIBoxObject* boxObject, void* userArg)
 {
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(userArg);
   NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mBoxObjectTable entry");
   cb->NoteXPCOMChild(boxObject);
   return PL_DHASH_NEXT;
 }
 static PLDHashOperator
 IdentifierMapEntryTraverse(nsIdentifierMapEntry *aEntry, void *aArg)
 {
   nsCycleCollectionTraversalCallback *cb =
     static_cast<nsCycleCollectionTraversalCallback*>(aArg);
   aEntry->Traverse(cb);
   return PL_DHASH_NEXT;
 }
 static const char* kNSURIs[] = {
   "([none])",
   "(xmlns)",
   "(xml)",
   "(xhtml)",
   "(XLink)",
   "(XSLT)",
   "(XBL)",
   "(MathML)",
   "(RDF)",
   "(XUL)"
 };
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(nsDocument)
   if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
     char name[512];
     nsAutoCString loadedAsData;
     if (tmp->IsLoadedAsData()) {
       loadedAsData.AssignLiteral("data");
     } else {
       loadedAsData.AssignLiteral("normal");
     }
     uint32_t nsid = tmp->GetDefaultNamespaceID();
     nsAutoCString uri;
     if (tmp->mDocumentURI)
       tmp->mDocumentURI->GetSpec(uri);
     if (nsid < ArrayLength(kNSURIs)) {
       PR_snprintf(name, sizeof(name), "nsDocument %s %s %s",
                   loadedAsData.get(), kNSURIs[nsid], uri.get());
     }
     else {
       PR_snprintf(name, sizeof(name), "nsDocument %s %s",
                   loadedAsData.get(), uri.get());
     }
     cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
   }
   else {
     NS_IMPL_CYCLE_COLLECTION_DESCRIBE(nsDocument, tmp->mRefCnt.get())
   }
   // Always need to traverse script objects, so do that before we check
   // if we're uncollectable.
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
   if (!nsINode::Traverse(tmp, cb)) {
     return NS_SUCCESS_INTERRUPTED_TRAVERSE;
   }
   tmp->mIdentifierMap.EnumerateEntries(IdentifierMapEntryTraverse, &cb);
   tmp->mExternalResourceMap.Traverse(&cb);
   // Traverse the mChildren nsAttrAndChildArray.
   for (int32_t indx = int32_t(tmp->mChildren.ChildCount()); indx > 0; --indx) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mChildren[i]");
     cb.NoteXPCOMChild(tmp->mChildren.ChildAt(indx - 1));
   }
   // Traverse all nsIDocument pointer members.
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSecurityInfo)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDisplayDocument)
   // Traverse all nsDocument nsCOMPtrs.
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParser)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScriptGlobalObject)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDOMStyleSheets)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheetSetList)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mScriptLoader)
   tmp->mRadioGroups.EnumerateRead(RadioGroupsTraverser, &cb);
   // The boxobject for an element will only exist as long as it's in the
   // document, so we'll traverse the table here instead of from the element.
   if (tmp->mBoxObjectTable) {
     tmp->mBoxObjectTable->EnumerateRead(BoxObjectTraverser, &cb);
   }
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChannel)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleAttrStyleSheet)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mXPathEvaluator)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLayoutHistoryState)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOnloadBlocker)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFirstBaseNodeWithHref)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDOMImplementation)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mImageMaps)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOriginalDocument)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCachedEncoder)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStateObjectCached)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUndoManager)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTemplateContentsOwner)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildrenCollection)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRegistry)
   // Traverse all our nsCOMArrays.
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheets)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCatalogSheets)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPreloadingImages)
   for (uint32_t i = 0; i < tmp->mFrameRequestCallbacks.Length(); ++i) {
     NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mFrameRequestCallbacks[i]");
     cb.NoteXPCOMChild(tmp->mFrameRequestCallbacks[i].mCallback.GetISupports());
   }
   // Traverse animation components
   if (tmp->mAnimationController) {
     tmp->mAnimationController->Traverse(&cb);
   }
   if (tmp->mSubDocuments && tmp->mSubDocuments->ops) {
     PL_DHashTableEnumerate(tmp->mSubDocuments, SubDocTraverser, &cb);
   }
   if (tmp->mCSSLoader) {
     tmp->mCSSLoader->TraverseCachedSheets(cb);
   }
   for (uint32_t i = 0; i < tmp->mHostObjectURIs.Length(); ++i) {
     nsHostObjectProtocolHandler::Traverse(tmp->mHostObjectURIs[i], cb);
   }
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_CLASS(nsDocument)
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsDocument)
   if (tmp->PreservingWrapper()) {
     NS_IMPL_CYCLE_COLLECTION_TRACE_JSVAL_MEMBER_CALLBACK(mExpandoAndGeneration.expando);
   }
   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsDocument)
   tmp->mInUnlinkOrDeletion = true;
   // Clear out our external resources
   tmp->mExternalResourceMap.Shutdown();
   nsAutoScriptBlocker scriptBlocker;
   nsINode::Unlink(tmp);
   // Unlink the mChildren nsAttrAndChildArray.
   for (int32_t indx = int32_t(tmp->mChildren.ChildCount()) - 1;
        indx >= 0; --indx) {
     tmp->mChildren.ChildAt(indx)->UnbindFromTree();
     tmp->mChildren.RemoveChildAt(indx);
   }
   tmp->mFirstChild = nullptr;
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mXPathEvaluator)
   tmp->mCachedRootElement = nullptr; // Avoid a dangling pointer
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDisplayDocument)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFirstBaseNodeWithHref)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDOMImplementation)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mImageMaps)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mOriginalDocument)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mCachedEncoder)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mUndoManager)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTemplateContentsOwner)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mChildrenCollection)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mRegistry)
   tmp->mParentDocument = nullptr;
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mPreloadingImages)
   if (tmp->mBoxObjectTable) {
    tmp->mBoxObjectTable->EnumerateRead(ClearAllBoxObjects, nullptr);
    delete tmp->mBoxObjectTable;
    tmp->mBoxObjectTable = nullptr;
  }
   if (tmp->mListenerManager) {
     tmp->mListenerManager->Disconnect();
     tmp->UnsetFlags(NODE_HAS_LISTENERMANAGER);
     tmp->mListenerManager = nullptr;
   }
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mDOMStyleSheets)
   if (tmp->mStyleSheetSetList) {
     tmp->mStyleSheetSetList->Disconnect();
     tmp->mStyleSheetSetList = nullptr;
   }
   if (tmp->mSubDocuments) {
     PL_DHashTableDestroy(tmp->mSubDocuments);
     tmp->mSubDocuments = nullptr;
   }
   tmp->mFrameRequestCallbacks.Clear();
   tmp->mRadioGroups.Clear();
   // nsDocument has a pretty complex destructor, so we're going to
   // assume that *most* cycles you actually want to break somewhere
   // else, and not unlink an awful lot here.
   tmp->mIdentifierMap.Clear();
   tmp->mExpandoAndGeneration.Unlink();
   if (tmp->mAnimationController) {
     tmp->mAnimationController->Unlink();
   }
   tmp->mPendingTitleChangeEvent.Revoke();
   if (tmp->mCSSLoader) {
     tmp->mCSSLoader->UnlinkCachedSheets();
   }
   for (uint32_t i = 0; i < tmp->mHostObjectURIs.Length(); ++i) {
     nsHostObjectProtocolHandler::RemoveDataEntry(tmp->mHostObjectURIs[i]);
   }
   tmp->mInUnlinkOrDeletion = false;
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 static bool sPrefsInitialized = false;
 static uint32_t sOnloadDecodeLimit = 0;
 nsresult
 nsDocument::Init()
 {
   if (mCSSLoader || mStyleImageLoader || mNodeInfoManager || mScriptLoader) {
     return NS_ERROR_ALREADY_INITIALIZED;
   }
   if (!sPrefsInitialized) {
     sPrefsInitialized = true;
     Preferences::AddUintVarCache(&sOnloadDecodeLimit, "image.onload.decode.limit", 0);
   }
   // Force initialization.
   nsINode::nsSlots* slots = Slots();
   // Prepend self as mutation-observer whether we need it or not (some
   // subclasses currently do, other don't). This is because the code in
   // nsNodeUtils always notifies the first observer first, expecting the
   // first observer to be the document.
   NS_ENSURE_TRUE(slots->mMutationObservers.PrependElementUnlessExists(static_cast<nsIMutationObserver*>(this)),
                  NS_ERROR_OUT_OF_MEMORY);
   mOnloadBlocker = new nsOnloadBlocker();
   mCSSLoader = new mozilla::css::Loader(this);
   // Assume we're not quirky, until we know otherwise
   mCSSLoader->SetCompatibilityMode(eCompatibility_FullStandards);
   mStyleImageLoader = new mozilla::css::ImageLoader(this);
   mNodeInfoManager = new nsNodeInfoManager();
   nsresult rv = mNodeInfoManager->Init(this);
   NS_ENSURE_SUCCESS(rv, rv);
   // mNodeInfo keeps NodeInfoManager alive!
   mNodeInfo = mNodeInfoManager->GetDocumentNodeInfo();
   NS_ENSURE_TRUE(mNodeInfo, NS_ERROR_OUT_OF_MEMORY);
   NS_ABORT_IF_FALSE(mNodeInfo->NodeType() == nsIDOMNode::DOCUMENT_NODE,
                     "Bad NodeType in aNodeInfo");
   NS_ASSERTION(OwnerDoc() == this, "Our nodeinfo is busted!");
   // If after creation the owner js global is not set for a document
   // we use the default compartment for this document, instead of creating
   // wrapper in some random compartment when the document is exposed to js
   // via some events.
   nsCOMPtr<nsIGlobalObject> global = xpc::GetJunkScopeGlobal();
   NS_ENSURE_TRUE(global, NS_ERROR_FAILURE);
   mScopeObject = do_GetWeakReference(global);
   MOZ_ASSERT(mScopeObject);
   mScriptLoader = new nsScriptLoader(this);
   mozilla::HoldJSObjects(this);
   return NS_OK;
 }
 void
 nsIDocument::DeleteAllProperties()
 {
   for (uint32_t i = 0; i < GetPropertyTableCount(); ++i) {
     PropertyTable(i)->DeleteAllProperties();
   }
 }
 void
 nsIDocument::DeleteAllPropertiesFor(nsINode* aNode)
 {
   for (uint32_t i = 0; i < GetPropertyTableCount(); ++i) {
     PropertyTable(i)->DeleteAllPropertiesFor(aNode);
   }
 }
 nsPropertyTable*
 nsIDocument::GetExtraPropertyTable(uint16_t aCategory)
 {
   NS_ASSERTION(aCategory > 0, "Category 0 should have already been handled");
   while (aCategory >= mExtraPropertyTables.Length() + 1) {
     mExtraPropertyTables.AppendElement(new nsPropertyTable());
   }
   return mExtraPropertyTables[aCategory - 1];
 }
 bool
 nsIDocument::IsVisibleConsideringAncestors() const
 {
   const nsIDocument *parent = this;
   do {
     if (!parent->IsVisible()) {
       return false;
     }
   } while ((parent = parent->GetParentDocument()));
   return true;
       }
 void
 nsDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
 {
   nsCOMPtr<nsIURI> uri;
   nsCOMPtr<nsIPrincipal> principal;
   if (aChannel) {
     // Note: this code is duplicated in XULDocument::StartDocumentLoad and
     // nsScriptSecurityManager::GetChannelPrincipal.
     // Note: this should match nsDocShell::OnLoadingSite
     NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
     nsIScriptSecurityManager *securityManager =
       nsContentUtils::GetSecurityManager();
     if (securityManager) {
       securityManager->GetChannelPrincipal(aChannel,
                                            getter_AddRefs(principal));
     }
   }
   ResetToURI(uri, aLoadGroup, principal);
   nsCOMPtr<nsIPropertyBag2> bag = do_QueryInterface(aChannel);
   if (bag) {
     nsCOMPtr<nsIURI> baseURI;
     bag->GetPropertyAsInterface(NS_LITERAL_STRING("baseURI"),
                                 NS_GET_IID(nsIURI), getter_AddRefs(baseURI));
     if (baseURI) {
       mDocumentBaseURI = baseURI;
       mChromeXHRDocBaseURI = baseURI;
     }
   }
   mChannel = aChannel;
 }
 void
 nsDocument::ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup,
                        nsIPrincipal* aPrincipal)
 {
   NS_PRECONDITION(aURI, "Null URI passed to ResetToURI");
 #ifdef PR_LOGGING
   if (gDocumentLeakPRLog && PR_LOG_TEST(gDocumentLeakPRLog, PR_LOG_DEBUG)) {
     nsAutoCString spec;
     aURI->GetSpec(spec);
     PR_LogPrint("DOCUMENT %p ResetToURI %s", this, spec.get());
   }
 #endif
   mSecurityInfo = nullptr;
   mDocumentLoadGroup = nullptr;
   // Delete references to sub-documents and kill the subdocument map,
   // if any. It holds strong references
   if (mSubDocuments) {
     PL_DHashTableDestroy(mSubDocuments);
     mSubDocuments = nullptr;
   }
   // Destroy link map now so we don't waste time removing
   // links one by one
   DestroyElementMaps();
   bool oldVal = mInUnlinkOrDeletion;
   mInUnlinkOrDeletion = true;
   uint32_t count = mChildren.ChildCount();
   { // Scope for update
     MOZ_AUTO_DOC_UPDATE(this, UPDATE_CONTENT_MODEL, true);
     for (int32_t i = int32_t(count) - 1; i >= 0; i--) {
       nsCOMPtr<nsIContent> content = mChildren.ChildAt(i);
       nsIContent* previousSibling = content->GetPreviousSibling();
       if (nsINode::GetFirstChild() == content) {
         mFirstChild = content->GetNextSibling();
       }
       mChildren.RemoveChildAt(i);
       nsNodeUtils::ContentRemoved(this, content, i, previousSibling);
       content->UnbindFromTree();
     }
     mCachedRootElement = nullptr;
   }
   mInUnlinkOrDeletion = oldVal;
   mRegistry = nullptr;
   // Reset our stylesheets
   ResetStylesheetsToURI(aURI);
   // Release the listener manager
   if (mListenerManager) {
     mListenerManager->Disconnect();
     mListenerManager = nullptr;
   }
   // Release the stylesheets list.
   mDOMStyleSheets = nullptr;
   // Release our principal after tearing down the document, rather than before.
   // This ensures that, during teardown, the document and the dying window (which
   // already nulled out its document pointer and cached the principal) have
   // matching principals.
   SetPrincipal(nullptr);
   // Clear the original URI so SetDocumentURI sets it.
   mOriginalURI = nullptr;
   SetDocumentURI(aURI);
   mChromeXHRDocURI = aURI;
   // If mDocumentBaseURI is null, nsIDocument::GetBaseURI() returns
   // mDocumentURI.
   mDocumentBaseURI = nullptr;
   mChromeXHRDocBaseURI = nullptr;
   if (aLoadGroup) {
     mDocumentLoadGroup = do_GetWeakReference(aLoadGroup);
     // there was an assertion here that aLoadGroup was not null.  This
     // is no longer valid: nsDocShell::SetDocument does not create a
     // load group, and it works just fine
     // XXXbz what does "just fine" mean exactly?  And given that there
     // is no nsDocShell::SetDocument, what is this talking about?
   }
   mLastModified.Truncate();
   // XXXbz I guess we're assuming that the caller will either pass in
   // a channel with a useful type or call SetContentType?
   SetContentTypeInternal(EmptyCString());
   mContentLanguage.Truncate();
   mBaseTarget.Truncate();
   mReferrer.Truncate();
   mXMLDeclarationBits = 0;
   // Now get our new principal
   if (aPrincipal) {
     SetPrincipal(aPrincipal);
   } else {
     nsIScriptSecurityManager *securityManager =
       nsContentUtils::GetSecurityManager();
     if (securityManager) {
       nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
       if (!docShell && aLoadGroup) {
         nsCOMPtr<nsIInterfaceRequestor> cbs;
         aLoadGroup->GetNotificationCallbacks(getter_AddRefs(cbs));
         docShell = do_GetInterface(cbs);
       }
       MOZ_ASSERT(docShell,
                  "must be in a docshell or pass in an explicit principal");
       nsCOMPtr<nsIPrincipal> principal;
       nsresult rv = securityManager->
         GetDocShellCodebasePrincipal(mDocumentURI, docShell,
                                      getter_AddRefs(principal));
       if (NS_SUCCEEDED(rv)) {
         SetPrincipal(principal);
       }
     }
   }
   // Refresh the principal on the compartment.
   nsPIDOMWindow* win = GetInnerWindow();
   if (win) {
     win->RefreshCompartmentPrincipal();
   }
 }
 void
 nsDocument::RemoveDocStyleSheetsFromStyleSets()
 {
   // The stylesheets should forget us
   int32_t indx = mStyleSheets.Count();
   while (--indx >= 0) {
     nsIStyleSheet* sheet = mStyleSheets[indx];
     sheet->SetOwningDocument(nullptr);
     if (sheet->IsApplicable()) {
       nsCOMPtr<nsIPresShell> shell = GetShell();
       if (shell) {
         shell->StyleSet()->RemoveDocStyleSheet(sheet);
       }
     }
     // XXX Tell observers?
   }
 }
 void
 nsDocument::RemoveStyleSheetsFromStyleSets(nsCOMArray<nsIStyleSheet>& aSheets, nsStyleSet::sheetType aType)
 {
   // The stylesheets should forget us
   int32_t indx = aSheets.Count();
   while (--indx >= 0) {
     nsIStyleSheet* sheet = aSheets[indx];
     sheet->SetOwningDocument(nullptr);
     if (sheet->IsApplicable()) {
       nsCOMPtr<nsIPresShell> shell = GetShell();
       if (shell) {
         shell->StyleSet()->RemoveStyleSheet(aType, sheet);
       }
     }
     // XXX Tell observers?
   }
 }
 void
 nsDocument::ResetStylesheetsToURI(nsIURI* aURI)
 {
   MOZ_ASSERT(aURI);
   mozAutoDocUpdate upd(this, UPDATE_STYLE, true);
   RemoveDocStyleSheetsFromStyleSets();
   RemoveStyleSheetsFromStyleSets(mCatalogSheets, nsStyleSet::eAgentSheet);
   RemoveStyleSheetsFromStyleSets(mAdditionalSheets[eAgentSheet], nsStyleSet::eAgentSheet);
   RemoveStyleSheetsFromStyleSets(mAdditionalSheets[eUserSheet], nsStyleSet::eUserSheet);
   RemoveStyleSheetsFromStyleSets(mAdditionalSheets[eAuthorSheet], nsStyleSet::eDocSheet);
   // Release all the sheets
   mStyleSheets.Clear();
   for (uint32_t i = 0; i < SheetTypeCount; ++i)
     mAdditionalSheets[i].Clear();
   // NOTE:  We don't release the catalog sheets.  It doesn't really matter
   // now, but it could in the future -- in which case not releasing them
   // is probably the right thing to do.
   // Now reset our inline style and attribute sheets.
   if (mAttrStyleSheet) {
     mAttrStyleSheet->Reset();
     mAttrStyleSheet->SetOwningDocument(this);
   } else {
     mAttrStyleSheet = new nsHTMLStyleSheet(this);
   }
   if (!mStyleAttrStyleSheet) {
     mStyleAttrStyleSheet = new nsHTMLCSSStyleSheet();
   }
   // Now set up our style sets
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     FillStyleSet(shell->StyleSet());
   }
 }
 static bool
 AppendAuthorSheet(nsIStyleSheet *aSheet, void *aData)
 {
   nsStyleSet *styleSet = static_cast<nsStyleSet*>(aData);
   styleSet->AppendStyleSheet(nsStyleSet::eDocSheet, aSheet);
   return true;
 }
 static void
 AppendSheetsToStyleSet(nsStyleSet* aStyleSet,
                        const nsCOMArray<nsIStyleSheet>& aSheets,
                        nsStyleSet::sheetType aType)
 {
   for (int32_t i = aSheets.Count() - 1; i >= 0; --i) {
     aStyleSet->AppendStyleSheet(aType, aSheets[i]);
   }
 }
 void
 nsDocument::FillStyleSet(nsStyleSet* aStyleSet)
 {
   NS_PRECONDITION(aStyleSet, "Must have a style set");
   NS_PRECONDITION(aStyleSet->SheetCount(nsStyleSet::eDocSheet) == 0,
                   "Style set already has document sheets?");
   // We could consider moving this to nsStyleSet::Init, to match its
   // handling of the eAnimationSheet and eTransitionSheet levels.
   aStyleSet->DirtyRuleProcessors(nsStyleSet::ePresHintSheet);
   aStyleSet->DirtyRuleProcessors(nsStyleSet::eStyleAttrSheet);
   int32_t i;
   for (i = mStyleSheets.Count() - 1; i >= 0; --i) {
     nsIStyleSheet* sheet = mStyleSheets[i];
     if (sheet->IsApplicable()) {
       aStyleSet->AddDocStyleSheet(sheet, this);
     }
   }
   nsStyleSheetService *sheetService = nsStyleSheetService::GetInstance();
   if (sheetService) {
     sheetService->AuthorStyleSheets()->EnumerateForwards(AppendAuthorSheet,
                                                          aStyleSet);
   }
   for (i = mCatalogSheets.Count() - 1; i >= 0; --i) {
     nsIStyleSheet* sheet = mCatalogSheets[i];
     if (sheet->IsApplicable()) {
       aStyleSet->AppendStyleSheet(nsStyleSet::eAgentSheet, sheet);
     }
   }
   AppendSheetsToStyleSet(aStyleSet, mAdditionalSheets[eAgentSheet],
                          nsStyleSet::eAgentSheet);
   AppendSheetsToStyleSet(aStyleSet, mAdditionalSheets[eUserSheet],
                          nsStyleSet::eUserSheet);
   AppendSheetsToStyleSet(aStyleSet, mAdditionalSheets[eAuthorSheet],
                          nsStyleSet::eDocSheet);
 }
 nsresult
 nsDocument::StartDocumentLoad(const char* aCommand, nsIChannel* aChannel,
                               nsILoadGroup* aLoadGroup,
                               nsISupports* aContainer,
                               nsIStreamListener **aDocListener,
                               bool aReset, nsIContentSink* aSink)
 {
 #ifdef PR_LOGGING
   if (gDocumentLeakPRLog && PR_LOG_TEST(gDocumentLeakPRLog, PR_LOG_DEBUG)) {
     nsCOMPtr<nsIURI> uri;
     aChannel->GetURI(getter_AddRefs(uri));
     nsAutoCString spec;
     if (uri)
       uri->GetSpec(spec);
     PR_LogPrint("DOCUMENT %p StartDocumentLoad %s", this, spec.get());
   }
 #endif
 #ifdef DEBUG
   {
     uint32_t appId;
     nsresult rv = NodePrincipal()->GetAppId(&appId);
     NS_ENSURE_SUCCESS(rv, rv);
     MOZ_ASSERT(appId != nsIScriptSecurityManager::UNKNOWN_APP_ID,
                "Document should never have UNKNOWN_APP_ID");
   }
 #endif
   MOZ_ASSERT(GetReadyStateEnum() == nsIDocument::READYSTATE_UNINITIALIZED,
              "Bad readyState");
   SetReadyStateInternal(READYSTATE_LOADING);
   if (nsCRT::strcmp(kLoadAsData, aCommand) == 0) {
     mLoadedAsData = true;
     // We need to disable script & style loading in this case.
     // We leave them disabled even in EndLoad(), and let anyone
     // who puts the document on display to worry about enabling.
     // Do not load/process scripts when loading as data
     ScriptLoader()->SetEnabled(false);
     // styles
     CSSLoader()->SetEnabled(false); // Do not load/process styles when loading as data
   } else if (nsCRT::strcmp("external-resource", aCommand) == 0) {
     // Allow CSS, but not scripts
     ScriptLoader()->SetEnabled(false);
   }
   mMayStartLayout = false;
   mHaveInputEncoding = true;
   if (aReset) {
     Reset(aChannel, aLoadGroup);
   }
   nsAutoCString contentType;
   nsCOMPtr<nsIPropertyBag2> bag = do_QueryInterface(aChannel);
   if ((bag && NS_SUCCEEDED(bag->GetPropertyAsACString(
                 NS_LITERAL_STRING("contentType"), contentType))) ||
       NS_SUCCEEDED(aChannel->GetContentType(contentType))) {
     // XXX this is only necessary for viewsource:
     nsACString::const_iterator start, end, semicolon;
     contentType.BeginReading(start);
     contentType.EndReading(end);
     semicolon = start;
     FindCharInReadable(';', semicolon, end);
     SetContentTypeInternal(Substring(start, semicolon));
   }
   RetrieveRelevantHeaders(aChannel);
   mChannel = aChannel;
   nsCOMPtr<nsIInputStreamChannel> inStrmChan = do_QueryInterface(mChannel);
   if (inStrmChan) {
     bool isSrcdocChannel;
     inStrmChan->GetIsSrcdocChannel(&isSrcdocChannel);
     if (isSrcdocChannel) {
       mIsSrcdocDocument = true;
     }
   }
   // If this document is being loaded by a docshell, copy its sandbox flags
   // to the document. These are immutable after being set here.
   nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(aContainer);
   if (docShell) {
     nsresult rv = docShell->GetSandboxFlags(&mSandboxFlags);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // If this is not a data document, set CSP.
   if (!mLoadedAsData) {
     nsresult rv = InitCSP(aChannel);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }
 void
 CSPErrorQueue::Add(const char* aMessageName)
 {
   mErrors.AppendElement(aMessageName);
 }
 void
 CSPErrorQueue::Flush(nsIDocument* aDocument)
 {
   for (uint32_t i = 0; i < mErrors.Length(); i++) {
     nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
         NS_LITERAL_CSTRING("CSP"), aDocument,
         nsContentUtils::eSECURITY_PROPERTIES,
         mErrors[i]);
   }
   mErrors.Clear();
 }
 void
 nsDocument::SendToConsole(nsCOMArray<nsISecurityConsoleMessage>& aMessages)
 {
   for (uint32_t i = 0; i < aMessages.Length(); ++i) {
     nsAutoString messageTag;
     aMessages[i]->GetTag(messageTag);
     nsAutoString category;
     aMessages[i]->GetCategory(category);
     nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                     NS_ConvertUTF16toUTF8(category),
                                     this, nsContentUtils::eSECURITY_PROPERTIES,
                                     NS_ConvertUTF16toUTF8(messageTag).get());
   }
 }
 static nsresult
 AppendCSPFromHeader(nsIContentSecurityPolicy* csp, const nsAString& aHeaderValue,
                     nsIURI* aSelfURI, bool aReportOnly, bool aSpecCompliant)
 {
   // Need to tokenize the header value since multiple headers could be
   // concatenated into one comma-separated list of policies.
   // See RFC2616 section 4.2 (last paragraph)
   nsresult rv = NS_OK;
   nsCharSeparatedTokenizer tokenizer(aHeaderValue, ',');
   while (tokenizer.hasMoreTokens()) {
       const nsSubstring& policy = tokenizer.nextToken();
       rv = csp->AppendPolicy(policy, aSelfURI, aReportOnly, aSpecCompliant);
       NS_ENSURE_SUCCESS(rv, rv);
 #ifdef PR_LOGGING
       {
         PR_LOG(gCspPRLog, PR_LOG_DEBUG,
                 ("CSP refined with policy: \"%s\"",
                 NS_ConvertUTF16toUTF8(policy).get()));
       }
 #endif
   }
   return NS_OK;
 }
 nsresult
 nsDocument::InitCSP(nsIChannel* aChannel)
 {
   nsCOMPtr<nsIContentSecurityPolicy> csp;
   if (!CSPService::sCSPEnabled) {
 #ifdef PR_LOGGING
     PR_LOG(gCspPRLog, PR_LOG_DEBUG,
            ("CSP is disabled, skipping CSP init for document %p", this));
 #endif
     return NS_OK;
   }
   nsAutoCString tCspHeaderValue, tCspROHeaderValue;
   nsAutoCString tCspOldHeaderValue, tCspOldROHeaderValue;
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
   if (httpChannel) {
     httpChannel->GetResponseHeader(
         NS_LITERAL_CSTRING("x-content-security-policy"),
         tCspOldHeaderValue);
     httpChannel->GetResponseHeader(
         NS_LITERAL_CSTRING("x-content-security-policy-report-only"),
         tCspOldROHeaderValue);
     httpChannel->GetResponseHeader(
         NS_LITERAL_CSTRING("content-security-policy"),
         tCspHeaderValue);
     httpChannel->GetResponseHeader(
         NS_LITERAL_CSTRING("content-security-policy-report-only"),
         tCspROHeaderValue);
   }
   NS_ConvertASCIItoUTF16 cspHeaderValue(tCspHeaderValue);
   NS_ConvertASCIItoUTF16 cspROHeaderValue(tCspROHeaderValue);
   NS_ConvertASCIItoUTF16 cspOldHeaderValue(tCspOldHeaderValue);
   NS_ConvertASCIItoUTF16 cspOldROHeaderValue(tCspOldROHeaderValue);
   // Only use the CSP 1.0 spec compliant headers if a pref to do so
   // is set. This lets us turn on the 1.0 parser per platform. This
   // pref is also set by the tests for 1.0 spec compliant CSP.
   bool specCompliantEnabled =
     Preferences::GetBool("security.csp.speccompliant");
   // If spec compliant pref isn't set, pretend we never got these headers.
   if ((!cspHeaderValue.IsEmpty() || !cspROHeaderValue.IsEmpty()) &&
        !specCompliantEnabled) {
     PR_LOG(gCspPRLog, PR_LOG_DEBUG,
             ("Got spec compliant CSP headers but pref was not set"));
     cspHeaderValue.Truncate();
     cspROHeaderValue.Truncate();
   }
   // If both the new header AND the old header are present, warn that
   // the old header will be ignored. Otherwise, if the old header is
   // present, warn that it will be deprecated.
   bool oldHeaderIsPresent = !cspOldHeaderValue.IsEmpty() || !cspOldROHeaderValue.IsEmpty();
   bool newHeaderIsPresent = !cspHeaderValue.IsEmpty() || !cspROHeaderValue.IsEmpty();
   if (oldHeaderIsPresent && newHeaderIsPresent) {
     mCSPWebConsoleErrorQueue.Add("BothCSPHeadersPresent");
   } else if (oldHeaderIsPresent) {
     mCSPWebConsoleErrorQueue.Add("OldCSPHeaderDeprecated");
   }
   // Figure out if we need to apply an app default CSP or a CSP from an app manifest
   nsIPrincipal* principal = NodePrincipal();
   uint16_t appStatus = principal->GetAppStatus();
   bool applyAppDefaultCSP = appStatus == nsIPrincipal::APP_STATUS_PRIVILEGED ||
                             appStatus == nsIPrincipal::APP_STATUS_CERTIFIED;
   bool applyAppManifestCSP = false;
   nsAutoString appManifestCSP;
   if (appStatus != nsIPrincipal::APP_STATUS_NOT_INSTALLED) {
     nsCOMPtr<nsIAppsService> appsService = do_GetService(APPS_SERVICE_CONTRACTID);
     if (appsService) {
       uint32_t appId = 0;
       if (NS_SUCCEEDED(principal->GetAppId(&appId))) {
         appsService->GetCSPByLocalId(appId, appManifestCSP);
         if (!appManifestCSP.IsEmpty()) {
           applyAppManifestCSP = true;
         }
       }
     }
   }
   // If there's no CSP to apply, go ahead and return early
   if (!applyAppDefaultCSP &&
       !applyAppManifestCSP &&
       cspHeaderValue.IsEmpty() &&
       cspROHeaderValue.IsEmpty() &&
       cspOldHeaderValue.IsEmpty() &&
       cspOldROHeaderValue.IsEmpty()) {
 #ifdef PR_LOGGING
     nsCOMPtr<nsIURI> chanURI;
     aChannel->GetURI(getter_AddRefs(chanURI));
     nsAutoCString aspec;
     chanURI->GetAsciiSpec(aspec);
     PR_LOG(gCspPRLog, PR_LOG_DEBUG,
            ("no CSP for document, %s, %s",
             aspec.get(),
             applyAppDefaultCSP ? "is app" : "not an app"));
 #endif
     return NS_OK;
   }
 #ifdef PR_LOGGING
   PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("Document is an app or CSP header specified %p", this));
 #endif
   nsresult rv;
   // If Document is an app check to see if we already set CSP and return early
   // if that is indeed the case.
   //
   // In general (see bug 947831), we should not be setting CSP on a principal
   // that aliases another document. For non-app code this is not a problem
   // since we only share the underlying principal with nested browsing
   // contexts for which a header cannot be set (e.g., about:blank and
   // about:srcodoc iframes) and thus won't try to set the CSP again. This
   // check ensures that we do not try to set CSP for an app.
   if (applyAppDefaultCSP || applyAppManifestCSP) {
     nsCOMPtr<nsIContentSecurityPolicy> csp;
     rv = principal->GetCsp(getter_AddRefs(csp));
     NS_ENSURE_SUCCESS(rv, rv);
     if (csp) {
 #ifdef PR_LOGGING
       PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("%s %s %s",
            "This document is sharing principal with another document.",
            "Since the document is an app, CSP was already set.",
            "Skipping attempt to set CSP."));
 #endif
       return NS_OK;
     }
   }
   // create new CSP object
   csp = do_CreateInstance("@mozilla.org/contentsecuritypolicy;1", &rv);
   if (NS_FAILED(rv)) {
 #ifdef PR_LOGGING
     PR_LOG(gCspPRLog, PR_LOG_DEBUG, ("Failed to create CSP object: %x", rv));
 #endif
     return rv;
   }
   // used as a "self" identifier for the CSP.
   nsCOMPtr<nsIURI> selfURI;
   aChannel->GetURI(getter_AddRefs(selfURI));
   // Store the request context for violation reports
   csp->SetRequestContext(nullptr, nullptr, nullptr, aChannel);
   // ----- if the doc is an app and we want a default CSP, apply it.
   if (applyAppDefaultCSP) {
     nsAdoptingString appCSP;
     if (appStatus ==  nsIPrincipal::APP_STATUS_PRIVILEGED) {
       appCSP = Preferences::GetString("security.apps.privileged.CSP.default");
       NS_ASSERTION(appCSP, "App, but no default CSP in security.apps.privileged.CSP.default");
     } else if (appStatus == nsIPrincipal::APP_STATUS_CERTIFIED) {
       appCSP = Preferences::GetString("security.apps.certified.CSP.default");
       NS_ASSERTION(appCSP, "App, but no default CSP in security.apps.certified.CSP.default");
     }
     if (appCSP) {
       // Use the 1.0 CSP parser for apps if the pref to do so is set.
       csp->AppendPolicy(appCSP, selfURI, false, specCompliantEnabled);
     }
   }
   // ----- if the doc is an app and specifies a CSP in its manifest, apply it.
   if (applyAppManifestCSP) {
     // Use the 1.0 CSP parser for apps if the pref to do so is set.
     csp->AppendPolicy(appManifestCSP, selfURI, false, specCompliantEnabled);
   }
   // While we are supporting both CSP 1.0 and the x- headers, the 1.0 headers
   // take priority.  If both are present, the x-* headers are ignored.
   // ----- if there's a full-strength CSP header, apply it.
   if (!cspHeaderValue.IsEmpty()) {
     rv = AppendCSPFromHeader(csp, cspHeaderValue, selfURI, false, true);
     NS_ENSURE_SUCCESS(rv, rv);
   } else if (!cspOldHeaderValue.IsEmpty()) {
     rv = AppendCSPFromHeader(csp, cspOldHeaderValue, selfURI, false, false);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // ----- if there's a report-only CSP header, apply it.
   if (!cspROHeaderValue.IsEmpty()) {
     rv = AppendCSPFromHeader(csp, cspROHeaderValue, selfURI, true, true);
     NS_ENSURE_SUCCESS(rv, rv);
   } else if (!cspOldROHeaderValue.IsEmpty()) {
     rv = AppendCSPFromHeader(csp, cspOldROHeaderValue, selfURI, true, false);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // ----- Enforce frame-ancestor policy on any applied policies
   nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
   if (docShell) {
     bool safeAncestry = false;
     // PermitsAncestry sends violation reports when necessary
     rv = csp->PermitsAncestry(docShell, &safeAncestry);
     NS_ENSURE_SUCCESS(rv, rv);
     if (!safeAncestry) {
 #ifdef PR_LOGGING
       PR_LOG(gCspPRLog, PR_LOG_DEBUG,
               ("CSP doesn't like frame's ancestry, not loading."));
 #endif
       // stop!  ERROR page!
       aChannel->Cancel(NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION);
     }
   }
   rv = principal->SetCsp(csp);
   NS_ENSURE_SUCCESS(rv, rv);
 #ifdef PR_LOGGING
   PR_LOG(gCspPRLog, PR_LOG_DEBUG,
          ("Inserted CSP into principal %p", principal));
 #endif
   return NS_OK;
 }
 void
 nsDocument::StopDocumentLoad()
 {
   if (mParser) {
     mParserAborted = true;
     mParser->Terminate();
   }
 }
 void
 nsDocument::SetDocumentURI(nsIURI* aURI)
 {
   nsCOMPtr<nsIURI> oldBase = GetDocBaseURI();
   mDocumentURI = NS_TryToMakeImmutable(aURI);
   nsIURI* newBase = GetDocBaseURI();
   bool equalBases = false;
   // Changing just the ref of a URI does not change how relative URIs would
   // resolve wrt to it, so we can treat the bases as equal as long as they're
   // equal ignoring the ref.
   if (oldBase && newBase) {
     oldBase->EqualsExceptRef(newBase, &equalBases);
   }
   else {
     equalBases = !oldBase && !newBase;
   }
   // If this is the first time we're setting the document's URI, set the
   // document's original URI.
   if (!mOriginalURI)
     mOriginalURI = mDocumentURI;
   // If changing the document's URI changed the base URI of the document, we
   // need to refresh the hrefs of all the links on the page.
   if (!equalBases) {
     RefreshLinkHrefs();
   }
 }
 void
 nsDocument::SetChromeXHRDocURI(nsIURI* aURI)
 {
   mChromeXHRDocURI = aURI;
 }
 void
 nsDocument::SetChromeXHRDocBaseURI(nsIURI* aURI)
 {
   mChromeXHRDocBaseURI = aURI;
 }
 NS_IMETHODIMP
 nsDocument::GetLastModified(nsAString& aLastModified)
 {
   nsIDocument::GetLastModified(aLastModified);
   return NS_OK;
 }
 void
 nsIDocument::GetLastModified(nsAString& aLastModified) const
 {
   if (!mLastModified.IsEmpty()) {
     aLastModified.Assign(mLastModified);
   } else {
     // If we for whatever reason failed to find the last modified time
     // (or even the current time), fall back to what NS4.x returned.
     aLastModified.Assign(NS_LITERAL_STRING("01/01/1970 00:00:00"));
   }
 }
 void
 nsDocument::AddToNameTable(Element *aElement, nsIAtom* aName)
 {
   MOZ_ASSERT(nsGenericHTMLElement::ShouldExposeNameAsHTMLDocumentProperty(aElement),
              "Only put elements that need to be exposed as document['name'] in "
              "the named table.");
   nsIdentifierMapEntry *entry =
     mIdentifierMap.PutEntry(nsDependentAtomString(aName));
   // Null for out-of-memory
   if (entry) {
     if (!entry->HasNameElement() &&
         !entry->HasIdElementExposedAsHTMLDocumentProperty()) {
       ++mExpandoAndGeneration.generation;
     }
     entry->AddNameElement(this, aElement);
   }
 }
 void
 nsDocument::RemoveFromNameTable(Element *aElement, nsIAtom* aName)
 {
   // Speed up document teardown
   if (mIdentifierMap.Count() == 0)
     return;
   nsIdentifierMapEntry *entry =
     mIdentifierMap.GetEntry(nsDependentAtomString(aName));
   if (!entry) // Could be false if the element was anonymous, hence never added
     return;
   entry->RemoveNameElement(aElement);
   if (!entry->HasNameElement() &&
       !entry->HasIdElementExposedAsHTMLDocumentProperty()) {
     ++mExpandoAndGeneration.generation;
   }
 }
 void
 nsDocument::AddToIdTable(Element *aElement, nsIAtom* aId)
 {
   nsIdentifierMapEntry *entry =
     mIdentifierMap.PutEntry(nsDependentAtomString(aId));
   if (entry) { /* True except on OOM */
     if (nsGenericHTMLElement::ShouldExposeIdAsHTMLDocumentProperty(aElement) &&
         !entry->HasNameElement() &&
         !entry->HasIdElementExposedAsHTMLDocumentProperty()) {
       ++mExpandoAndGeneration.generation;
     }
     entry->AddIdElement(aElement);
   }
 }
 void
 nsDocument::RemoveFromIdTable(Element *aElement, nsIAtom* aId)
 {
   NS_ASSERTION(aId, "huhwhatnow?");
   // Speed up document teardown
   if (mIdentifierMap.Count() == 0) {
     return;
   }
   nsIdentifierMapEntry *entry =
     mIdentifierMap.GetEntry(nsDependentAtomString(aId));
   if (!entry) // Can be null for XML elements with changing ids.
     return;
   entry->RemoveIdElement(aElement);
   if (nsGenericHTMLElement::ShouldExposeIdAsHTMLDocumentProperty(aElement) &&
       !entry->HasNameElement() &&
       !entry->HasIdElementExposedAsHTMLDocumentProperty()) {
     ++mExpandoAndGeneration.generation;
   }
   if (entry->IsEmpty()) {
     mIdentifierMap.RawRemoveEntry(entry);
   }
 }
 nsIPrincipal*
 nsDocument::GetPrincipal()
 {
   return NodePrincipal();
 }
 extern bool sDisablePrefetchHTTPSPref;
 void
 nsDocument::SetPrincipal(nsIPrincipal *aNewPrincipal)
 {
   if (aNewPrincipal && mAllowDNSPrefetch && sDisablePrefetchHTTPSPref) {
     nsCOMPtr<nsIURI> uri;
     aNewPrincipal->GetURI(getter_AddRefs(uri));
     bool isHTTPS;
     if (!uri || NS_FAILED(uri->SchemeIs("https", &isHTTPS)) ||
         isHTTPS) {
       mAllowDNSPrefetch = false;
     }
   }
   mNodeInfoManager->SetDocumentPrincipal(aNewPrincipal);
 }
 NS_IMETHODIMP
 nsDocument::GetApplicationCache(nsIApplicationCache **aApplicationCache)
 {
   NS_IF_ADDREF(*aApplicationCache = mApplicationCache);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::SetApplicationCache(nsIApplicationCache *aApplicationCache)
 {
   mApplicationCache = aApplicationCache;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetContentType(nsAString& aContentType)
 {
   CopyUTF8toUTF16(GetContentTypeInternal(), aContentType);
   return NS_OK;
 }
 void
 nsDocument::SetContentType(const nsAString& aContentType)
 {
   NS_ASSERTION(GetContentTypeInternal().IsEmpty() ||
                GetContentTypeInternal().Equals(NS_ConvertUTF16toUTF8(aContentType)),
                "Do you really want to change the content-type?");
   SetContentTypeInternal(NS_ConvertUTF16toUTF8(aContentType));
 }
 nsresult
 nsDocument::GetAllowPlugins(bool * aAllowPlugins)
 {
   // First, we ask our docshell if it allows plugins.
   nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
   if (docShell) {
     docShell->GetAllowPlugins(aAllowPlugins);
     // If the docshell allows plugins, we check whether
     // we are sandboxed and plugins should not be allowed.
     if (*aAllowPlugins)
       *aAllowPlugins = !(mSandboxFlags & SANDBOXED_PLUGINS);
   }
   return NS_OK;
 }
 already_AddRefed<UndoManager>
 nsDocument::GetUndoManager()
 {
   Element* rootElement = GetRootElement();
   if (!rootElement) {
     return nullptr;
   }
   if (!mUndoManager) {
     mUndoManager = new UndoManager(rootElement);
   }
   nsRefPtr<UndoManager> undoManager = mUndoManager;
   return undoManager.forget();
 }
 /* Return true if the document is in the focused top-level window, and is an
  * ancestor of the focused DOMWindow. */
 NS_IMETHODIMP
 nsDocument::HasFocus(bool* aResult)
 {
   ErrorResult rv;
   *aResult = nsIDocument::HasFocus(rv);
   return rv.ErrorCode();
 }
 bool
 nsIDocument::HasFocus(ErrorResult& rv) const
 {
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     rv.Throw(NS_ERROR_NOT_AVAILABLE);
     return false;
   }
   // Is there a focused DOMWindow?
   nsCOMPtr<nsIDOMWindow> focusedWindow;
   fm->GetFocusedWindow(getter_AddRefs(focusedWindow));
   if (!focusedWindow) {
     return false;
   }
   // Are we an ancestor of the focused DOMWindow?
   nsCOMPtr<nsIDOMDocument> domDocument;
   focusedWindow->GetDocument(getter_AddRefs(domDocument));
   nsCOMPtr<nsIDocument> document = do_QueryInterface(domDocument);
   for (nsIDocument* currentDoc = document; currentDoc;
        currentDoc = currentDoc->GetParentDocument()) {
     if (currentDoc == this) {
       // Yes, we are an ancestor
       return true;
     }
   }
   return false;
 }
 NS_IMETHODIMP
 nsDocument::GetReferrer(nsAString& aReferrer)
 {
   nsIDocument::GetReferrer(aReferrer);
   return NS_OK;
 }
 void
 nsIDocument::GetReferrer(nsAString& aReferrer) const
 {
   if (mIsSrcdocDocument && mParentDocument)
       mParentDocument->GetReferrer(aReferrer);
   else
     CopyUTF8toUTF16(mReferrer, aReferrer);
 }
 nsresult
 nsIDocument::GetSrcdocData(nsAString &aSrcdocData)
 {
   if (mIsSrcdocDocument) {
     nsCOMPtr<nsIInputStreamChannel> inStrmChan = do_QueryInterface(mChannel);
     if (inStrmChan) {
       return inStrmChan->GetSrcdocData(aSrcdocData);
     }
   }
   aSrcdocData = NullString();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetActiveElement(nsIDOMElement **aElement)
 {
   nsCOMPtr<nsIDOMElement> el(do_QueryInterface(nsIDocument::GetActiveElement()));
   el.forget(aElement);
   return NS_OK;
 }
 Element*
 nsIDocument::GetActiveElement()
 {
   // Get the focused element.
   nsCOMPtr<nsPIDOMWindow> window = GetWindow();
   if (window) {
     nsCOMPtr<nsPIDOMWindow> focusedWindow;
     nsIContent* focusedContent =
       nsFocusManager::GetFocusedDescendant(window, false,
                                            getter_AddRefs(focusedWindow));
     // be safe and make sure the element is from this document
     if (focusedContent && focusedContent->OwnerDoc() == this) {
       if (focusedContent->ChromeOnlyAccess()) {
         focusedContent = focusedContent->FindFirstNonChromeOnlyAccessContent();
       }
       if (focusedContent) {
         return focusedContent->AsElement();
       }
     }
   }
   // No focused element anywhere in this document.  Try to get the BODY.
   nsRefPtr<nsHTMLDocument> htmlDoc = AsHTMLDocument();
   if (htmlDoc) {
     // Because of IE compatibility, return null when html document doesn't have
     // a body.
     return htmlDoc->GetBody();
   }
   // If we couldn't get a BODY, return the root element.
   return GetDocumentElement();
 }
 NS_IMETHODIMP
 nsDocument::GetCurrentScript(nsIDOMElement **aElement)
 {
   nsCOMPtr<nsIDOMElement> el(do_QueryInterface(nsIDocument::GetCurrentScript()));
   el.forget(aElement);
   return NS_OK;
 }
 Element*
 nsIDocument::GetCurrentScript()
 {
   nsCOMPtr<Element> el(do_QueryInterface(ScriptLoader()->GetCurrentScript()));
   return el;
 }
 NS_IMETHODIMP
 nsDocument::ElementFromPoint(float aX, float aY, nsIDOMElement** aReturn)
 {
   Element* el = nsIDocument::ElementFromPoint(aX, aY);
   nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(el);
   retval.forget(aReturn);
   return NS_OK;
 }
 Element*
 nsIDocument::ElementFromPoint(float aX, float aY)
 {
   return ElementFromPointHelper(aX, aY, false, true);
 }
 Element*
 nsDocument::ElementFromPointHelper(float aX, float aY,
                                    bool aIgnoreRootScrollFrame,
                                    bool aFlushLayout)
 {
   // As per the the spec, we return null if either coord is negative
   if (!aIgnoreRootScrollFrame && (aX < 0 || aY < 0)) {
     return nullptr;
   }
   nscoord x = nsPresContext::CSSPixelsToAppUnits(aX);
   nscoord y = nsPresContext::CSSPixelsToAppUnits(aY);
   nsPoint pt(x, y);
   // Make sure the layout information we get is up-to-date, and
   // ensure we get a root frame (for everything but XUL)
   if (aFlushLayout)
     FlushPendingNotifications(Flush_Layout);
   nsIPresShell *ps = GetShell();
   if (!ps) {
     return nullptr;
   }
   nsIFrame *rootFrame = ps->GetRootFrame();
   // XUL docs, unlike HTML, have no frame tree until everything's done loading
   if (!rootFrame) {
     return nullptr; // return null to premature XUL callers as a reminder to wait
   }
   nsIFrame *ptFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, pt,
     nsLayoutUtils::IGNORE_PAINT_SUPPRESSION | nsLayoutUtils::IGNORE_CROSS_DOC |
     (aIgnoreRootScrollFrame ? nsLayoutUtils::IGNORE_ROOT_SCROLL_FRAME : 0));
   if (!ptFrame) {
     return nullptr;
   }
   nsIContent* elem = GetContentInThisDocument(ptFrame);
   if (elem && !elem->IsElement()) {
     elem = elem->GetParent();
   }
   return elem ? elem->AsElement() : nullptr;
 }
 nsresult
 nsDocument::NodesFromRectHelper(float aX, float aY,
                                 float aTopSize, float aRightSize,
                                 float aBottomSize, float aLeftSize,
                                 bool aIgnoreRootScrollFrame,
                                 bool aFlushLayout,
                                 nsIDOMNodeList** aReturn)
 {
   NS_ENSURE_ARG_POINTER(aReturn);
   nsSimpleContentList* elements = new nsSimpleContentList(this);
   NS_ADDREF(elements);
   *aReturn = elements;
   // Following the same behavior of elementFromPoint,
   // we don't return anything if either coord is negative
   if (!aIgnoreRootScrollFrame && (aX < 0 || aY < 0))
     return NS_OK;
   nscoord x = nsPresContext::CSSPixelsToAppUnits(aX - aLeftSize);
   nscoord y = nsPresContext::CSSPixelsToAppUnits(aY - aTopSize);
   nscoord w = nsPresContext::CSSPixelsToAppUnits(aLeftSize + aRightSize) + 1;
   nscoord h = nsPresContext::CSSPixelsToAppUnits(aTopSize + aBottomSize) + 1;
   nsRect rect(x, y, w, h);
   // Make sure the layout information we get is up-to-date, and
   // ensure we get a root frame (for everything but XUL)
   if (aFlushLayout) {
     FlushPendingNotifications(Flush_Layout);
   }
   nsIPresShell *ps = GetShell();
   NS_ENSURE_STATE(ps);
   nsIFrame *rootFrame = ps->GetRootFrame();
   // XUL docs, unlike HTML, have no frame tree until everything's done loading
   if (!rootFrame)
     return NS_OK; // return nothing to premature XUL callers as a reminder to wait
   nsAutoTArray<nsIFrame*,8> outFrames;
   nsLayoutUtils::GetFramesForArea(rootFrame, rect, outFrames,
     nsLayoutUtils::IGNORE_PAINT_SUPPRESSION | nsLayoutUtils::IGNORE_CROSS_DOC |
     (aIgnoreRootScrollFrame ? nsLayoutUtils::IGNORE_ROOT_SCROLL_FRAME : 0));
   // Used to filter out repeated elements in sequence.
   nsIContent* lastAdded = nullptr;
   for (uint32_t i = 0; i < outFrames.Length(); i++) {
     nsIContent* node = GetContentInThisDocument(outFrames[i]);
     if (node && !node->IsElement() && !node->IsNodeOfType(nsINode::eTEXT)) {
       // We have a node that isn't an element or a text node,
       // use its parent content instead.
       node = node->GetParent();
     }
     if (node && node != lastAdded) {
       elements->AppendElement(node);
       lastAdded = node;
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetElementsByClassName(const nsAString& aClasses,
                                    nsIDOMNodeList** aReturn)
 {
   *aReturn = nsIDocument::GetElementsByClassName(aClasses).take();
   return NS_OK;
 }
 already_AddRefed<nsContentList>
 nsIDocument::GetElementsByClassName(const nsAString& aClasses)
 {
   return nsContentUtils::GetElementsByClassName(this, aClasses);
 }
 NS_IMETHODIMP
 nsDocument::ReleaseCapture()
 {
   nsIDocument::ReleaseCapture();
   return NS_OK;
 }
 void
 nsIDocument::ReleaseCapture() const
 {
   // only release the capture if the caller can access it. This prevents a
   // page from stopping a scrollbar grab for example.
   nsCOMPtr<nsINode> node = nsIPresShell::GetCapturingContent();
   if (node && nsContentUtils::CanCallerAccess(node)) {
     nsIPresShell::SetCapturingContent(nullptr, 0);
   }
 }
 already_AddRefed<nsIURI>
 nsIDocument::GetBaseURI(bool aTryUseXHRDocBaseURI) const
 {
   nsCOMPtr<nsIURI> uri;
   if (aTryUseXHRDocBaseURI && mChromeXHRDocBaseURI) {
     uri = mChromeXHRDocBaseURI;
   } else {
     uri = GetDocBaseURI();
   }
   return uri.forget();
 }
 nsresult
 nsDocument::SetBaseURI(nsIURI* aURI)
 {
   if (!aURI && !mDocumentBaseURI) {
     return NS_OK;
   }
   // Don't do anything if the URI wasn't actually changed.
   if (aURI && mDocumentBaseURI) {
     bool equalBases = false;
     mDocumentBaseURI->Equals(aURI, &equalBases);
     if (equalBases) {
       return NS_OK;
     }
   }
   if (aURI) {
     mDocumentBaseURI = NS_TryToMakeImmutable(aURI);
   } else {
     mDocumentBaseURI = nullptr;
   }
   RefreshLinkHrefs();
   return NS_OK;
 }
 void
 nsDocument::GetBaseTarget(nsAString &aBaseTarget)
 {
   aBaseTarget = mBaseTarget;
 }
 void
 nsDocument::SetDocumentCharacterSet(const nsACString& aCharSetID)
 {
   // XXX it would be a good idea to assert the sanity of the argument,
   // but before we figure out what to do about non-Encoding Standard
   // encodings in the charset menu and in mailnews, assertions are futile.
   if (!mCharacterSet.Equals(aCharSetID)) {
     mCharacterSet = aCharSetID;
     int32_t n = mCharSetObservers.Length();
     for (int32_t i = 0; i < n; i++) {
       nsIObserver* observer = mCharSetObservers.ElementAt(i);
       observer->Observe(static_cast<nsIDocument *>(this), "charset",
                         NS_ConvertASCIItoUTF16(aCharSetID).get());
     }
   }
 }
 nsresult
 nsDocument::AddCharSetObserver(nsIObserver* aObserver)
 {
   NS_ENSURE_ARG_POINTER(aObserver);
   NS_ENSURE_TRUE(mCharSetObservers.AppendElement(aObserver), NS_ERROR_FAILURE);
   return NS_OK;
 }
 void
 nsDocument::RemoveCharSetObserver(nsIObserver* aObserver)
 {
   mCharSetObservers.RemoveElement(aObserver);
 }
 void
 nsDocument::GetHeaderData(nsIAtom* aHeaderField, nsAString& aData) const
 {
   aData.Truncate();
   const nsDocHeaderData* data = mHeaderData;
   while (data) {
     if (data->mField == aHeaderField) {
       aData = data->mData;
       break;
     }
     data = data->mNext;
   }
 }
 void
 nsDocument::SetHeaderData(nsIAtom* aHeaderField, const nsAString& aData)
 {
   if (!aHeaderField) {
     NS_ERROR("null headerField");
     return;
   }
   if (!mHeaderData) {
     if (!aData.IsEmpty()) { // don't bother storing empty string
       mHeaderData = new nsDocHeaderData(aHeaderField, aData);
     }
   }
   else {
     nsDocHeaderData* data = mHeaderData;
     nsDocHeaderData** lastPtr = &mHeaderData;
     bool found = false;
     do {  // look for existing and replace
       if (data->mField == aHeaderField) {
         if (!aData.IsEmpty()) {
           data->mData.Assign(aData);
         }
         else {  // don't store empty string
           *lastPtr = data->mNext;
           data->mNext = nullptr;
           delete data;
         }
         found = true;
         break;
       }
       lastPtr = &(data->mNext);
       data = *lastPtr;
     } while (data);
     if (!aData.IsEmpty() && !found) {
       // didn't find, append
       *lastPtr = new nsDocHeaderData(aHeaderField, aData);
     }
   }
   if (aHeaderField == nsGkAtoms::headerContentLanguage) {
     CopyUTF16toUTF8(aData, mContentLanguage);
   }
   if (aHeaderField == nsGkAtoms::headerDefaultStyle) {
     // Only mess with our stylesheets if we don't have a lastStyleSheetSet, per
     // spec.
     if (DOMStringIsNull(mLastStyleSheetSet)) {
       // Calling EnableStyleSheetsForSetInternal, not SetSelectedStyleSheetSet,
       // per spec.  The idea here is that we're changing our preferred set and
       // that shouldn't change the value of lastStyleSheetSet.  Also, we're
       // using the Internal version so we can update the CSSLoader and not have
       // to worry about null strings.
       EnableStyleSheetsForSetInternal(aData, true);
     }
   }
   if (aHeaderField == nsGkAtoms::refresh) {
     // We get into this code before we have a script global yet, so get to
     // our container via mDocumentContainer.
     nsCOMPtr<nsIRefreshURI> refresher(mDocumentContainer);
     if (refresher) {
       // Note: using mDocumentURI instead of mBaseURI here, for consistency
       // (used to just use the current URI of our webnavigation, but that
       // should really be the same thing).  Note that this code can run
       // before the current URI of the webnavigation has been updated, so we
       // can't assert equality here.
       refresher->SetupRefreshURIFromHeader(mDocumentURI, NodePrincipal(),
                                            NS_ConvertUTF16toUTF8(aData));
     }
   }
   if (aHeaderField == nsGkAtoms::headerDNSPrefetchControl &&
       mAllowDNSPrefetch) {
     // Chromium treats any value other than 'on' (case insensitive) as 'off'.
     mAllowDNSPrefetch = aData.IsEmpty() || aData.LowerCaseEqualsLiteral("on");
   }
   if (aHeaderField == nsGkAtoms::viewport ||
       aHeaderField == nsGkAtoms::handheldFriendly ||
       aHeaderField == nsGkAtoms::viewport_minimum_scale ||
       aHeaderField == nsGkAtoms::viewport_maximum_scale ||
       aHeaderField == nsGkAtoms::viewport_initial_scale ||
       aHeaderField == nsGkAtoms::viewport_height ||
       aHeaderField == nsGkAtoms::viewport_width ||
       aHeaderField ==  nsGkAtoms::viewport_user_scalable) {
     mViewportType = Unknown;
   }
 }
 void
 nsDocument::TryChannelCharset(nsIChannel *aChannel,
                               int32_t& aCharsetSource,
                               nsACString& aCharset,
                               nsHtml5TreeOpExecutor* aExecutor)
 {
   if (aChannel) {
     nsAutoCString charsetVal;
     nsresult rv = aChannel->GetContentCharset(charsetVal);
     if (NS_SUCCEEDED(rv)) {
       nsAutoCString preferred;
       if(EncodingUtils::FindEncodingForLabel(charsetVal, preferred)) {
         aCharset = preferred;
         aCharsetSource = kCharsetFromChannel;
         return;
       } else if (aExecutor && !charsetVal.IsEmpty()) {
         aExecutor->ComplainAboutBogusProtocolCharset(this);
       }
     }
   }
 }
 already_AddRefed<nsIPresShell>
 nsDocument::CreateShell(nsPresContext* aContext, nsViewManager* aViewManager,
                         nsStyleSet* aStyleSet)
 {
   // Don't add anything here.  Add it to |doCreateShell| instead.
   // This exists so that subclasses can pass other values for the 4th
   // parameter some of the time.
   return doCreateShell(aContext, aViewManager, aStyleSet,
                        eCompatibility_FullStandards);
 }
 already_AddRefed<nsIPresShell>
 nsDocument::doCreateShell(nsPresContext* aContext,
                           nsViewManager* aViewManager, nsStyleSet* aStyleSet,
                           nsCompatibility aCompatMode)
 {
   NS_ASSERTION(!mPresShell, "We have a presshell already!");
   NS_ENSURE_FALSE(GetBFCacheEntry(), nullptr);
   FillStyleSet(aStyleSet);
   nsRefPtr<PresShell> shell = new PresShell;
   shell->Init(this, aContext, aViewManager, aStyleSet, aCompatMode);
   // Note: we don't hold a ref to the shell (it holds a ref to us)
   mPresShell = shell;
   // Make sure to never paint if we belong to an invisible DocShell.
   nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
   if (docShell && docShell->IsInvisible())
     shell->SetNeverPainting(true);
   mExternalResourceMap.ShowViewers();
   MaybeRescheduleAnimationFrameNotifications();
   return shell.forget();
 }
 void
 nsDocument::MaybeRescheduleAnimationFrameNotifications()
 {
   if (!mPresShell || !IsEventHandlingEnabled()) {
     // bail out for now, until one of those conditions changes
     return;
   }
   nsRefreshDriver* rd = mPresShell->GetPresContext()->RefreshDriver();
   if (!mFrameRequestCallbacks.IsEmpty()) {
     rd->ScheduleFrameRequestCallbacks(this);
   }
 }
 void
 nsIDocument::TakeFrameRequestCallbacks(FrameRequestCallbackList& aCallbacks)
 {
   aCallbacks.AppendElements(mFrameRequestCallbacks);
   mFrameRequestCallbacks.Clear();
 }
 PLDHashOperator RequestDiscardEnumerator(imgIRequest* aKey,
                                          uint32_t aData,
                                          void* userArg)
 {
   aKey->RequestDiscard();
   return PL_DHASH_NEXT;
 }
 void
 nsDocument::DeleteShell()
 {
   mExternalResourceMap.HideViewers();
   if (IsEventHandlingEnabled()) {
     RevokeAnimationFrameNotifications();
   }
   // When our shell goes away, request that all our images be immediately
   // discarded, so we don't carry around decoded image data for a document we
   // no longer intend to paint.
   mImageTracker.EnumerateRead(RequestDiscardEnumerator, nullptr);
   mPresShell = nullptr;
 }
 void
 nsDocument::RevokeAnimationFrameNotifications()
 {
   if (!mFrameRequestCallbacks.IsEmpty()) {
     mPresShell->GetPresContext()->RefreshDriver()->
       RevokeFrameRequestCallbacks(this);
   }
 }
 static void
 SubDocClearEntry(PLDHashTable *table, PLDHashEntryHdr *entry)
 {
   SubDocMapEntry *e = static_cast<SubDocMapEntry *>(entry);
   NS_RELEASE(e->mKey);
   if (e->mSubDocument) {
     e->mSubDocument->SetParentDocument(nullptr);
     NS_RELEASE(e->mSubDocument);
   }
 }
 static bool
 SubDocInitEntry(PLDHashTable *table, PLDHashEntryHdr *entry, const void *key)
 {
   SubDocMapEntry *e =
     const_cast<SubDocMapEntry *>
               (static_cast<const SubDocMapEntry *>(entry));
   e->mKey = const_cast<Element*>(static_cast<const Element*>(key));
   NS_ADDREF(e->mKey);
   e->mSubDocument = nullptr;
   return true;
 }
 nsresult
 nsDocument::SetSubDocumentFor(Element* aElement, nsIDocument* aSubDoc)
 {
   NS_ENSURE_TRUE(aElement, NS_ERROR_UNEXPECTED);
   if (!aSubDoc) {
     // aSubDoc is nullptr, remove the mapping
     if (mSubDocuments) {
       SubDocMapEntry *entry =
         static_cast<SubDocMapEntry*>
                    (PL_DHashTableOperate(mSubDocuments, aElement,
                                          PL_DHASH_LOOKUP));
       if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
         PL_DHashTableRawRemove(mSubDocuments, entry);
       }
     }
   } else {
     if (!mSubDocuments) {
       // Create a new hashtable
       static const PLDHashTableOps hash_table_ops =
       {
         PL_DHashAllocTable,
         PL_DHashFreeTable,
         PL_DHashVoidPtrKeyStub,
         PL_DHashMatchEntryStub,
         PL_DHashMoveEntryStub,
         SubDocClearEntry,
         PL_DHashFinalizeStub,
         SubDocInitEntry
       };
       mSubDocuments = PL_NewDHashTable(&hash_table_ops, nullptr,
                                        sizeof(SubDocMapEntry), 16);
       if (!mSubDocuments) {
         return NS_ERROR_OUT_OF_MEMORY;
       }
     }
     // Add a mapping to the hash table
     SubDocMapEntry *entry =
       static_cast<SubDocMapEntry*>
                  (PL_DHashTableOperate(mSubDocuments, aElement,
                                        PL_DHASH_ADD));
     if (!entry) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     if (entry->mSubDocument) {
       entry->mSubDocument->SetParentDocument(nullptr);
       // Release the old sub document
       NS_RELEASE(entry->mSubDocument);
     }
     entry->mSubDocument = aSubDoc;
     NS_ADDREF(entry->mSubDocument);
     aSubDoc->SetParentDocument(this);
   }
   return NS_OK;
 }
 nsIDocument*
 nsDocument::GetSubDocumentFor(nsIContent *aContent) const
 {
   if (mSubDocuments && aContent->IsElement()) {
     SubDocMapEntry *entry =
       static_cast<SubDocMapEntry*>
                  (PL_DHashTableOperate(mSubDocuments, aContent->AsElement(),
                                        PL_DHASH_LOOKUP));
     if (PL_DHASH_ENTRY_IS_BUSY(entry)) {
       return entry->mSubDocument;
     }
   }
   return nullptr;
 }
 static PLDHashOperator
 FindContentEnumerator(PLDHashTable *table, PLDHashEntryHdr *hdr,
                       uint32_t number, void *arg)
 {
   SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
   FindContentData *data = static_cast<FindContentData*>(arg);
   if (entry->mSubDocument == data->mSubDocument) {
     data->mResult = entry->mKey;
     return PL_DHASH_STOP;
   }
   return PL_DHASH_NEXT;
 }
 Element*
 nsDocument::FindContentForSubDocument(nsIDocument *aDocument) const
 {
   NS_ENSURE_TRUE(aDocument, nullptr);
   if (!mSubDocuments) {
     return nullptr;
   }
   FindContentData data(aDocument);
   PL_DHashTableEnumerate(mSubDocuments, FindContentEnumerator, &data);
   return data.mResult;
 }
 bool
 nsDocument::IsNodeOfType(uint32_t aFlags) const
 {
     return !(aFlags & ~eDOCUMENT);
 }
 Element*
 nsIDocument::GetRootElement() const
 {
   return (mCachedRootElement && mCachedRootElement->GetParentNode() == this) ?
          mCachedRootElement : GetRootElementInternal();
 }
 Element*
 nsDocument::GetRootElementInternal() const
 {
   // Loop backwards because any non-elements, such as doctypes and PIs
   // are likely to appear before the root element.
   uint32_t i;
   for (i = mChildren.ChildCount(); i > 0; --i) {
     nsIContent* child = mChildren.ChildAt(i - 1);
     if (child->IsElement()) {
       const_cast<nsDocument*>(this)->mCachedRootElement = child->AsElement();
       return child->AsElement();
     }
   }
   const_cast<nsDocument*>(this)->mCachedRootElement = nullptr;
   return nullptr;
 }
 nsIContent *
 nsDocument::GetChildAt(uint32_t aIndex) const
 {
   return mChildren.GetSafeChildAt(aIndex);
 }
 int32_t
 nsDocument::IndexOf(const nsINode* aPossibleChild) const
 {
   return mChildren.IndexOfChild(aPossibleChild);
 }
 uint32_t
 nsDocument::GetChildCount() const
 {
   return mChildren.ChildCount();
 }
 nsIContent * const *
 nsDocument::GetChildArray(uint32_t* aChildCount) const
 {
   return mChildren.GetChildArray(aChildCount);
 }
 nsresult
 nsDocument::InsertChildAt(nsIContent* aKid, uint32_t aIndex,
                           bool aNotify)
 {
   if (aKid->IsElement() && GetRootElement()) {
     NS_WARNING("Inserting root element when we already have one");
     return NS_ERROR_DOM_HIERARCHY_REQUEST_ERR;
   }
   return doInsertChildAt(aKid, aIndex, aNotify, mChildren);
 }
 nsresult
 nsDocument::AppendChildTo(nsIContent* aKid, bool aNotify)
 {
   // Make sure to _not_ call the subclass InsertChildAt here.  If
   // subclasses wanted to hook into this stuff, they would have
   // overridden AppendChildTo.
   // XXXbz maybe this should just be a non-virtual method on nsINode?
   // Feels that way to me...
   return nsDocument::InsertChildAt(aKid, GetChildCount(), aNotify);
 }
 void
 nsDocument::RemoveChildAt(uint32_t aIndex, bool aNotify)
 {
   nsCOMPtr<nsIContent> oldKid = GetChildAt(aIndex);
   if (!oldKid) {
     return;
   }
   if (oldKid->IsElement()) {
     // Destroy the link map up front before we mess with the child list.
     DestroyElementMaps();
   }
   doRemoveChildAt(aIndex, aNotify, oldKid, mChildren);
   mCachedRootElement = nullptr;
 }
 int32_t
 nsDocument::GetNumberOfStyleSheets() const
 {
   return mStyleSheets.Count();
 }
 nsIStyleSheet*
 nsDocument::GetStyleSheetAt(int32_t aIndex) const
 {
   NS_ENSURE_TRUE(0 <= aIndex && aIndex < mStyleSheets.Count(), nullptr);
   return mStyleSheets[aIndex];
 }
 int32_t
 nsDocument::GetIndexOfStyleSheet(nsIStyleSheet* aSheet) const
 {
   return mStyleSheets.IndexOf(aSheet);
 }
 void
 nsDocument::AddStyleSheetToStyleSets(nsIStyleSheet* aSheet)
 {
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     shell->StyleSet()->AddDocStyleSheet(aSheet, this);
   }
 }
 #define DO_STYLESHEET_NOTIFICATION(createFunc, concreteInterface, initMethod, type, ...) \
   do {                                                                  \
     nsCOMPtr<nsIDOMEvent> event;                                        \
     nsresult rv = createFunc(getter_AddRefs(event), this,               \
                              mPresShell ?                               \
                              mPresShell->GetPresContext() : nullptr,    \
                              nullptr);                                  \
     if (NS_FAILED(rv)) {                                                \
       return;                                                           \
     }                                                                   \
     nsCOMPtr<nsIDOMCSSStyleSheet> cssSheet(do_QueryInterface(aSheet));  \
     if (!cssSheet) {                                                    \
       return;                                                           \
     }                                                                   \
     nsCOMPtr<concreteInterface> ssEvent(do_QueryInterface(event));      \
     MOZ_ASSERT(ssEvent);                                                \
     ssEvent->initMethod(NS_LITERAL_STRING(type), true, true,            \
                         cssSheet, __VA_ARGS__);                         \
     event->SetTrusted(true);                                            \
     event->SetTarget(this);                                             \
     nsRefPtr<AsyncEventDispatcher> asyncDispatcher =                    \
       new AsyncEventDispatcher(this, event);                            \
     asyncDispatcher->mDispatchChromeOnly = true;                        \
     asyncDispatcher->PostDOMEvent();                                    \
   } while (0);
 void
 nsDocument::NotifyStyleSheetAdded(nsIStyleSheet* aSheet, bool aDocumentSheet)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetAdded, (this, aSheet, aDocumentSheet));
   if (StyleSheetChangeEventsEnabled()) {
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleSheetChangeEvent,
                                nsIDOMStyleSheetChangeEvent,
                                InitStyleSheetChangeEvent,
                                "StyleSheetAdded",
                                aDocumentSheet);
   }
 }
 void
 nsDocument::NotifyStyleSheetRemoved(nsIStyleSheet* aSheet, bool aDocumentSheet)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetRemoved, (this, aSheet, aDocumentSheet));
   if (StyleSheetChangeEventsEnabled()) {
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleSheetChangeEvent,
                                nsIDOMStyleSheetChangeEvent,
                                InitStyleSheetChangeEvent,
                                "StyleSheetRemoved",
                                aDocumentSheet);
   }
 }
 void
 nsDocument::AddStyleSheet(nsIStyleSheet* aSheet)
 {
   NS_PRECONDITION(aSheet, "null arg");
   mStyleSheets.AppendObject(aSheet);
   aSheet->SetOwningDocument(this);
   if (aSheet->IsApplicable()) {
     AddStyleSheetToStyleSets(aSheet);
   }
   NotifyStyleSheetAdded(aSheet, true);
 }
 void
 nsDocument::RemoveStyleSheetFromStyleSets(nsIStyleSheet* aSheet)
 {
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     shell->StyleSet()->RemoveDocStyleSheet(aSheet);
   }
 }
 void
 nsDocument::RemoveStyleSheet(nsIStyleSheet* aSheet)
 {
   NS_PRECONDITION(aSheet, "null arg");
   nsCOMPtr<nsIStyleSheet> sheet = aSheet; // hold ref so it won't die too soon
   if (!mStyleSheets.RemoveObject(aSheet)) {
     NS_ASSERTION(mInUnlinkOrDeletion, "stylesheet not found");
     return;
   }
   if (!mIsGoingAway) {
     if (aSheet->IsApplicable()) {
       RemoveStyleSheetFromStyleSets(aSheet);
     }
     NotifyStyleSheetRemoved(aSheet, true);
   }
   aSheet->SetOwningDocument(nullptr);
 }
 void
 nsDocument::UpdateStyleSheets(nsCOMArray<nsIStyleSheet>& aOldSheets,
                               nsCOMArray<nsIStyleSheet>& aNewSheets)
 {
   BeginUpdate(UPDATE_STYLE);
   // XXX Need to set the sheet on the ownernode, if any
   NS_PRECONDITION(aOldSheets.Count() == aNewSheets.Count(),
                   "The lists must be the same length!");
   int32_t count = aOldSheets.Count();
   nsCOMPtr<nsIStyleSheet> oldSheet;
   int32_t i;
   for (i = 0; i < count; ++i) {
     oldSheet = aOldSheets[i];
     // First remove the old sheet.
     NS_ASSERTION(oldSheet, "None of the old sheets should be null");
     int32_t oldIndex = mStyleSheets.IndexOf(oldSheet);
     RemoveStyleSheet(oldSheet);  // This does the right notifications
     // Now put the new one in its place.  If it's null, just ignore it.
     nsIStyleSheet* newSheet = aNewSheets[i];
     if (newSheet) {
       mStyleSheets.InsertObjectAt(newSheet, oldIndex);
       newSheet->SetOwningDocument(this);
       if (newSheet->IsApplicable()) {
         AddStyleSheetToStyleSets(newSheet);
       }
       NotifyStyleSheetAdded(newSheet, true);
     }
   }
   EndUpdate(UPDATE_STYLE);
 }
 void
 nsDocument::InsertStyleSheetAt(nsIStyleSheet* aSheet, int32_t aIndex)
 {
   NS_PRECONDITION(aSheet, "null ptr");
   mStyleSheets.InsertObjectAt(aSheet, aIndex);
   aSheet->SetOwningDocument(this);
   if (aSheet->IsApplicable()) {
     AddStyleSheetToStyleSets(aSheet);
   }
   NotifyStyleSheetAdded(aSheet, true);
 }
 void
 nsDocument::SetStyleSheetApplicableState(nsIStyleSheet* aSheet,
                                          bool aApplicable)
 {
   NS_PRECONDITION(aSheet, "null arg");
   // If we're actually in the document style sheet list
   if (-1 != mStyleSheets.IndexOf(aSheet)) {
     if (aApplicable) {
       AddStyleSheetToStyleSets(aSheet);
     } else {
       RemoveStyleSheetFromStyleSets(aSheet);
     }
   }
   // We have to always notify, since this will be called for sheets
   // that are children of sheets in our style set, as well as some
   // sheets for nsHTMLEditor.
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleSheetApplicableStateChanged,
                                (this, aSheet, aApplicable));
   if (StyleSheetChangeEventsEnabled()) {
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleSheetApplicableStateChangeEvent,
                                nsIDOMStyleSheetApplicableStateChangeEvent,
                                InitStyleSheetApplicableStateChangeEvent,
                                "StyleSheetApplicableStateChanged",
                                aApplicable);
   }
   if (!mSSApplicableStateNotificationPending) {
     nsRefPtr<nsIRunnable> notification = NS_NewRunnableMethod(this,
       &nsDocument::NotifyStyleSheetApplicableStateChanged);
     mSSApplicableStateNotificationPending =
       NS_SUCCEEDED(NS_DispatchToCurrentThread(notification));
   }
 }
 void
 nsDocument::NotifyStyleSheetApplicableStateChanged()
 {
   mSSApplicableStateNotificationPending = false;
   nsCOMPtr<nsIObserverService> observerService =
     mozilla::services::GetObserverService();
   if (observerService) {
     observerService->NotifyObservers(static_cast<nsIDocument*>(this),
                                      "style-sheet-applicable-state-changed",
                                      nullptr);
   }
 }
 // These three functions are a lot like the implementation of the
 // corresponding API for regular stylesheets.
 int32_t
 nsDocument::GetNumberOfCatalogStyleSheets() const
 {
   return mCatalogSheets.Count();
 }
 nsIStyleSheet*
 nsDocument::GetCatalogStyleSheetAt(int32_t aIndex) const
 {
   NS_ENSURE_TRUE(0 <= aIndex && aIndex < mCatalogSheets.Count(), nullptr);
   return mCatalogSheets[aIndex];
 }
 void
 nsDocument::AddCatalogStyleSheet(nsCSSStyleSheet* aSheet)
 {
   mCatalogSheets.AppendObject(aSheet);
   aSheet->SetOwningDocument(this);
   aSheet->SetOwningNode(this);
   if (aSheet->IsApplicable()) {
     // This is like |AddStyleSheetToStyleSets|, but for an agent sheet.
     nsCOMPtr<nsIPresShell> shell = GetShell();
     if (shell) {
       shell->StyleSet()->AppendStyleSheet(nsStyleSet::eAgentSheet, aSheet);
     }
   }
   NotifyStyleSheetAdded(aSheet, false);
 }
 void
 nsDocument::EnsureCatalogStyleSheet(const char *aStyleSheetURI)
 {
   mozilla::css::Loader* cssLoader = CSSLoader();
   if (cssLoader->GetEnabled()) {
     int32_t sheetCount = GetNumberOfCatalogStyleSheets();
     for (int32_t i = 0; i < sheetCount; i++) {
       nsIStyleSheet* sheet = GetCatalogStyleSheetAt(i);
       NS_ASSERTION(sheet, "unexpected null stylesheet in the document");
       if (sheet) {
         nsAutoCString uriStr;
         sheet->GetSheetURI()->GetSpec(uriStr);
         if (uriStr.Equals(aStyleSheetURI))
           return;
       }
     }
     nsCOMPtr<nsIURI> uri;
     NS_NewURI(getter_AddRefs(uri), aStyleSheetURI);
     if (uri) {
       nsRefPtr<nsCSSStyleSheet> sheet;
       cssLoader->LoadSheetSync(uri, true, true, getter_AddRefs(sheet));
       if (sheet) {
         BeginUpdate(UPDATE_STYLE);
         AddCatalogStyleSheet(sheet);
         EndUpdate(UPDATE_STYLE);
       }
     }
   }
 }
 static nsStyleSet::sheetType
 ConvertAdditionalSheetType(nsIDocument::additionalSheetType aType)
 {
   switch(aType) {
     case nsIDocument::eAgentSheet:
       return nsStyleSet::eAgentSheet;
     case nsIDocument::eUserSheet:
       return nsStyleSet::eUserSheet;
     case nsIDocument::eAuthorSheet:
       return nsStyleSet::eDocSheet;
     default:
       NS_ASSERTION(false, "wrong type");
       // we must return something although this should never happen
       return nsStyleSet::eSheetTypeCount;
   }
 }
 static int32_t
 FindSheet(const nsCOMArray<nsIStyleSheet>& aSheets, nsIURI* aSheetURI)
 {
   for (int32_t i = aSheets.Count() - 1; i >= 0; i-- ) {
     bool bEqual;
     nsIURI* uri = aSheets[i]->GetSheetURI();
     if (uri && NS_SUCCEEDED(uri->Equals(aSheetURI, &bEqual)) && bEqual)
       return i;
   }
   return -1;
 }
 nsresult
 nsDocument::LoadAdditionalStyleSheet(additionalSheetType aType, nsIURI* aSheetURI)
 {
   NS_PRECONDITION(aSheetURI, "null arg");
   // Checking if we have loaded this one already.
   if (FindSheet(mAdditionalSheets[aType], aSheetURI) >= 0)
     return NS_ERROR_INVALID_ARG;
   // Loading the sheet sync.
   nsRefPtr<mozilla::css::Loader> loader = new mozilla::css::Loader();
   nsRefPtr<nsCSSStyleSheet> sheet;
   nsresult rv = loader->LoadSheetSync(aSheetURI, aType == eAgentSheet,
     true, getter_AddRefs(sheet));
   NS_ENSURE_SUCCESS(rv, rv);
   mAdditionalSheets[aType].AppendObject(sheet);
   sheet->SetOwningDocument(this);
   MOZ_ASSERT(sheet->IsApplicable());
   BeginUpdate(UPDATE_STYLE);
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     nsStyleSet::sheetType type = ConvertAdditionalSheetType(aType);
     shell->StyleSet()->AppendStyleSheet(type, sheet);
   }
   // Passing false, so documet.styleSheets.length will not be affected by
   // these additional sheets.
   NotifyStyleSheetAdded(sheet, false);
   EndUpdate(UPDATE_STYLE);
   return NS_OK;
 }
 void
 nsDocument::RemoveAdditionalStyleSheet(additionalSheetType aType, nsIURI* aSheetURI)
 {
   MOZ_ASSERT(aSheetURI);
   nsCOMArray<nsIStyleSheet>& sheets = mAdditionalSheets[aType];
   int32_t i = FindSheet(mAdditionalSheets[aType], aSheetURI);
   if (i >= 0) {
     nsCOMPtr<nsIStyleSheet> sheetRef = sheets[i];
     sheets.RemoveObjectAt(i);
     BeginUpdate(UPDATE_STYLE);
     if (!mIsGoingAway) {
       MOZ_ASSERT(sheetRef->IsApplicable());
       nsCOMPtr<nsIPresShell> shell = GetShell();
       if (shell) {
         nsStyleSet::sheetType type = ConvertAdditionalSheetType(aType);
         shell->StyleSet()->RemoveStyleSheet(type, sheetRef);
       }
     }
     // Passing false, so documet.styleSheets.length will not be affected by
     // these additional sheets.
     NotifyStyleSheetRemoved(sheetRef, false);
     EndUpdate(UPDATE_STYLE);
     sheetRef->SetOwningDocument(nullptr);
   }
 }
 nsIStyleSheet*
 nsDocument::FirstAdditionalAuthorSheet()
 {
   return mAdditionalSheets[eAuthorSheet].SafeObjectAt(0);
 }
 nsIGlobalObject*
 nsDocument::GetScopeObject() const
 {
   nsCOMPtr<nsIGlobalObject> scope(do_QueryReferent(mScopeObject));
   return scope;
 }
 void
 nsDocument::SetScopeObject(nsIGlobalObject* aGlobal)
 {
   mScopeObject = do_GetWeakReference(aGlobal);
   if (aGlobal) {
     mHasHadScriptHandlingObject = true;
   }
 }
 static void
 NotifyActivityChanged(nsIContent *aContent, void *aUnused)
 {
   nsCOMPtr<nsIDOMHTMLMediaElement> domMediaElem(do_QueryInterface(aContent));
   if (domMediaElem) {
     HTMLMediaElement* mediaElem = static_cast<HTMLMediaElement*>(aContent);
     mediaElem->NotifyOwnerDocumentActivityChanged();
   }
   nsCOMPtr<nsIObjectLoadingContent> objectLoadingContent(do_QueryInterface(aContent));
   if (objectLoadingContent) {
     nsObjectLoadingContent* olc = static_cast<nsObjectLoadingContent*>(objectLoadingContent.get());
     olc->NotifyOwnerDocumentActivityChanged();
   }
 }
 void
 nsIDocument::SetContainer(nsDocShell* aContainer)
 {
   if (aContainer) {
     mDocumentContainer = aContainer->asWeakPtr();
   } else {
     mDocumentContainer = WeakPtr<nsDocShell>();
   }
   EnumerateFreezableElements(NotifyActivityChanged, nullptr);
   if (!aContainer) {
     return;
   }
   // Get the Docshell
   if (aContainer->ItemType() == nsIDocShellTreeItem::typeContent) {
     // check if same type root
     nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
     aContainer->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
     NS_ASSERTION(sameTypeRoot, "No document shell root tree item from document shell tree item!");
     if (sameTypeRoot == aContainer) {
       static_cast<nsDocument*>(this)->SetIsTopLevelContentDocument(true);
     }
   }
 }
 nsISupports*
 nsIDocument::GetContainer() const
 {
   return static_cast<nsIDocShell*>(mDocumentContainer);
 }
 void
 nsDocument::SetScriptGlobalObject(nsIScriptGlobalObject *aScriptGlobalObject)
 {
 #ifdef DEBUG
   {
     nsCOMPtr<nsPIDOMWindow> win(do_QueryInterface(aScriptGlobalObject));
     NS_ASSERTION(!win || win->IsInnerWindow(),
                  "Script global object must be an inner window!");
   }
 #endif
   NS_ABORT_IF_FALSE(aScriptGlobalObject || !mAnimationController ||
                     mAnimationController->IsPausedByType(
                         nsSMILTimeContainer::PAUSE_PAGEHIDE |
                         nsSMILTimeContainer::PAUSE_BEGIN),
                     "Clearing window pointer while animations are unpaused");
   if (mScriptGlobalObject && !aScriptGlobalObject) {
     // We're detaching from the window.  We need to grab a pointer to
     // our layout history state now.
     mLayoutHistoryState = GetLayoutHistoryState();
     if (mPresShell && !EventHandlingSuppressed()) {
       RevokeAnimationFrameNotifications();
     }
     // Also make sure to remove our onload blocker now if we haven't done it yet
     if (mOnloadBlockCount != 0) {
       nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
       if (loadGroup) {
         loadGroup->RemoveRequest(mOnloadBlocker, nullptr, NS_OK);
       }
     }
   }
   mScriptGlobalObject = aScriptGlobalObject;
   if (aScriptGlobalObject) {
     mHasHadScriptHandlingObject = true;
     mHasHadDefaultView = true;
     // Go back to using the docshell for the layout history state
     mLayoutHistoryState = nullptr;
     mScopeObject = do_GetWeakReference(aScriptGlobalObject);
 #ifdef DEBUG
     if (!mWillReparent) {
       // We really shouldn't have a wrapper here but if we do we need to make sure
       // it has the correct parent.
       JSObject *obj = GetWrapperPreserveColor();
       if (obj) {
         JSObject *newScope = aScriptGlobalObject->GetGlobalJSObject();
         NS_ASSERTION(js::GetGlobalForObjectCrossCompartment(obj) == newScope,
                      "Wrong scope, this is really bad!");
       }
     }
 #endif
     if (mAllowDNSPrefetch) {
       nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
       if (docShell) {
 #ifdef DEBUG
         nsCOMPtr<nsIWebNavigation> webNav =
           do_GetInterface(aScriptGlobalObject);
         NS_ASSERTION(SameCOMIdentity(webNav, docShell),
                      "Unexpected container or script global?");
 #endif
         bool allowDNSPrefetch;
         docShell->GetAllowDNSPrefetch(&allowDNSPrefetch);
         mAllowDNSPrefetch = allowDNSPrefetch;
       }
     }
     MaybeRescheduleAnimationFrameNotifications();
     mRegistry = new Registry();
   }
   // Remember the pointer to our window (or lack there of), to avoid
   // having to QI every time it's asked for.
   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(mScriptGlobalObject);
   mWindow = window;
   // Now that we know what our window is, we can flush the CSP errors to the
   // Web Console. We are flushing all messages that occured and were stored
   // in the queue prior to this point.
   FlushCSPWebConsoleErrorQueue();
   nsCOMPtr<nsIHttpChannelInternal> internalChannel =
     do_QueryInterface(GetChannel());
   if (internalChannel) {
     nsCOMArray<nsISecurityConsoleMessage> messages;
     internalChannel->TakeAllSecurityMessages(messages);
     SendToConsole(messages);
   }
   // Set our visibility state, but do not fire the event.  This is correct
   // because either we're coming out of bfcache (in which case IsVisible() will
   // still test false at this point and no state change will happen) or we're
   // doing the initial document load and don't want to fire the event for this
   // change.
   mVisibilityState = GetVisibilityState();
 }
 nsIScriptGlobalObject*
 nsDocument::GetScriptHandlingObjectInternal() const
 {
   MOZ_ASSERT(!mScriptGlobalObject,
              "Do not call this when mScriptGlobalObject is set!");
   if (mHasHadDefaultView) {
     return nullptr;
   }
   nsCOMPtr<nsIScriptGlobalObject> scriptHandlingObject =
     do_QueryReferent(mScopeObject);
   nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(scriptHandlingObject);
   if (win) {
     NS_ASSERTION(win->IsInnerWindow(), "Should have inner window here!");
     nsPIDOMWindow* outer = win->GetOuterWindow();
     if (!outer || outer->GetCurrentInnerWindow() != win) {
       NS_WARNING("Wrong inner/outer window combination!");
       return nullptr;
     }
   }
   return scriptHandlingObject;
 }
 void
 nsDocument::SetScriptHandlingObject(nsIScriptGlobalObject* aScriptObject)
 {
   NS_ASSERTION(!mScriptGlobalObject ||
                mScriptGlobalObject == aScriptObject,
                "Wrong script object!");
   nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(aScriptObject);
   NS_ASSERTION(!win || win->IsInnerWindow(), "Should have inner window here!");
   if (aScriptObject) {
     mScopeObject = do_GetWeakReference(aScriptObject);
     mHasHadScriptHandlingObject = true;
     mHasHadDefaultView = false;
   }
 }
 bool
 nsDocument::IsTopLevelContentDocument()
 {
   return mIsTopLevelContentDocument;
 }
 void
 nsDocument::SetIsTopLevelContentDocument(bool aIsTopLevelContentDocument)
 {
   mIsTopLevelContentDocument = aIsTopLevelContentDocument;
 }
 nsPIDOMWindow *
 nsDocument::GetWindowInternal() const
 {
   MOZ_ASSERT(!mWindow, "This should not be called when mWindow is not null!");
   // Let's use mScriptGlobalObject. Even if the document is already removed from
   // the docshell, the outer window might be still obtainable from the it.
   nsCOMPtr<nsPIDOMWindow> win;
   if (mRemovedFromDocShell) {
     nsCOMPtr<nsIInterfaceRequestor> requestor(mDocumentContainer);
     if (requestor) {
       // The docshell returns the outer window we are done.
       win = do_GetInterface(requestor);
     }
   } else {
     win = do_QueryInterface(mScriptGlobalObject);
     if (win) {
       // mScriptGlobalObject is always the inner window, let's get the outer.
       win = win->GetOuterWindow();
     }
   }
   return win;
 }
 nsScriptLoader*
 nsDocument::ScriptLoader()
 {
   return mScriptLoader;
 }
 bool
 nsDocument::InternalAllowXULXBL()
 {
   if (nsContentUtils::AllowXULXBLForPrincipal(NodePrincipal())) {
     mAllowXULXBL = eTriTrue;
     return true;
   }
   mAllowXULXBL = eTriFalse;
   return false;
 }
 // Note: We don't hold a reference to the document observer; we assume
 // that it has a live reference to the document.
 void
 nsDocument::AddObserver(nsIDocumentObserver* aObserver)
 {
   NS_ASSERTION(mObservers.IndexOf(aObserver) == nsTArray<int>::NoIndex,
                "Observer already in the list");
   mObservers.AppendElement(aObserver);
   AddMutationObserver(aObserver);
 }
 bool
 nsDocument::RemoveObserver(nsIDocumentObserver* aObserver)
 {
   // If we're in the process of destroying the document (and we're
   // informing the observers of the destruction), don't remove the
   // observers from the list. This is not a big deal, since we
   // don't hold a live reference to the observers.
   if (!mInDestructor) {
     RemoveMutationObserver(aObserver);
     return mObservers.RemoveElement(aObserver);
   }
   return mObservers.Contains(aObserver);
 }
 void
 nsDocument::MaybeEndOutermostXBLUpdate()
 {
   // Only call BindingManager()->EndOutermostUpdate() when
   // we're not in an update and it is safe to run scripts.
   if (mUpdateNestLevel == 0 && mInXBLUpdate) {
     if (nsContentUtils::IsSafeToRunScript()) {
       mInXBLUpdate = false;
       BindingManager()->EndOutermostUpdate();
     } else if (!mInDestructor) {
       nsContentUtils::AddScriptRunner(
         NS_NewRunnableMethod(this, &nsDocument::MaybeEndOutermostXBLUpdate));
     }
   }
 }
 void
 nsDocument::BeginUpdate(nsUpdateType aUpdateType)
 {
   if (mUpdateNestLevel == 0 && !mInXBLUpdate) {
     mInXBLUpdate = true;
     BindingManager()->BeginOutermostUpdate();
   }
   ++mUpdateNestLevel;
   nsContentUtils::AddScriptBlocker();
   NS_DOCUMENT_NOTIFY_OBSERVERS(BeginUpdate, (this, aUpdateType));
 }
 void
 nsDocument::EndUpdate(nsUpdateType aUpdateType)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(EndUpdate, (this, aUpdateType));
   nsContentUtils::RemoveScriptBlocker();
   --mUpdateNestLevel;
   // This set of updates may have created XBL bindings.  Let the
   // binding manager know we're done.
   MaybeEndOutermostXBLUpdate();
   MaybeInitializeFinalizeFrameLoaders();
 }
 void
 nsDocument::BeginLoad()
 {
   // Block onload here to prevent having to deal with blocking and
   // unblocking it while we know the document is loading.
   BlockOnload();
   mDidFireDOMContentLoaded = false;
   BlockDOMContentLoaded();
   if (mScriptLoader) {
     mScriptLoader->BeginDeferringScripts();
   }
   NS_DOCUMENT_NOTIFY_OBSERVERS(BeginLoad, (this));
 }
 void
 nsDocument::ReportEmptyGetElementByIdArg()
 {
   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                   NS_LITERAL_CSTRING("DOM"), this,
                                   nsContentUtils::eDOM_PROPERTIES,
                                   "EmptyGetElementByIdParam");
 }
 Element*
 nsDocument::GetElementById(const nsAString& aElementId)
 {
   if (!CheckGetElementByIdArg(aElementId)) {
     return nullptr;
   }
   nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(aElementId);
   return entry ? entry->GetIdElement() : nullptr;
 }
 const nsSmallVoidArray*
 nsDocument::GetAllElementsForId(const nsAString& aElementId) const
 {
   if (aElementId.IsEmpty()) {
     return nullptr;
   }
   nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(aElementId);
   return entry ? entry->GetIdElements() : nullptr;
 }
 NS_IMETHODIMP
 nsDocument::GetElementById(const nsAString& aId, nsIDOMElement** aReturn)
 {
   Element *content = GetElementById(aId);
   if (content) {
     return CallQueryInterface(content, aReturn);
   }
   *aReturn = nullptr;
   return NS_OK;
 }
 Element*
 nsDocument::AddIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
                                 void* aData, bool aForImage)
 {
   nsDependentAtomString id(aID);
   if (!CheckGetElementByIdArg(id))
     return nullptr;
   nsIdentifierMapEntry *entry = mIdentifierMap.PutEntry(id);
   NS_ENSURE_TRUE(entry, nullptr);
   entry->AddContentChangeCallback(aObserver, aData, aForImage);
   return aForImage ? entry->GetImageIdElement() : entry->GetIdElement();
 }
 void
 nsDocument::RemoveIDTargetObserver(nsIAtom* aID, IDTargetObserver aObserver,
                                    void* aData, bool aForImage)
 {
   nsDependentAtomString id(aID);
   if (!CheckGetElementByIdArg(id))
     return;
   nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(id);
   if (!entry) {
     return;
   }
   entry->RemoveContentChangeCallback(aObserver, aData, aForImage);
 }
 NS_IMETHODIMP
 nsDocument::MozSetImageElement(const nsAString& aImageElementId,
                                nsIDOMElement* aImageElement)
 {
   nsCOMPtr<Element> el = do_QueryInterface(aImageElement);
   MozSetImageElement(aImageElementId, el);
   return NS_OK;
 }
 void
 nsDocument::MozSetImageElement(const nsAString& aImageElementId,
                                Element* aElement)
 {
   if (aImageElementId.IsEmpty())
     return;
   // Hold a script blocker while calling SetImageElement since that can call
   // out to id-observers
   nsAutoScriptBlocker scriptBlocker;
   nsIdentifierMapEntry *entry = mIdentifierMap.PutEntry(aImageElementId);
   if (entry) {
     entry->SetImageElement(aElement);
     if (entry->IsEmpty()) {
       mIdentifierMap.RemoveEntry(aImageElementId);
     }
   }
 }
 Element*
 nsDocument::LookupImageElement(const nsAString& aId)
 {
   if (aId.IsEmpty())
     return nullptr;
   nsIdentifierMapEntry *entry = mIdentifierMap.GetEntry(aId);
   return entry ? entry->GetImageIdElement() : nullptr;
 }
 void
 nsDocument::DispatchContentLoadedEvents()
 {
   // If you add early returns from this method, make sure you're
   // calling UnblockOnload properly.
   // Unpin references to preloaded images
   mPreloadingImages.Clear();
   if (mTiming) {
     mTiming->NotifyDOMContentLoadedStart(nsIDocument::GetDocumentURI());
   }
   // Dispatch observer notification to notify observers document is interactive.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   nsIPrincipal *principal = GetPrincipal();
   os->NotifyObservers(static_cast<nsIDocument*>(this),
                       nsContentUtils::IsSystemPrincipal(principal) ?
                         "chrome-document-interactive" :
                         "content-document-interactive",
                       nullptr);
   // Fire a DOM event notifying listeners that this document has been
   // loaded (excluding images and other loads initiated by this
   // document).
   nsContentUtils::DispatchTrustedEvent(this, static_cast<nsIDocument*>(this),
                                        NS_LITERAL_STRING("DOMContentLoaded"),
                                        true, true);
   if (mTiming) {
     mTiming->NotifyDOMContentLoadedEnd(nsIDocument::GetDocumentURI());
   }
   // If this document is a [i]frame, fire a DOMFrameContentLoaded
   // event on all parent documents notifying that the HTML (excluding
   // other external files such as images and stylesheets) in a frame
   // has finished loading.
   // target_frame is the [i]frame element that will be used as the
   // target for the event. It's the [i]frame whose content is done
   // loading.
   nsCOMPtr<EventTarget> target_frame;
   if (mParentDocument) {
     target_frame = mParentDocument->FindContentForSubDocument(this);
   }
   if (target_frame) {
     nsCOMPtr<nsIDocument> parent = mParentDocument;
     do {
       nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(parent);
       nsCOMPtr<nsIDOMEvent> event;
       if (domDoc) {
         domDoc->CreateEvent(NS_LITERAL_STRING("Events"),
                             getter_AddRefs(event));
       }
       if (event) {
         event->InitEvent(NS_LITERAL_STRING("DOMFrameContentLoaded"), true,
                          true);
         event->SetTarget(target_frame);
         event->SetTrusted(true);
         // To dispatch this event we must manually call
         // EventDispatcher::Dispatch() on the ancestor document since the
         // target is not in the same document, so the event would never reach
         // the ancestor document if we used the normal event
         // dispatching code.
         WidgetEvent* innerEvent = event->GetInternalNSEvent();
         if (innerEvent) {
           nsEventStatus status = nsEventStatus_eIgnore;
           nsIPresShell *shell = parent->GetShell();
           if (shell) {
             nsRefPtr<nsPresContext> context = shell->GetPresContext();
             if (context) {
               EventDispatcher::Dispatch(parent, context, innerEvent, event,
                                         &status);
             }
           }
         }
       }
       parent = parent->GetParentDocument();
     } while (parent);
   }
   // If the document has a manifest attribute, fire a MozApplicationManifest
   // event.
   Element* root = GetRootElement();
   if (root && root->HasAttr(kNameSpaceID_None, nsGkAtoms::manifest)) {
     nsContentUtils::DispatchChromeEvent(this, static_cast<nsIDocument*>(this),
                                         NS_LITERAL_STRING("MozApplicationManifest"),
                                         true, true);
   }
   UnblockOnload(true);
 }
 void
 nsDocument::EndLoad()
 {
   // Drop the ref to our parser, if any, but keep hold of the sink so that we
   // can flush it from FlushPendingNotifications as needed.  We might have to
   // do that to get a StartLayout() to happen.
   if (mParser) {
     mWeakSink = do_GetWeakReference(mParser->GetContentSink());
     mParser = nullptr;
   }
   NS_DOCUMENT_NOTIFY_OBSERVERS(EndLoad, (this));
   UnblockDOMContentLoaded();
 }
 void
 nsDocument::UnblockDOMContentLoaded()
 {
   MOZ_ASSERT(mBlockDOMContentLoaded);
   if (--mBlockDOMContentLoaded != 0 || mDidFireDOMContentLoaded) {
     return;
   }
   mDidFireDOMContentLoaded = true;
   MOZ_ASSERT(mReadyState == READYSTATE_INTERACTIVE);
   if (!mSynchronousDOMContentLoaded) {
     nsRefPtr<nsIRunnable> ev =
       NS_NewRunnableMethod(this, &nsDocument::DispatchContentLoadedEvents);
     NS_DispatchToCurrentThread(ev);
   } else {
     DispatchContentLoadedEvents();
   }
 }
 void
 nsDocument::ContentStateChanged(nsIContent* aContent, EventStates aStateMask)
 {
   NS_PRECONDITION(!nsContentUtils::IsSafeToRunScript(),
                   "Someone forgot a scriptblocker");
   NS_DOCUMENT_NOTIFY_OBSERVERS(ContentStateChanged,
                                (this, aContent, aStateMask));
 }
 void
 nsDocument::DocumentStatesChanged(EventStates aStateMask)
 {
   // Invalidate our cached state.
   mGotDocumentState &= ~aStateMask;
   mDocumentState &= ~aStateMask;
   NS_DOCUMENT_NOTIFY_OBSERVERS(DocumentStatesChanged, (this, aStateMask));
 }
 void
 nsDocument::StyleRuleChanged(nsIStyleSheet* aSheet,
                              nsIStyleRule* aOldStyleRule,
                              nsIStyleRule* aNewStyleRule)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleChanged,
                                (this, aSheet,
                                 aOldStyleRule, aNewStyleRule));
   if (StyleSheetChangeEventsEnabled()) {
     nsCOMPtr<css::Rule> rule = do_QueryInterface(aNewStyleRule);
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleRuleChangeEvent,
                                nsIDOMStyleRuleChangeEvent,
                                InitStyleRuleChangeEvent,
                                "StyleRuleChanged",
                                rule ? rule->GetDOMRule() : nullptr);
   }
 }
 void
 nsDocument::StyleRuleAdded(nsIStyleSheet* aSheet,
                            nsIStyleRule* aStyleRule)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleAdded,
                                (this, aSheet, aStyleRule));
   if (StyleSheetChangeEventsEnabled()) {
     nsCOMPtr<css::Rule> rule = do_QueryInterface(aStyleRule);
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleRuleChangeEvent,
                                nsIDOMStyleRuleChangeEvent,
                                InitStyleRuleChangeEvent,
                                "StyleRuleAdded",
                                rule ? rule->GetDOMRule() : nullptr);
   }
 }
 void
 nsDocument::StyleRuleRemoved(nsIStyleSheet* aSheet,
                              nsIStyleRule* aStyleRule)
 {
   NS_DOCUMENT_NOTIFY_OBSERVERS(StyleRuleRemoved,
                                (this, aSheet, aStyleRule));
   if (StyleSheetChangeEventsEnabled()) {
     nsCOMPtr<css::Rule> rule = do_QueryInterface(aStyleRule);
     DO_STYLESHEET_NOTIFICATION(NS_NewDOMStyleRuleChangeEvent,
                                nsIDOMStyleRuleChangeEvent,
                                InitStyleRuleChangeEvent,
                                "StyleRuleRemoved",
                                rule ? rule->GetDOMRule() : nullptr);
   }
 }
 #undef DO_STYLESHEET_NOTIFICATION
 //
 // nsIDOMDocument interface
 //
 DocumentType*
 nsIDocument::GetDoctype() const
 {
   for (nsIContent* child = GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (child->NodeType() == nsIDOMNode::DOCUMENT_TYPE_NODE) {
       return static_cast<DocumentType*>(child);
     }
   }
   return nullptr;
 }
 NS_IMETHODIMP
 nsDocument::GetDoctype(nsIDOMDocumentType** aDoctype)
 {
   MOZ_ASSERT(aDoctype);
   nsCOMPtr<nsIDOMDocumentType> doctype = nsIDocument::GetDoctype();
   doctype.forget(aDoctype);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetImplementation(nsIDOMDOMImplementation** aImplementation)
 {
   ErrorResult rv;
   *aImplementation = GetImplementation(rv);
   if (rv.Failed()) {
     MOZ_ASSERT(!*aImplementation);
     return rv.ErrorCode();
   }
   NS_ADDREF(*aImplementation);
   return NS_OK;
 }
 DOMImplementation*
 nsDocument::GetImplementation(ErrorResult& rv)
 {
   if (!mDOMImplementation) {
     nsCOMPtr<nsIURI> uri;
     NS_NewURI(getter_AddRefs(uri), "about:blank");
     if (!uri) {
       rv.Throw(NS_ERROR_OUT_OF_MEMORY);
       return nullptr;
     }
     bool hasHadScriptObject = true;
     nsIScriptGlobalObject* scriptObject =
       GetScriptHandlingObject(hasHadScriptObject);
     if (!scriptObject && hasHadScriptObject) {
       rv.Throw(NS_ERROR_UNEXPECTED);
       return nullptr;
     }
     mDOMImplementation = new DOMImplementation(this,
       scriptObject ? scriptObject : GetScopeObject(), uri, uri);
   }
   return mDOMImplementation;
 }
 NS_IMETHODIMP
 nsDocument::GetDocumentElement(nsIDOMElement** aDocumentElement)
 {
   NS_ENSURE_ARG_POINTER(aDocumentElement);
   Element* root = GetRootElement();
   if (root) {
     return CallQueryInterface(root, aDocumentElement);
   }
   *aDocumentElement = nullptr;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::CreateElement(const nsAString& aTagName,
                           nsIDOMElement** aReturn)
 {
   *aReturn = nullptr;
   ErrorResult rv;
   nsCOMPtr<Element> element = nsIDocument::CreateElement(aTagName, rv);
   NS_ENSURE_FALSE(rv.Failed(), rv.ErrorCode());
   return CallQueryInterface(element, aReturn);
 }
 bool IsLowercaseASCII(const nsAString& aValue)
 {
   int32_t len = aValue.Length();
   for (int32_t i = 0; i < len; ++i) {
     char16_t c = aValue[i];
     if (!(0x0061 <= (c) && ((c) <= 0x007a))) {
       return false;
     }
   }
   return true;
 }
 already_AddRefed<Element>
 nsIDocument::CreateElement(const nsAString& aTagName, ErrorResult& rv)
 {
   rv = nsContentUtils::CheckQName(aTagName, false);
   if (rv.Failed()) {
     return nullptr;
   }
   bool needsLowercase = IsHTML() && !IsLowercaseASCII(aTagName);
   nsAutoString lcTagName;
   if (needsLowercase) {
     nsContentUtils::ASCIIToLower(aTagName, lcTagName);
   }
   nsCOMPtr<nsIContent> content;
   rv = CreateElem(needsLowercase ? lcTagName : aTagName,
                   nullptr, mDefaultElementType, getter_AddRefs(content));
   if (rv.Failed()) {
     return nullptr;
   }
   return dont_AddRef(content.forget().take()->AsElement());
 }
 void
 nsDocument::SwizzleCustomElement(Element* aElement,
                                  const nsAString& aTypeExtension,
                                  uint32_t aNamespaceID,
                                  ErrorResult& rv)
 {
   nsCOMPtr<nsIAtom> typeAtom(do_GetAtom(aTypeExtension));
   nsCOMPtr<nsIAtom> tagAtom = aElement->Tag();
   if (!mRegistry || tagAtom == typeAtom) {
     return;
   }
   CustomElementDefinition* data;
   CustomElementHashKey key(aNamespaceID, typeAtom);
   if (!mRegistry->mCustomDefinitions.Get(&key, &data)) {
     // The type extension doesn't exist in the registry,
     // thus we don't need to swizzle, but it is possibly
     // an upgrade candidate.
     RegisterUnresolvedElement(aElement, typeAtom);
     return;
   }
   if (data->mLocalName != tagAtom) {
     // The element doesn't match the local name for the
     // definition, thus the element isn't a custom element
     // and we don't need to do anything more.
     return;
   }
   if (!aElement->HasAttr(kNameSpaceID_None, nsGkAtoms::is)) {
     // Swizzling in the parser happens after the "is" attribute is added.
     aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::is, aTypeExtension, true);
   }
   // Enqueuing the created callback will set the CustomElementData on the
   // element, causing prototype swizzling to occur in Element::WrapObject.
   EnqueueLifecycleCallback(nsIDocument::eCreated, aElement, nullptr, data);
 }
 already_AddRefed<Element>
 nsDocument::CreateElement(const nsAString& aTagName,
                           const nsAString& aTypeExtension,
                           ErrorResult& rv)
 {
   nsRefPtr<Element> elem = nsIDocument::CreateElement(aTagName, rv);
   if (rv.Failed()) {
     return nullptr;
   }
   SwizzleCustomElement(elem, aTypeExtension,
                        GetDefaultNamespaceID(), rv);
   if (rv.Failed()) {
     return nullptr;
   }
   return elem.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateElementNS(const nsAString& aNamespaceURI,
                             const nsAString& aQualifiedName,
                             nsIDOMElement** aReturn)
 {
   *aReturn = nullptr;
   ErrorResult rv;
   nsCOMPtr<Element> element =
     nsIDocument::CreateElementNS(aNamespaceURI, aQualifiedName, rv);
   NS_ENSURE_FALSE(rv.Failed(), rv.ErrorCode());
   return CallQueryInterface(element, aReturn);
 }
 already_AddRefed<Element>
 nsIDocument::CreateElementNS(const nsAString& aNamespaceURI,
                              const nsAString& aQualifiedName,
                              ErrorResult& rv)
 {
   nsCOMPtr<nsINodeInfo> nodeInfo;
   rv = nsContentUtils::GetNodeInfoFromQName(aNamespaceURI,
                                             aQualifiedName,
                                             mNodeInfoManager,
                                             nsIDOMNode::ELEMENT_NODE,
                                             getter_AddRefs(nodeInfo));
   if (rv.Failed()) {
     return nullptr;
   }
   nsCOMPtr<Element> element;
   rv = NS_NewElement(getter_AddRefs(element), nodeInfo.forget(),
                      NOT_FROM_PARSER);
   if (rv.Failed()) {
     return nullptr;
   }
   return element.forget();
 }
 already_AddRefed<Element>
 nsDocument::CreateElementNS(const nsAString& aNamespaceURI,
                             const nsAString& aQualifiedName,
                             const nsAString& aTypeExtension,
                             ErrorResult& rv)
 {
   nsRefPtr<Element> elem = nsIDocument::CreateElementNS(aNamespaceURI,
                                                         aQualifiedName,
                                                         rv);
   if (rv.Failed()) {
     return nullptr;
   }
   int32_t nameSpaceId = kNameSpaceID_Wildcard;
   if (!aNamespaceURI.EqualsLiteral("*")) {
     rv = nsContentUtils::NameSpaceManager()->RegisterNameSpace(aNamespaceURI,
                                                                nameSpaceId);
     if (rv.Failed()) {
       return nullptr;
     }
   }
   SwizzleCustomElement(elem, aTypeExtension, nameSpaceId, rv);
   if (rv.Failed()) {
     return nullptr;
   }
   return elem.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateTextNode(const nsAString& aData, nsIDOMText** aReturn)
 {
   *aReturn = nsIDocument::CreateTextNode(aData).take();
   return NS_OK;
 }
 already_AddRefed<nsTextNode>
 nsIDocument::CreateTextNode(const nsAString& aData) const
 {
   nsRefPtr<nsTextNode> text = new nsTextNode(mNodeInfoManager);
   // Don't notify; this node is still being created.
   text->SetText(aData, false);
   return text.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateDocumentFragment(nsIDOMDocumentFragment** aReturn)
 {
   *aReturn = nsIDocument::CreateDocumentFragment().take();
   return NS_OK;
 }
 already_AddRefed<DocumentFragment>
 nsIDocument::CreateDocumentFragment() const
 {
   nsRefPtr<DocumentFragment> frag = new DocumentFragment(mNodeInfoManager);
   return frag.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateComment(const nsAString& aData, nsIDOMComment** aReturn)
 {
   *aReturn = nsIDocument::CreateComment(aData).take();
   return NS_OK;
 }
 // Unfortunately, bareword "Comment" is ambiguous with some Mac system headers.
 already_AddRefed<dom::Comment>
 nsIDocument::CreateComment(const nsAString& aData) const
 {
   nsRefPtr<dom::Comment> comment = new dom::Comment(mNodeInfoManager);
   // Don't notify; this node is still being created.
   comment->SetText(aData, false);
   return comment.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateCDATASection(const nsAString& aData,
                                nsIDOMCDATASection** aReturn)
 {
   NS_ENSURE_ARG_POINTER(aReturn);
   ErrorResult rv;
   *aReturn = nsIDocument::CreateCDATASection(aData, rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<CDATASection>
 nsIDocument::CreateCDATASection(const nsAString& aData,
                                 ErrorResult& rv)
 {
   if (IsHTML()) {
     rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     return nullptr;
   }
   if (FindInReadable(NS_LITERAL_STRING("]]>"), aData)) {
     rv.Throw(NS_ERROR_DOM_INVALID_CHARACTER_ERR);
     return nullptr;
   }
   nsRefPtr<CDATASection> cdata = new CDATASection(mNodeInfoManager);
   // Don't notify; this node is still being created.
   cdata->SetText(aData, false);
   return cdata.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateProcessingInstruction(const nsAString& aTarget,
                                         const nsAString& aData,
                                         nsIDOMProcessingInstruction** aReturn)
 {
   ErrorResult rv;
   *aReturn =
     nsIDocument::CreateProcessingInstruction(aTarget, aData, rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<ProcessingInstruction>
 nsIDocument::CreateProcessingInstruction(const nsAString& aTarget,
                                          const nsAString& aData,
                                          ErrorResult& rv) const
 {
   nsresult res = nsContentUtils::CheckQName(aTarget, false);
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return nullptr;
   }
   if (FindInReadable(NS_LITERAL_STRING("?>"), aData)) {
     rv.Throw(NS_ERROR_DOM_INVALID_CHARACTER_ERR);
     return nullptr;
   }
   nsRefPtr<ProcessingInstruction> pi =
     NS_NewXMLProcessingInstruction(mNodeInfoManager, aTarget, aData);
   return pi.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateAttribute(const nsAString& aName,
                             nsIDOMAttr** aReturn)
 {
   ErrorResult rv;
   *aReturn = nsIDocument::CreateAttribute(aName, rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<Attr>
 nsIDocument::CreateAttribute(const nsAString& aName, ErrorResult& rv)
 {
   WarnOnceAbout(eCreateAttribute);
   if (!mNodeInfoManager) {
     rv.Throw(NS_ERROR_NOT_INITIALIZED);
     return nullptr;
   }
   nsresult res = nsContentUtils::CheckQName(aName, false);
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return nullptr;
   }
   nsCOMPtr<nsINodeInfo> nodeInfo;
   res = mNodeInfoManager->GetNodeInfo(aName, nullptr, kNameSpaceID_None,
                                       nsIDOMNode::ATTRIBUTE_NODE,
                                       getter_AddRefs(nodeInfo));
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return nullptr;
   }
   nsRefPtr<Attr> attribute = new Attr(nullptr, nodeInfo.forget(),
                                       EmptyString(), false);
   return attribute.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateAttributeNS(const nsAString & aNamespaceURI,
                               const nsAString & aQualifiedName,
                               nsIDOMAttr **aResult)
 {
   ErrorResult rv;
   *aResult =
     nsIDocument::CreateAttributeNS(aNamespaceURI, aQualifiedName, rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<Attr>
 nsIDocument::CreateAttributeNS(const nsAString& aNamespaceURI,
                                const nsAString& aQualifiedName,
                                ErrorResult& rv)
 {
   WarnOnceAbout(eCreateAttributeNS);
   nsCOMPtr<nsINodeInfo> nodeInfo;
   rv = nsContentUtils::GetNodeInfoFromQName(aNamespaceURI,
                                             aQualifiedName,
                                             mNodeInfoManager,
                                             nsIDOMNode::ATTRIBUTE_NODE,
                                             getter_AddRefs(nodeInfo));
   if (rv.Failed()) {
     return nullptr;
   }
   nsRefPtr<Attr> attribute = new Attr(nullptr, nodeInfo.forget(),
                                       EmptyString(), true);
   return attribute.forget();
 }
 bool
 nsDocument::CustomElementConstructor(JSContext* aCx, unsigned aArgc, JS::Value* aVp)
 {
   JS::CallArgs args = JS::CallArgsFromVp(aArgc, aVp);
   JS::Rooted<JSObject*> global(aCx,
     JS_GetGlobalForObject(aCx, &args.callee()));
   nsCOMPtr<nsPIDOMWindow> window = do_QueryWrapper(aCx, global);
   MOZ_ASSERT(window, "Should have a non-null window");
   nsDocument* document = static_cast<nsDocument*>(window->GetDoc());
   // Function name is the type of the custom element.
   JSString* jsFunName =
     JS_GetFunctionId(JS_ValueToFunction(aCx, args.calleev()));
   nsDependentJSString elemName;
   if (!elemName.init(aCx, jsFunName)) {
     return true;
   }
   nsCOMPtr<nsIAtom> typeAtom(do_GetAtom(elemName));
   CustomElementHashKey key(kNameSpaceID_Unknown, typeAtom);
   CustomElementDefinition* definition;
   if (!document->mRegistry ||
       !document->mRegistry->mCustomDefinitions.Get(&key, &definition)) {
     return true;
   }
   nsDependentAtomString localName(definition->mLocalName);
   nsCOMPtr<nsIContent> newElement;
   nsresult rv = document->CreateElem(localName, nullptr,
                                      definition->mNamespaceID,
                                      getter_AddRefs(newElement));
   NS_ENSURE_SUCCESS(rv, true);
   ErrorResult errorResult;
   nsCOMPtr<Element> element = do_QueryInterface(newElement);
   document->SwizzleCustomElement(element, elemName, definition->mNamespaceID,
                                  errorResult);
   if (errorResult.Failed()) {
     return true;
   }
   rv = nsContentUtils::WrapNative(aCx, newElement, newElement, args.rval());
   NS_ENSURE_SUCCESS(rv, true);
   return true;
 }
 bool
 nsDocument::IsRegisterElementEnabled(JSContext* aCx, JSObject* aObject)
 {
   JS::Rooted<JSObject*> obj(aCx, aObject);
   return Preferences::GetBool("dom.webcomponents.enabled") ||
     IsInCertifiedApp(aCx, obj);
 }
 nsresult
 nsDocument::RegisterUnresolvedElement(Element* aElement, nsIAtom* aTypeName)
 {
   if (!mRegistry) {
     return NS_OK;
   }
   nsINodeInfo* info = aElement->NodeInfo();
   // Candidate may be a custom element through extension,
   // in which case the custom element type name will not
   // match the element tag name. e.g. <button is="x-button">.
   nsCOMPtr<nsIAtom> typeName = aTypeName;
   if (!typeName) {
     typeName = info->NameAtom();
   }
   CustomElementHashKey key(info->NamespaceID(), typeName);
   if (mRegistry->mCustomDefinitions.Get(&key)) {
     return NS_OK;
   }
   nsTArray<nsRefPtr<Element>>* unresolved;
   mRegistry->mCandidatesMap.Get(&key, &unresolved);
   if (!unresolved) {
     unresolved = new nsTArray<nsRefPtr<Element>>();
     // Ownership of unresolved is taken by mCandidatesMap.
     mRegistry->mCandidatesMap.Put(&key, unresolved);
   }
   nsRefPtr<Element>* elem = unresolved->AppendElement();
   *elem = aElement;
   return NS_OK;
 }
 namespace {
 class ProcessStackRunner MOZ_FINAL : public nsIRunnable
 {
   public:
   ProcessStackRunner(bool aIsBaseQueue = false)
     : mIsBaseQueue(aIsBaseQueue)
   {
   }
   NS_DECL_ISUPPORTS
   NS_IMETHOD Run() MOZ_OVERRIDE
   {
     nsDocument::ProcessTopElementQueue(mIsBaseQueue);
     return NS_OK;
   }
   bool mIsBaseQueue;
 };
 NS_IMPL_ISUPPORTS(ProcessStackRunner, nsIRunnable);
 } // anonymous namespace
 void
 nsDocument::EnqueueLifecycleCallback(nsIDocument::ElementCallbackType aType,
                                      Element* aCustomElement,
                                      LifecycleCallbackArgs* aArgs,
                                      CustomElementDefinition* aDefinition)
 {
   if (!mRegistry) {
     // The element might not belong to a document that
     // has a browsing context, and thus no registry.
     return;
   }
   CustomElementData* elementData = aCustomElement->GetCustomElementData();
   // Let DEFINITION be ELEMENT's definition
   CustomElementDefinition* definition = aDefinition;
   if (!definition) {
     nsINodeInfo* info = aCustomElement->NodeInfo();
     // Make sure we get the correct definition in case the element
     // is a extended custom element e.g. <button is="x-button">.
     nsCOMPtr<nsIAtom> typeAtom = elementData ?
       elementData->mType.get() : info->NameAtom();
     CustomElementHashKey key(info->NamespaceID(), typeAtom);
     if (!mRegistry->mCustomDefinitions.Get(&key, &definition) ||
         definition->mLocalName != info->NameAtom()) {
       // Trying to enqueue a callback for an element that is not
       // a custom element. We are done, nothing to do.
       return;
     }
   }
   if (!elementData) {
     // Create the custom element data the first time
     // that we try to enqueue a callback.
     elementData = new CustomElementData(definition->mType);
     // aCustomElement takes ownership of elementData
     aCustomElement->SetCustomElementData(elementData);
     MOZ_ASSERT(aType == nsIDocument::eCreated,
                "First callback should be the created callback");
   }
   // Let CALLBACK be the callback associated with the key NAME in CALLBACKS.
   CallbackFunction* func = nullptr;
   switch (aType) {
     case nsIDocument::eCreated:
       if (definition->mCallbacks->mCreatedCallback.WasPassed()) {
         func = definition->mCallbacks->mCreatedCallback.Value();
       }
       break;
     case nsIDocument::eAttached:
       if (definition->mCallbacks->mAttachedCallback.WasPassed()) {
         func = definition->mCallbacks->mAttachedCallback.Value();
       }
       break;
     case nsIDocument::eDetached:
       if (definition->mCallbacks->mDetachedCallback.WasPassed()) {
         func = definition->mCallbacks->mDetachedCallback.Value();
       }
       break;
     case nsIDocument::eAttributeChanged:
       if (definition->mCallbacks->mAttributeChangedCallback.WasPassed()) {
         func = definition->mCallbacks->mAttributeChangedCallback.Value();
       }
       break;
   }
   // If there is no such callback, stop.
   if (!func) {
     return;
   }
   if (aType == nsIDocument::eCreated) {
     elementData->mCreatedCallbackInvoked = false;
   } else if (!elementData->mCreatedCallbackInvoked) {
     // Callbacks other than created callback must not be enqueued
     // until after the created callback has been invoked.
     return;
   }
   // Add CALLBACK to ELEMENT's callback queue.
   CustomElementCallback* callback = new CustomElementCallback(aCustomElement,
                                                               aType,
                                                               func,
                                                               elementData);
   // Ownership of callback is taken by mCallbackQueue.
   elementData->mCallbackQueue.AppendElement(callback);
   if (aArgs) {
     callback->SetArgs(*aArgs);
   }
   if (!elementData->mElementIsBeingCreated) {
     CustomElementData* lastData =
       sProcessingStack.ref().SafeLastElement(nullptr);
     // A new element queue needs to be pushed if the queue at the
     // top of the stack is associated with another microtask level.
     // Don't push a queue for the level 0 microtask (base element queue)
     // because we don't want to process the queue until the
     // microtask checkpoint.
     bool shouldPushElementQueue = nsContentUtils::MicroTaskLevel() > 0 &&
       (!lastData || lastData->mAssociatedMicroTask <
          static_cast<int32_t>(nsContentUtils::MicroTaskLevel()));
     // Push a new element queue onto the processing stack when appropriate
     // (when we enter a new microtask).
     if (shouldPushElementQueue) {
       // Push a sentinel value on the processing stack to mark the
       // boundary between the element queues.
       sProcessingStack.ref().AppendElement((CustomElementData*) nullptr);
     }
     sProcessingStack.ref().AppendElement(elementData);
     elementData->mAssociatedMicroTask =
       static_cast<int32_t>(nsContentUtils::MicroTaskLevel());
     // Add a script runner to pop and process the element queue at
     // the top of the processing stack.
     if (shouldPushElementQueue) {
       // Lifecycle callbacks enqueued by user agent implementation
       // should be invoked prior to returning control back to script.
       // Create a script runner to process the top of the processing
       // stack as soon as it is safe to run script.
       nsContentUtils::AddScriptRunner(new ProcessStackRunner());
     }
   }
 }
 // static
 void
 nsDocument::ProcessBaseElementQueue()
 {
   // Prevent re-entrance. Also, if a microtask checkpoint is reached
   // and there is no processing stack to process, then we are done.
   if (sProcessingBaseElementQueue || sProcessingStack.empty()) {
     return;
   }
   MOZ_ASSERT(nsContentUtils::MicroTaskLevel() == 0);
   sProcessingBaseElementQueue = true;
   nsContentUtils::AddScriptRunner(new ProcessStackRunner(true));
 }
 // static
 void
 nsDocument::ProcessTopElementQueue(bool aIsBaseQueue)
 {
   MOZ_ASSERT(nsContentUtils::IsSafeToRunScript());
   nsTArray<CustomElementData*>& stack = sProcessingStack.ref();
   uint32_t firstQueue = stack.LastIndexOf((CustomElementData*) nullptr);
   if (aIsBaseQueue && firstQueue != 0) {
     return;
   }
   for (uint32_t i = firstQueue + 1; i < stack.Length(); ++i) {
     // Callback queue may have already been processed in an earlier
     // element queue or in an element queue that was popped
     // off more recently.
     if (stack[i]->mAssociatedMicroTask != -1) {
       stack[i]->RunCallbackQueue();
       stack[i]->mAssociatedMicroTask = -1;
     }
   }
   // If this was actually the base element queue, don't bother trying to pop
   // the first "queue" marker (sentinel).
   if (firstQueue != 0) {
     stack.SetLength(firstQueue);
   } else {
     // Don't pop sentinel for base element queue.
     stack.SetLength(1);
     sProcessingBaseElementQueue = false;
   }
 }
 bool
 nsDocument::RegisterEnabled()
 {
   static bool sPrefValue =
     Preferences::GetBool("dom.webcomponents.enabled", false);
   return sPrefValue;
 }
 // static
 Maybe<nsTArray<mozilla::dom::CustomElementData*>>
 nsDocument::sProcessingStack;
 // static
 bool
 nsDocument::sProcessingBaseElementQueue;
 void
 nsDocument::RegisterElement(JSContext* aCx, const nsAString& aType,
                             const ElementRegistrationOptions& aOptions,
                             JS::MutableHandle<JSObject*> aRetval,
                             ErrorResult& rv)
 {
   if (!mRegistry) {
     rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     return;
   }
   Registry::DefinitionMap& definitions = mRegistry->mCustomDefinitions;
   // Unconditionally convert TYPE to lowercase.
   nsAutoString lcType;
   nsContentUtils::ASCIIToLower(aType, lcType);
   // Only convert NAME to lowercase in HTML documents. Note that NAME is
   // options.extends.
   nsAutoString lcName;
   if (IsHTML()) {
     nsContentUtils::ASCIIToLower(aOptions.mExtends, lcName);
   } else {
     lcName.Assign(aOptions.mExtends);
   }
   nsCOMPtr<nsIAtom> typeAtom(do_GetAtom(lcType));
   if (!nsContentUtils::IsCustomElementName(typeAtom)) {
     rv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
     return;
   }
   // If there already exists a definition with the same TYPE, set ERROR to
   // DuplicateDefinition and stop.
   // Note that we need to find existing custom elements from either namespace.
   CustomElementHashKey duplicateFinder(kNameSpaceID_Unknown, typeAtom);
   if (definitions.Get(&duplicateFinder)) {
     rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     return;
   }
   nsIGlobalObject* sgo = GetScopeObject();
   if (!sgo) {
     rv.Throw(NS_ERROR_UNEXPECTED);
     return;
   }
   JS::Rooted<JSObject*> global(aCx, sgo->GetGlobalJSObject());
   JSAutoCompartment ac(aCx, global);
   JS::Handle<JSObject*> htmlProto(
     HTMLElementBinding::GetProtoObject(aCx, global));
   if (!htmlProto) {
     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     return;
   }
   int32_t namespaceID = kNameSpaceID_XHTML;
   JS::Rooted<JSObject*> protoObject(aCx);
   if (!aOptions.mPrototype) {
     protoObject = JS_NewObject(aCx, nullptr, htmlProto, JS::NullPtr());
     if (!protoObject) {
       rv.Throw(NS_ERROR_UNEXPECTED);
       return;
     }
   } else {
     // If a prototype is provided, we must check to ensure that it is from the
     // same browsing context as us.
     protoObject = aOptions.mPrototype;
     if (JS_GetGlobalForObject(aCx, protoObject) != global) {
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return;
     }
     // If PROTOTYPE is already an interface prototype object for any interface
     // object or PROTOTYPE has a non-configurable property named constructor,
     // throw a NotSupportedError and stop.
     const js::Class* clasp = js::GetObjectClass(protoObject);
     if (IsDOMIfaceAndProtoClass(clasp)) {
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return;
     }
     JS::Rooted<JSPropertyDescriptor> descRoot(aCx);
     JS::MutableHandle<JSPropertyDescriptor> desc(&descRoot);
     if (!JS_GetPropertyDescriptor(aCx, protoObject, "constructor", desc)) {
       rv.Throw(NS_ERROR_UNEXPECTED);
       return;
     }
     // Check if non-configurable
     if (desc.isPermanent()) {
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return;
     }
     JS::Handle<JSObject*> svgProto(
       SVGElementBinding::GetProtoObject(aCx, global));
     if (!svgProto) {
       rv.Throw(NS_ERROR_OUT_OF_MEMORY);
       return;
     }
     JS::Rooted<JSObject*> protoProto(aCx, protoObject);
     // If PROTOTYPE's interface inherits from SVGElement, set NAMESPACE to SVG
     // Namespace.
     while (protoProto) {
       if (protoProto == htmlProto) {
         break;
       }
       if (protoProto == svgProto) {
         namespaceID = kNameSpaceID_SVG;
         break;
       }
       if (!JS_GetPrototype(aCx, protoProto, &protoProto)) {
         rv.Throw(NS_ERROR_UNEXPECTED);
         return;
       }
     }
   }
   // If name was provided and not null...
   nsCOMPtr<nsIAtom> nameAtom;
   if (!lcName.IsEmpty()) {
     // Let BASE be the element interface for NAME and NAMESPACE.
     bool known = false;
     nameAtom = do_GetAtom(lcName);
     if (namespaceID == kNameSpaceID_XHTML) {
       nsIParserService* ps = nsContentUtils::GetParserService();
       if (!ps) {
         rv.Throw(NS_ERROR_UNEXPECTED);
         return;
       }
       known =
         ps->HTMLCaseSensitiveAtomTagToId(nameAtom) != eHTMLTag_userdefined;
     } else {
       known = SVGElementFactory::Exists(nameAtom);
     }
     // If BASE does not exist or is an interface for a custom element, set ERROR
     // to InvalidName and stop.
     // If BASE exists, then it cannot be an interface for a custom element.
     if (!known) {
       rv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
       return;
     }
   } else {
     // If NAMESPACE is SVG Namespace, set ERROR to InvalidName and stop.
     if (namespaceID == kNameSpaceID_SVG) {
       rv.Throw(NS_ERROR_UNEXPECTED);
       return;
     }
     nameAtom = typeAtom;
   }
   nsAutoPtr<LifecycleCallbacks> callbacksHolder(new LifecycleCallbacks());
   JS::RootedValue rootedv(aCx, JS::ObjectValue(*protoObject));
   if (!callbacksHolder->Init(aCx, rootedv)) {
     rv.Throw(NS_ERROR_FAILURE);
     return;
   }
   // Associate the definition with the custom element.
   CustomElementHashKey key(namespaceID, typeAtom);
   LifecycleCallbacks* callbacks = callbacksHolder.forget();
   CustomElementDefinition* definition =
     new CustomElementDefinition(protoObject,
                                 typeAtom,
                                 nameAtom,
                                 callbacks,
                                 namespaceID,
 /* TODO dependent on HTML imports. Bug 877072 */);
   definitions.Put(&key, definition);
   // Do element upgrade.
   nsAutoPtr<nsTArray<nsRefPtr<Element>>> candidates;
   mRegistry->mCandidatesMap.RemoveAndForget(&key, candidates);
   if (candidates) {
     for (size_t i = 0; i < candidates->Length(); ++i) {
       Element *elem = candidates->ElementAt(i);
       // Make sure that the element name matches the name in the definition.
       // (e.g. a definition for x-button extending button should match
       // <button is="x-button"> but not <x-button>.
       if (elem->NodeInfo()->NameAtom() != nameAtom) {
         // Skip over this element because definition does not apply.
         continue;
       }
       nsWrapperCache* cache;
       CallQueryInterface(elem, &cache);
       MOZ_ASSERT(cache, "Element doesn't support wrapper cache?");
       JS::RootedObject wrapper(aCx);
       if ((wrapper = cache->GetWrapper())) {
         if (!JS_SetPrototype(aCx, wrapper, protoObject)) {
           continue;
         }
       }
       EnqueueLifecycleCallback(nsIDocument::eCreated, elem, nullptr, definition);
       if (elem->GetCurrentDoc()) {
         // Normally callbacks can not be enqueued until the created
         // callback has been invoked, however, the attached callback
         // in element upgrade is an exception so pretend the created
         // callback has been invoked.
         elem->GetCustomElementData()->mCreatedCallbackInvoked = true;
         EnqueueLifecycleCallback(nsIDocument::eAttached, elem, nullptr, definition);
       }
     }
   }
   // Create constructor to return. Store the name of the custom element as the
   // name of the function.
   JSFunction* constructor = JS_NewFunction(aCx, nsDocument::CustomElementConstructor, 0,
                                            JSFUN_CONSTRUCTOR, JS::NullPtr(),
                                            NS_ConvertUTF16toUTF8(lcType).get());
   if (!constructor) {
     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     return;
   }
   aRetval.set(JS_GetFunctionObject(constructor));
 }
 void
 nsDocument::UseRegistryFromDocument(nsIDocument* aDocument)
 {
   nsDocument* doc = static_cast<nsDocument*>(aDocument);
   MOZ_ASSERT(!mRegistry, "There should be no existing registry.");
   mRegistry = doc->mRegistry;
 }
 NS_IMETHODIMP
 nsDocument::GetElementsByTagName(const nsAString& aTagname,
                                  nsIDOMNodeList** aReturn)
 {
   nsRefPtr<nsContentList> list = GetElementsByTagName(aTagname);
   NS_ENSURE_TRUE(list, NS_ERROR_OUT_OF_MEMORY);
   // transfer ref to aReturn
   list.forget(aReturn);
   return NS_OK;
 }
 already_AddRefed<nsContentList>
 nsIDocument::GetElementsByTagNameNS(const nsAString& aNamespaceURI,
                                     const nsAString& aLocalName,
                                     ErrorResult& aResult)
 {
   int32_t nameSpaceId = kNameSpaceID_Wildcard;
   if (!aNamespaceURI.EqualsLiteral("*")) {
     aResult =
       nsContentUtils::NameSpaceManager()->RegisterNameSpace(aNamespaceURI,
                                                             nameSpaceId);
     if (aResult.Failed()) {
       return nullptr;
     }
   }
   NS_ASSERTION(nameSpaceId != kNameSpaceID_Unknown, "Unexpected namespace ID!");
   return NS_GetContentList(this, nameSpaceId, aLocalName);
 }
 NS_IMETHODIMP
 nsDocument::GetElementsByTagNameNS(const nsAString& aNamespaceURI,
                                    const nsAString& aLocalName,
                                    nsIDOMNodeList** aReturn)
 {
   ErrorResult rv;
   nsRefPtr<nsContentList> list =
     nsIDocument::GetElementsByTagNameNS(aNamespaceURI, aLocalName, rv);
   if (rv.Failed()) {
     return rv.ErrorCode();
   }
   // transfer ref to aReturn
   list.forget(aReturn);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetAsync(bool *aAsync)
 {
   NS_ERROR("nsDocument::GetAsync() should be overriden by subclass!");
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsDocument::SetAsync(bool aAsync)
 {
   NS_ERROR("nsDocument::SetAsync() should be overriden by subclass!");
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsDocument::Load(const nsAString& aUrl, bool *aReturn)
 {
   NS_ERROR("nsDocument::Load() should be overriden by subclass!");
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 NS_IMETHODIMP
 nsDocument::GetStyleSheets(nsIDOMStyleSheetList** aStyleSheets)
 {
   NS_ADDREF(*aStyleSheets = StyleSheets());
   return NS_OK;
 }
 StyleSheetList*
 nsDocument::StyleSheets()
 {
   if (!mDOMStyleSheets) {
     mDOMStyleSheets = new nsDOMStyleSheetList(this);
   }
   return mDOMStyleSheets;
 }
 NS_IMETHODIMP
 nsDocument::GetMozSelectedStyleSheetSet(nsAString& aSheetSet)
 {
   nsIDocument::GetSelectedStyleSheetSet(aSheetSet);
   return NS_OK;
 }
 void
 nsIDocument::GetSelectedStyleSheetSet(nsAString& aSheetSet)
 {
   aSheetSet.Truncate();
   // Look through our sheets, find the selected set title
   int32_t count = GetNumberOfStyleSheets();
   nsAutoString title;
   for (int32_t index = 0; index < count; index++) {
     nsIStyleSheet* sheet = GetStyleSheetAt(index);
     NS_ASSERTION(sheet, "Null sheet in sheet list!");
     nsCOMPtr<nsIDOMStyleSheet> domSheet = do_QueryInterface(sheet);
     NS_ASSERTION(domSheet, "Sheet must QI to nsIDOMStyleSheet");
     bool disabled;
     domSheet->GetDisabled(&disabled);
     if (disabled) {
       // Disabled sheets don't affect the currently selected set
       continue;
     }
     sheet->GetTitle(title);
     if (aSheetSet.IsEmpty()) {
       aSheetSet = title;
     } else if (!title.IsEmpty() && !aSheetSet.Equals(title)) {
       // Sheets from multiple sets enabled; return null string, per spec.
       SetDOMStringToNull(aSheetSet);
       return;
     }
   }
 }
 NS_IMETHODIMP
 nsDocument::SetMozSelectedStyleSheetSet(const nsAString& aSheetSet)
 {
   SetSelectedStyleSheetSet(aSheetSet);
   return NS_OK;
 }
 void
 nsDocument::SetSelectedStyleSheetSet(const nsAString& aSheetSet)
 {
   if (DOMStringIsNull(aSheetSet)) {
     return;
   }
   // Must update mLastStyleSheetSet before doing anything else with stylesheets
   // or CSSLoaders.
   mLastStyleSheetSet = aSheetSet;
   EnableStyleSheetsForSetInternal(aSheetSet, true);
 }
 NS_IMETHODIMP
 nsDocument::GetLastStyleSheetSet(nsAString& aSheetSet)
 {
   nsString sheetSet;
   GetLastStyleSheetSet(sheetSet);
   aSheetSet = sheetSet;
   return NS_OK;
 }
 void
 nsDocument::GetLastStyleSheetSet(nsString& aSheetSet)
 {
   aSheetSet = mLastStyleSheetSet;
 }
 NS_IMETHODIMP
 nsDocument::GetPreferredStyleSheetSet(nsAString& aSheetSet)
 {
   nsIDocument::GetPreferredStyleSheetSet(aSheetSet);
   return NS_OK;
 }
 void
 nsIDocument::GetPreferredStyleSheetSet(nsAString& aSheetSet)
 {
   GetHeaderData(nsGkAtoms::headerDefaultStyle, aSheetSet);
 }
 NS_IMETHODIMP
 nsDocument::GetStyleSheetSets(nsISupports** aList)
 {
   NS_ADDREF(*aList = StyleSheetSets());
   return NS_OK;
 }
 DOMStringList*
 nsDocument::StyleSheetSets()
 {
   if (!mStyleSheetSetList) {
     mStyleSheetSetList = new nsDOMStyleSheetSetList(this);
   }
   return mStyleSheetSetList;
 }
 NS_IMETHODIMP
 nsDocument::MozEnableStyleSheetsForSet(const nsAString& aSheetSet)
 {
   EnableStyleSheetsForSet(aSheetSet);
   return NS_OK;
 }
 void
 nsDocument::EnableStyleSheetsForSet(const nsAString& aSheetSet)
 {
   // Per spec, passing in null is a no-op.
   if (!DOMStringIsNull(aSheetSet)) {
     // Note: must make sure to not change the CSSLoader's preferred sheet --
     // that value should be equal to either our lastStyleSheetSet (if that's
     // non-null) or to our preferredStyleSheetSet.  And this method doesn't
     // change either of those.
     EnableStyleSheetsForSetInternal(aSheetSet, false);
   }
 }
 void
 nsDocument::EnableStyleSheetsForSetInternal(const nsAString& aSheetSet,
                                             bool aUpdateCSSLoader)
 {
   BeginUpdate(UPDATE_STYLE);
   int32_t count = GetNumberOfStyleSheets();
   nsAutoString title;
   for (int32_t index = 0; index < count; index++) {
     nsIStyleSheet* sheet = GetStyleSheetAt(index);
     NS_ASSERTION(sheet, "Null sheet in sheet list!");
     sheet->GetTitle(title);
     if (!title.IsEmpty()) {
       sheet->SetEnabled(title.Equals(aSheetSet));
     }
   }
   if (aUpdateCSSLoader) {
     CSSLoader()->SetPreferredSheet(aSheetSet);
   }
   EndUpdate(UPDATE_STYLE);
 }
 NS_IMETHODIMP
 nsDocument::GetCharacterSet(nsAString& aCharacterSet)
 {
   nsIDocument::GetCharacterSet(aCharacterSet);
   return NS_OK;
 }
 void
 nsIDocument::GetCharacterSet(nsAString& aCharacterSet) const
 {
   CopyASCIItoUTF16(GetDocumentCharacterSet(), aCharacterSet);
 }
 NS_IMETHODIMP
 nsDocument::ImportNode(nsIDOMNode* aImportedNode,
                        bool aDeep,
                        uint8_t aArgc,
                        nsIDOMNode** aResult)
 {
   if (aArgc == 0) {
     aDeep = true;
   }
   *aResult = nullptr;
   nsCOMPtr<nsINode> imported = do_QueryInterface(aImportedNode);
   NS_ENSURE_TRUE(imported, NS_ERROR_UNEXPECTED);
   ErrorResult rv;
   nsCOMPtr<nsINode> result = nsIDocument::ImportNode(*imported, aDeep, rv);
   if (rv.Failed()) {
     return rv.ErrorCode();
   }
   NS_ADDREF(*aResult = result->AsDOMNode());
   return NS_OK;
 }
 already_AddRefed<nsINode>
 nsIDocument::ImportNode(nsINode& aNode, bool aDeep, ErrorResult& rv) const
 {
   nsINode* imported = &aNode;
   switch (imported->NodeType()) {
     case nsIDOMNode::ATTRIBUTE_NODE:
     case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     case nsIDOMNode::ELEMENT_NODE:
     case nsIDOMNode::PROCESSING_INSTRUCTION_NODE:
     case nsIDOMNode::TEXT_NODE:
     case nsIDOMNode::CDATA_SECTION_NODE:
     case nsIDOMNode::COMMENT_NODE:
     case nsIDOMNode::DOCUMENT_TYPE_NODE:
     {
       nsCOMPtr<nsINode> newNode;
       nsCOMArray<nsINode> nodesWithProperties;
       rv = nsNodeUtils::Clone(imported, aDeep, mNodeInfoManager,
                               nodesWithProperties, getter_AddRefs(newNode));
       if (rv.Failed()) {
         return nullptr;
       }
       nsIDocument *ownerDoc = imported->OwnerDoc();
       rv = nsNodeUtils::CallUserDataHandlers(nodesWithProperties, ownerDoc,
                                              nsIDOMUserDataHandler::NODE_IMPORTED,
                                              true);
       if (rv.Failed()) {
         return nullptr;
       }
       return newNode.forget();
     }
     default:
     {
       NS_WARNING("Don't know how to clone this nodetype for importNode.");
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     }
   }
   return nullptr;
 }
 NS_IMETHODIMP
 nsDocument::LoadBindingDocument(const nsAString& aURI)
 {
   ErrorResult rv;
   nsIDocument::LoadBindingDocument(aURI, rv);
   return rv.ErrorCode();
 }
 void
 nsIDocument::LoadBindingDocument(const nsAString& aURI, ErrorResult& rv)
 {
   nsCOMPtr<nsIURI> uri;
   rv = NS_NewURI(getter_AddRefs(uri), aURI,
                  mCharacterSet.get(),
                  GetDocBaseURI());
   if (rv.Failed()) {
     return;
   }
   // Figure out the right principal to use
   nsCOMPtr<nsIPrincipal> subject;
   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
   if (secMan) {
     rv = secMan->GetSubjectPrincipal(getter_AddRefs(subject));
     if (rv.Failed()) {
       return;
     }
   }
   if (!subject) {
     // Fall back to our principal.  Or should we fall back to the null
     // principal?  The latter would just mean no binding loads....
     subject = NodePrincipal();
   }
   BindingManager()->LoadBindingDocument(this, uri, subject);
 }
 NS_IMETHODIMP
 nsDocument::GetBindingParent(nsIDOMNode* aNode, nsIDOMElement** aResult)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_ARG_POINTER(node);
   Element* bindingParent = nsIDocument::GetBindingParent(*node);
   nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(bindingParent);
   retval.forget(aResult);
   return NS_OK;
 }
 Element*
 nsIDocument::GetBindingParent(nsINode& aNode)
 {
   nsCOMPtr<nsIContent> content(do_QueryInterface(&aNode));
   if (!content)
     return nullptr;
   nsIContent* bindingParent = content->GetBindingParent();
   return bindingParent ? bindingParent->AsElement() : nullptr;
 }
 static Element*
 GetElementByAttribute(nsIContent* aContent, nsIAtom* aAttrName,
                       const nsAString& aAttrValue, bool aUniversalMatch)
 {
   if (aUniversalMatch ? aContent->HasAttr(kNameSpaceID_None, aAttrName) :
                         aContent->AttrValueIs(kNameSpaceID_None, aAttrName,
                                               aAttrValue, eCaseMatters)) {
     return aContent->AsElement();
   }
   for (nsIContent* child = aContent->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     Element* matchedElement =
       GetElementByAttribute(child, aAttrName, aAttrValue, aUniversalMatch);
     if (matchedElement)
       return matchedElement;
   }
   return nullptr;
 }
 Element*
 nsDocument::GetAnonymousElementByAttribute(nsIContent* aElement,
                                            nsIAtom* aAttrName,
                                            const nsAString& aAttrValue) const
 {
   nsINodeList* nodeList = BindingManager()->GetAnonymousNodesFor(aElement);
   if (!nodeList)
     return nullptr;
   uint32_t length = 0;
   nodeList->GetLength(&length);
   bool universalMatch = aAttrValue.EqualsLiteral("*");
   for (uint32_t i = 0; i < length; ++i) {
     nsIContent* current = nodeList->Item(i);
     Element* matchedElm =
       GetElementByAttribute(current, aAttrName, aAttrValue, universalMatch);
     if (matchedElm)
       return matchedElm;
   }
   return nullptr;
 }
 NS_IMETHODIMP
 nsDocument::GetAnonymousElementByAttribute(nsIDOMElement* aElement,
                                            const nsAString& aAttrName,
                                            const nsAString& aAttrValue,
                                            nsIDOMElement** aResult)
 {
   nsCOMPtr<Element> element = do_QueryInterface(aElement);
   NS_ENSURE_ARG_POINTER(element);
   Element* anonEl =
     nsIDocument::GetAnonymousElementByAttribute(*element, aAttrName,
                                                 aAttrValue);
   nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(anonEl);
   retval.forget(aResult);
   return NS_OK;
 }
 Element*
 nsIDocument::GetAnonymousElementByAttribute(Element& aElement,
                                             const nsAString& aAttrName,
                                             const nsAString& aAttrValue)
 {
   nsCOMPtr<nsIAtom> attribute = do_GetAtom(aAttrName);
   return GetAnonymousElementByAttribute(&aElement, attribute, aAttrValue);
 }
 NS_IMETHODIMP
 nsDocument::GetAnonymousNodes(nsIDOMElement* aElement,
                               nsIDOMNodeList** aResult)
 {
   *aResult = nullptr;
   nsCOMPtr<nsIContent> content(do_QueryInterface(aElement));
   return BindingManager()->GetAnonymousNodesFor(content, aResult);
 }
 nsINodeList*
 nsIDocument::GetAnonymousNodes(Element& aElement)
 {
   return BindingManager()->GetAnonymousNodesFor(&aElement);
 }
 NS_IMETHODIMP
 nsDocument::CreateRange(nsIDOMRange** aReturn)
 {
   ErrorResult rv;
   *aReturn = nsIDocument::CreateRange(rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<nsRange>
 nsIDocument::CreateRange(ErrorResult& rv)
 {
   nsRefPtr<nsRange> range = new nsRange(this);
   nsresult res = range->Set(this, 0, this, 0);
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return nullptr;
   }
   return range.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateNodeIterator(nsIDOMNode *aRoot,
                                uint32_t aWhatToShow,
                                nsIDOMNodeFilter *aFilter,
                                uint8_t aOptionalArgc,
                                nsIDOMNodeIterator **_retval)
 {
   *_retval = nullptr;
   if (!aOptionalArgc) {
     aWhatToShow = nsIDOMNodeFilter::SHOW_ALL;
   }
   if (!aRoot) {
     return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
   }
   nsCOMPtr<nsINode> root = do_QueryInterface(aRoot);
   NS_ENSURE_TRUE(root, NS_ERROR_UNEXPECTED);
   ErrorResult rv;
   NodeFilterHolder holder(aFilter);
   *_retval = nsIDocument::CreateNodeIterator(*root, aWhatToShow, holder,
                                              rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<NodeIterator>
 nsIDocument::CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
                                 NodeFilter* aFilter,
                                 ErrorResult& rv) const
 {
   NodeFilterHolder holder(aFilter);
   return CreateNodeIterator(aRoot, aWhatToShow, holder, rv);
 }
 already_AddRefed<NodeIterator>
 nsIDocument::CreateNodeIterator(nsINode& aRoot, uint32_t aWhatToShow,
                                 const NodeFilterHolder& aFilter,
                                 ErrorResult& rv) const
 {
   nsINode* root = &aRoot;
   nsRefPtr<NodeIterator> iterator = new NodeIterator(root, aWhatToShow,
                                                      aFilter);
   return iterator.forget();
 }
 NS_IMETHODIMP
 nsDocument::CreateTreeWalker(nsIDOMNode *aRoot,
                              uint32_t aWhatToShow,
                              nsIDOMNodeFilter *aFilter,
                              uint8_t aOptionalArgc,
                              nsIDOMTreeWalker **_retval)
 {
   *_retval = nullptr;
   if (!aOptionalArgc) {
     aWhatToShow = nsIDOMNodeFilter::SHOW_ALL;
   }
   nsCOMPtr<nsINode> root = do_QueryInterface(aRoot);
   NS_ENSURE_TRUE(root, NS_ERROR_DOM_NOT_SUPPORTED_ERR);
   ErrorResult rv;
   NodeFilterHolder holder(aFilter);
   *_retval = nsIDocument::CreateTreeWalker(*root, aWhatToShow, holder,
                                            rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<TreeWalker>
 nsIDocument::CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
                               NodeFilter* aFilter,
                               ErrorResult& rv) const
 {
   NodeFilterHolder holder(aFilter);
   return CreateTreeWalker(aRoot, aWhatToShow, holder, rv);
 }
 already_AddRefed<TreeWalker>
 nsIDocument::CreateTreeWalker(nsINode& aRoot, uint32_t aWhatToShow,
                               const NodeFilterHolder& aFilter,
                               ErrorResult& rv) const
 {
   nsINode* root = &aRoot;
   nsRefPtr<TreeWalker> walker = new TreeWalker(root, aWhatToShow, aFilter);
   return walker.forget();
 }
 NS_IMETHODIMP
 nsDocument::GetDefaultView(nsIDOMWindow** aDefaultView)
 {
   *aDefaultView = nullptr;
   nsCOMPtr<nsPIDOMWindow> win = GetWindow();
   win.forget(aDefaultView);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetLocation(nsIDOMLocation **_retval)
 {
   *_retval = nsIDocument::GetLocation().take();
   return NS_OK;
 }
 already_AddRefed<nsIDOMLocation>
 nsIDocument::GetLocation() const
 {
   nsCOMPtr<nsIDOMWindow> w = do_QueryInterface(mScriptGlobalObject);
   if (!w) {
     return nullptr;
   }
   nsCOMPtr<nsIDOMLocation> loc;
   w->GetLocation(getter_AddRefs(loc));
   return loc.forget();
 }
 Element*
 nsIDocument::GetHtmlElement() const
 {
   Element* rootElement = GetRootElement();
   if (rootElement && rootElement->IsHTML(nsGkAtoms::html))
     return rootElement;
   return nullptr;
 }
 Element*
 nsIDocument::GetHtmlChildElement(nsIAtom* aTag)
 {
   Element* html = GetHtmlElement();
   if (!html)
     return nullptr;
   // Look for the element with aTag inside html. This needs to run
   // forwards to find the first such element.
   for (nsIContent* child = html->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (child->IsHTML(aTag))
       return child->AsElement();
   }
   return nullptr;
 }
 nsIContent*
 nsDocument::GetTitleContent(uint32_t aNamespace)
 {
   // mMayHaveTitleElement will have been set to true if any HTML or SVG
   // <title> element has been bound to this document. So if it's false,
   // we know there is nothing to do here. This avoids us having to search
   // the whole DOM if someone calls document.title on a large document
   // without a title.
   if (!mMayHaveTitleElement)
     return nullptr;
   nsRefPtr<nsContentList> list =
     NS_GetContentList(this, aNamespace, NS_LITERAL_STRING("title"));
   return list->Item(0, false);
 }
 void
 nsDocument::GetTitleFromElement(uint32_t aNamespace, nsAString& aTitle)
 {
   nsIContent* title = GetTitleContent(aNamespace);
   if (!title)
     return;
   if(!nsContentUtils::GetNodeTextContent(title, false, aTitle))
     NS_RUNTIMEABORT("OOM");
 }
 NS_IMETHODIMP
 nsDocument::GetTitle(nsAString& aTitle)
 {
   nsString title;
   GetTitle(title);
   aTitle = title;
   return NS_OK;
 }
 void
 nsDocument::GetTitle(nsString& aTitle)
 {
   aTitle.Truncate();
   nsIContent *rootElement = GetRootElement();
   if (!rootElement)
     return;
   nsAutoString tmp;
   switch (rootElement->GetNameSpaceID()) {
 #ifdef MOZ_XUL
     case kNameSpaceID_XUL:
       rootElement->GetAttr(kNameSpaceID_None, nsGkAtoms::title, tmp);
       break;
 #endif
     case kNameSpaceID_SVG:
       if (rootElement->Tag() == nsGkAtoms::svg) {
         GetTitleFromElement(kNameSpaceID_SVG, tmp);
         break;
       } // else fall through
     default:
       GetTitleFromElement(kNameSpaceID_XHTML, tmp);
       break;
   }
   tmp.CompressWhitespace();
   aTitle = tmp;
 }
 NS_IMETHODIMP
 nsDocument::SetTitle(const nsAString& aTitle)
 {
   Element *rootElement = GetRootElement();
   if (!rootElement)
     return NS_OK;
   switch (rootElement->GetNameSpaceID()) {
     case kNameSpaceID_SVG:
       return NS_OK; // SVG doesn't support setting a title
 #ifdef MOZ_XUL
     case kNameSpaceID_XUL:
       return rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::title,
                                   aTitle, true);
 #endif
   }
   // Batch updates so that mutation events don't change "the title
   // element" under us
   mozAutoDocUpdate updateBatch(this, UPDATE_CONTENT_MODEL, true);
   nsIContent* title = GetTitleContent(kNameSpaceID_XHTML);
   if (!title) {
     Element *head = GetHeadElement();
     if (!head)
       return NS_OK;
     {
       nsCOMPtr<nsINodeInfo> titleInfo;
       titleInfo = mNodeInfoManager->GetNodeInfo(nsGkAtoms::title, nullptr,
                                                 kNameSpaceID_XHTML,
                                                 nsIDOMNode::ELEMENT_NODE);
       title = NS_NewHTMLTitleElement(titleInfo.forget());
       if (!title)
         return NS_OK;
     }
     head->AppendChildTo(title, true);
   }
   return nsContentUtils::SetNodeTextContent(title, aTitle, false);
 }
 void
 nsDocument::SetTitle(const nsAString& aTitle, ErrorResult& rv)
 {
   rv = SetTitle(aTitle);
 }
 void
 nsDocument::NotifyPossibleTitleChange(bool aBoundTitleElement)
 {
   NS_ASSERTION(!mInUnlinkOrDeletion || !aBoundTitleElement,
                "Setting a title while unlinking or destroying the element?");
   if (mInUnlinkOrDeletion) {
     return;
   }
   if (aBoundTitleElement) {
     mMayHaveTitleElement = true;
   }
   if (mPendingTitleChangeEvent.IsPending())
     return;
   nsRefPtr<nsRunnableMethod<nsDocument, void, false> > event =
     NS_NewNonOwningRunnableMethod(this,
       &nsDocument::DoNotifyPossibleTitleChange);
   nsresult rv = NS_DispatchToCurrentThread(event);
   if (NS_SUCCEEDED(rv)) {
     mPendingTitleChangeEvent = event;
   }
 }
 void
 nsDocument::DoNotifyPossibleTitleChange()
 {
   mPendingTitleChangeEvent.Forget();
   mHaveFiredTitleChange = true;
   nsAutoString title;
   GetTitle(title);
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     nsCOMPtr<nsISupports> container =
       shell->GetPresContext()->GetContainerWeak();
     if (container) {
       nsCOMPtr<nsIBaseWindow> docShellWin = do_QueryInterface(container);
       if (docShellWin) {
         docShellWin->SetTitle(title.get());
       }
     }
   }
   // Fire a DOM event for the title change.
   nsContentUtils::DispatchChromeEvent(this, static_cast<nsIDocument*>(this),
                                       NS_LITERAL_STRING("DOMTitleChanged"),
                                       true, true);
 }
 already_AddRefed<nsIBoxObject>
 nsDocument::GetBoxObjectFor(Element* aElement, ErrorResult& aRv)
 {
   if (!aElement) {
     aRv.Throw(NS_ERROR_UNEXPECTED);
     return nullptr;
   }
   nsIDocument* doc = aElement->OwnerDoc();
   if (doc != this) {
     aRv.Throw(NS_ERROR_DOM_WRONG_DOCUMENT_ERR);
     return nullptr;
   }
   if (!mHasWarnedAboutBoxObjects && !aElement->IsXUL()) {
     mHasWarnedAboutBoxObjects = true;
     nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                     NS_LITERAL_CSTRING("BoxObjects"), this,
                                     nsContentUtils::eDOM_PROPERTIES,
                                     "UseOfGetBoxObjectForWarning");
   }
   if (!mBoxObjectTable) {
     mBoxObjectTable = new nsInterfaceHashtable<nsPtrHashKey<nsIContent>, nsPIBoxObject>(12);
   } else {
     nsCOMPtr<nsPIBoxObject> boxObject = mBoxObjectTable->Get(aElement);
     if (boxObject) {
       return boxObject.forget();
     }
   }
   int32_t namespaceID;
   nsCOMPtr<nsIAtom> tag = BindingManager()->ResolveTag(aElement, &namespaceID);
   nsAutoCString contractID("@mozilla.org/layout/xul-boxobject");
   if (namespaceID == kNameSpaceID_XUL) {
     if (tag == nsGkAtoms::browser ||
         tag == nsGkAtoms::editor ||
         tag == nsGkAtoms::iframe)
       contractID += "-container";
     else if (tag == nsGkAtoms::menu)
       contractID += "-menu";
     else if (tag == nsGkAtoms::popup ||
              tag == nsGkAtoms::menupopup ||
              tag == nsGkAtoms::panel ||
              tag == nsGkAtoms::tooltip)
       contractID += "-popup";
     else if (tag == nsGkAtoms::tree)
       contractID += "-tree";
     else if (tag == nsGkAtoms::listbox)
       contractID += "-listbox";
     else if (tag == nsGkAtoms::scrollbox)
       contractID += "-scrollbox";
   }
   contractID += ";1";
   nsCOMPtr<nsPIBoxObject> boxObject(do_CreateInstance(contractID.get()));
   if (!boxObject) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
   boxObject->Init(aElement);
   if (mBoxObjectTable) {
     mBoxObjectTable->Put(aElement, boxObject.get());
   }
   return boxObject.forget();
 }
 void
 nsDocument::ClearBoxObjectFor(nsIContent* aContent)
 {
   if (mBoxObjectTable) {
     nsPIBoxObject *boxObject = mBoxObjectTable->GetWeak(aContent);
     if (boxObject) {
       boxObject->Clear();
       mBoxObjectTable->Remove(aContent);
     }
   }
 }
 void
 nsDocument::FlushSkinBindings()
 {
   BindingManager()->FlushSkinBindings();
 }
 nsresult
 nsDocument::InitializeFrameLoader(nsFrameLoader* aLoader)
 {
   mInitializableFrameLoaders.RemoveElement(aLoader);
   // Don't even try to initialize.
   if (mInDestructor) {
     NS_WARNING("Trying to initialize a frame loader while"
                "document is being deleted");
     return NS_ERROR_FAILURE;
   }
   mInitializableFrameLoaders.AppendElement(aLoader);
   if (!mFrameLoaderRunner) {
     mFrameLoaderRunner =
       NS_NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders);
     NS_ENSURE_TRUE(mFrameLoaderRunner, NS_ERROR_OUT_OF_MEMORY);
     nsContentUtils::AddScriptRunner(mFrameLoaderRunner);
   }
   return NS_OK;
 }
 nsresult
 nsDocument::FinalizeFrameLoader(nsFrameLoader* aLoader)
 {
   mInitializableFrameLoaders.RemoveElement(aLoader);
   if (mInDestructor) {
     return NS_ERROR_FAILURE;
   }
   mFinalizableFrameLoaders.AppendElement(aLoader);
   if (!mFrameLoaderRunner) {
     mFrameLoaderRunner =
       NS_NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders);
     NS_ENSURE_TRUE(mFrameLoaderRunner, NS_ERROR_OUT_OF_MEMORY);
     nsContentUtils::AddScriptRunner(mFrameLoaderRunner);
   }
   return NS_OK;
 }
 void
 nsDocument::MaybeInitializeFinalizeFrameLoaders()
 {
   if (mDelayFrameLoaderInitialization || mUpdateNestLevel != 0) {
     // This method will be recalled when mUpdateNestLevel drops to 0,
     // or when !mDelayFrameLoaderInitialization.
     mFrameLoaderRunner = nullptr;
     return;
   }
   // We're not in an update, but it is not safe to run scripts, so
   // postpone frameloader initialization and finalization.
   if (!nsContentUtils::IsSafeToRunScript()) {
     if (!mInDestructor && !mFrameLoaderRunner &&
         (mInitializableFrameLoaders.Length() ||
          mFinalizableFrameLoaders.Length())) {
       mFrameLoaderRunner =
         NS_NewRunnableMethod(this, &nsDocument::MaybeInitializeFinalizeFrameLoaders);
       nsContentUtils::AddScriptRunner(mFrameLoaderRunner);
     }
     return;
   }
   mFrameLoaderRunner = nullptr;
   // Don't use a temporary array for mInitializableFrameLoaders, because
   // loading a frame may cause some other frameloader to be removed from the
   // array. But be careful to keep the loader alive when starting the load!
   while (mInitializableFrameLoaders.Length()) {
     nsRefPtr<nsFrameLoader> loader = mInitializableFrameLoaders[0];
     mInitializableFrameLoaders.RemoveElementAt(0);
     NS_ASSERTION(loader, "null frameloader in the array?");
     loader->ReallyStartLoading();
   }
   uint32_t length = mFinalizableFrameLoaders.Length();
   if (length > 0) {
     nsTArray<nsRefPtr<nsFrameLoader> > loaders;
     mFinalizableFrameLoaders.SwapElements(loaders);
     for (uint32_t i = 0; i < length; ++i) {
       loaders[i]->Finalize();
     }
   }
 }
 void
 nsDocument::TryCancelFrameLoaderInitialization(nsIDocShell* aShell)
 {
   uint32_t length = mInitializableFrameLoaders.Length();
   for (uint32_t i = 0; i < length; ++i) {
     if (mInitializableFrameLoaders[i]->GetExistingDocShell() == aShell) {
       mInitializableFrameLoaders.RemoveElementAt(i);
       return;
     }
   }
 }
 bool
 nsDocument::FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell)
 {
   if (aShell) {
     uint32_t length = mFinalizableFrameLoaders.Length();
     for (uint32_t i = 0; i < length; ++i) {
       if (mFinalizableFrameLoaders[i]->GetExistingDocShell() == aShell) {
         return true;
       }
     }
   }
   return false;
 }
 nsIDocument*
 nsDocument::RequestExternalResource(nsIURI* aURI,
                                     nsINode* aRequestingNode,
                                     ExternalResourceLoad** aPendingLoad)
 {
   NS_PRECONDITION(aURI, "Must have a URI");
   NS_PRECONDITION(aRequestingNode, "Must have a node");
   if (mDisplayDocument) {
     return mDisplayDocument->RequestExternalResource(aURI,
                                                      aRequestingNode,
                                                      aPendingLoad);
   }
   return mExternalResourceMap.RequestResource(aURI, aRequestingNode,
                                               this, aPendingLoad);
 }
 void
 nsDocument::EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData)
 {
   mExternalResourceMap.EnumerateResources(aCallback, aData);
 }
 nsSMILAnimationController*
 nsDocument::GetAnimationController()
 {
   // We create the animation controller lazily because most documents won't want
   // one and only SVG documents and the like will call this
   if (mAnimationController)
     return mAnimationController;
   // Refuse to create an Animation Controller for data documents.
   if (mLoadedAsData || mLoadedAsInteractiveData)
     return nullptr;
   mAnimationController = new nsSMILAnimationController(this);
   // If there's a presContext then check the animation mode and pause if
   // necessary.
   nsIPresShell *shell = GetShell();
   if (mAnimationController && shell) {
     nsPresContext *context = shell->GetPresContext();
     if (context &&
         context->ImageAnimationMode() == imgIContainer::kDontAnimMode) {
       mAnimationController->Pause(nsSMILTimeContainer::PAUSE_USERPREF);
     }
   }
   // If we're hidden (or being hidden), notify the newly-created animation
   // controller. (Skip this check for SVG-as-an-image documents, though,
   // because they don't get OnPageShow / OnPageHide calls).
   if (!mIsShowing && !mIsBeingUsedAsImage) {
     mAnimationController->OnPageHide();
   }
   return mAnimationController;
 }
 /**
  * Retrieve the "direction" property of the document.
  *
  * @lina 01/09/2001
  */
 NS_IMETHODIMP
 nsDocument::GetDir(nsAString& aDirection)
 {
   nsIDocument::GetDir(aDirection);
   return NS_OK;
 }
 void
 nsIDocument::GetDir(nsAString& aDirection) const
 {
   aDirection.Truncate();
   Element* rootElement = GetHtmlElement();
   if (rootElement) {
     static_cast<nsGenericHTMLElement*>(rootElement)->GetDir(aDirection);
   }
 }
 /**
  * Set the "direction" property of the document.
  *
  * @lina 01/09/2001
  */
 NS_IMETHODIMP
 nsDocument::SetDir(const nsAString& aDirection)
 {
   nsIDocument::SetDir(aDirection);
   return NS_OK;
 }
 void
 nsIDocument::SetDir(const nsAString& aDirection)
 {
   Element* rootElement = GetHtmlElement();
   if (rootElement) {
     rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::dir,
                          aDirection, true);
   }
 }
 NS_IMETHODIMP
 nsDocument::GetInputEncoding(nsAString& aInputEncoding)
 {
   nsIDocument::GetInputEncoding(aInputEncoding);
   return NS_OK;
 }
 void
 nsIDocument::GetInputEncoding(nsAString& aInputEncoding)
 {
   // Not const function, because WarnOnceAbout is not a const method
   WarnOnceAbout(eInputEncoding);
   if (mHaveInputEncoding) {
     return GetCharacterSet(aInputEncoding);
   }
   SetDOMStringToNull(aInputEncoding);
 }
 NS_IMETHODIMP
 nsDocument::GetMozSyntheticDocument(bool *aSyntheticDocument)
 {
   *aSyntheticDocument = mIsSyntheticDocument;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetDocumentURI(nsAString& aDocumentURI)
 {
   nsString temp;
   nsIDocument::GetDocumentURI(temp);
   aDocumentURI = temp;
   return NS_OK;
 }
 void
 nsIDocument::GetDocumentURI(nsString& aDocumentURI) const
 {
   if (mDocumentURI) {
     nsAutoCString uri;
     mDocumentURI->GetSpec(uri);
     CopyUTF8toUTF16(uri, aDocumentURI);
   } else {
     aDocumentURI.Truncate();
   }
 }
 // Alias of above
 NS_IMETHODIMP
 nsDocument::GetURL(nsAString& aURL)
 {
   return GetDocumentURI(aURL);
 }
 void
 nsIDocument::GetURL(nsString& aURL) const
 {
   return GetDocumentURI(aURL);
 }
 void
 nsIDocument::GetDocumentURIFromJS(nsString& aDocumentURI) const
 {
   if (!mChromeXHRDocURI || !nsContentUtils::IsCallerChrome()) {
     return GetDocumentURI(aDocumentURI);
   }
   nsAutoCString uri;
   mChromeXHRDocURI->GetSpec(uri);
   CopyUTF8toUTF16(uri, aDocumentURI);
 }
 nsIURI*
 nsIDocument::GetDocumentURIObject() const
 {
   if (!mChromeXHRDocURI) {
     return GetDocumentURI();
   }
   return mChromeXHRDocURI;
 }
 // readonly attribute DOMString compatMode;
 // Returns "BackCompat" if we are in quirks mode, "CSS1Compat" if we are
 // in almost standards or full standards mode. See bug 105640.  This was
 // implemented to match MSIE's compatMode property.
 NS_IMETHODIMP
 nsDocument::GetCompatMode(nsAString& aCompatMode)
 {
   nsString temp;
   nsIDocument::GetCompatMode(temp);
   aCompatMode = temp;
   return NS_OK;
 }
 void
 nsIDocument::GetCompatMode(nsString& aCompatMode) const
 {
   NS_ASSERTION(mCompatMode == eCompatibility_NavQuirks ||
                mCompatMode == eCompatibility_AlmostStandards ||
                mCompatMode == eCompatibility_FullStandards,
                "mCompatMode is neither quirks nor strict for this document");
   if (mCompatMode == eCompatibility_NavQuirks) {
     aCompatMode.AssignLiteral("BackCompat");
   } else {
     aCompatMode.AssignLiteral("CSS1Compat");
   }
 }
 static void BlastSubtreeToPieces(nsINode *aNode);
 PLDHashOperator
 BlastFunc(nsAttrHashKey::KeyType aKey, Attr *aData, void* aUserArg)
 {
   nsCOMPtr<nsIAttribute> *attr =
     static_cast<nsCOMPtr<nsIAttribute>*>(aUserArg);
   *attr = aData;
   NS_ASSERTION(attr->get(),
                "non-nsIAttribute somehow made it into the hashmap?!");
   return PL_DHASH_STOP;
 }
 static void
 BlastSubtreeToPieces(nsINode *aNode)
 {
   if (aNode->IsElement()) {
     Element *element = aNode->AsElement();
     const nsDOMAttributeMap *map = element->GetAttributeMap();
     if (map) {
       nsCOMPtr<nsIAttribute> attr;
       while (map->Enumerate(BlastFunc, &attr) > 0) {
         BlastSubtreeToPieces(attr);
 #ifdef DEBUG
         nsresult rv =
 #endif
           element->UnsetAttr(attr->NodeInfo()->NamespaceID(),
                              attr->NodeInfo()->NameAtom(),
                              false);
         // XXX Should we abort here?
         NS_ASSERTION(NS_SUCCEEDED(rv), "Uhoh, UnsetAttr shouldn't fail!");
       }
     }
   }
   uint32_t count = aNode->GetChildCount();
   for (uint32_t i = 0; i < count; ++i) {
     BlastSubtreeToPieces(aNode->GetFirstChild());
     aNode->RemoveChildAt(0, false);
   }
 }
 class nsUserDataCaller : public nsRunnable
 {
 public:
   nsUserDataCaller(nsCOMArray<nsINode>& aNodesWithProperties,
                    nsIDocument* aOwnerDoc)
     : mNodesWithProperties(aNodesWithProperties),
       mOwnerDoc(aOwnerDoc)
   {
   }
   NS_IMETHOD Run()
   {
     nsNodeUtils::CallUserDataHandlers(mNodesWithProperties, mOwnerDoc,
                                       nsIDOMUserDataHandler::NODE_ADOPTED,
                                       false);
     return NS_OK;
   }
 private:
   nsCOMArray<nsINode> mNodesWithProperties;
   nsCOMPtr<nsIDocument> mOwnerDoc;
 };
 NS_IMETHODIMP
 nsDocument::AdoptNode(nsIDOMNode *aAdoptedNode, nsIDOMNode **aResult)
 {
   *aResult = nullptr;
   nsCOMPtr<nsINode> adoptedNode = do_QueryInterface(aAdoptedNode);
   NS_ENSURE_TRUE(adoptedNode, NS_ERROR_UNEXPECTED);
   ErrorResult rv;
   nsINode* result = nsIDocument::AdoptNode(*adoptedNode, rv);
   if (rv.Failed()) {
     return rv.ErrorCode();
   }
   NS_ADDREF(*aResult = result->AsDOMNode());
   return NS_OK;
 }
 nsINode*
 nsIDocument::AdoptNode(nsINode& aAdoptedNode, ErrorResult& rv)
 {
   nsINode* adoptedNode = &aAdoptedNode;
   // Scope firing mutation events so that we don't carry any state that
   // might be stale
   {
     nsINode* parent = adoptedNode->GetParentNode();
     if (parent) {
       nsContentUtils::MaybeFireNodeRemoved(adoptedNode, parent,
                                            adoptedNode->OwnerDoc());
     }
   }
   nsAutoScriptBlocker scriptBlocker;
   switch (adoptedNode->NodeType()) {
     case nsIDOMNode::ATTRIBUTE_NODE:
     {
       // Remove from ownerElement.
       nsRefPtr<Attr> adoptedAttr = static_cast<Attr*>(adoptedNode);
       nsCOMPtr<Element> ownerElement = adoptedAttr->GetOwnerElement(rv);
       if (rv.Failed()) {
         return nullptr;
       }
       if (ownerElement) {
         nsRefPtr<Attr> newAttr =
           ownerElement->RemoveAttributeNode(*adoptedAttr, rv);
         if (rv.Failed()) {
           return nullptr;
         }
         newAttr.swap(adoptedAttr);
       }
       break;
     }
     case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     case nsIDOMNode::ELEMENT_NODE:
     case nsIDOMNode::PROCESSING_INSTRUCTION_NODE:
     case nsIDOMNode::TEXT_NODE:
     case nsIDOMNode::CDATA_SECTION_NODE:
     case nsIDOMNode::COMMENT_NODE:
     case nsIDOMNode::DOCUMENT_TYPE_NODE:
     {
       // Don't allow adopting a node's anonymous subtree out from under it.
       if (adoptedNode->AsContent()->IsRootOfAnonymousSubtree()) {
         rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
         return nullptr;
       }
       // We don't want to adopt an element into its own contentDocument or into
       // a descendant contentDocument, so we check if the frameElement of this
       // document or any of its parents is the adopted node or one of its
       // descendants.
       nsIDocument *doc = this;
       do {
         nsPIDOMWindow *win = doc->GetWindow();
         if (win) {
           nsCOMPtr<nsINode> node =
             do_QueryInterface(win->GetFrameElementInternal());
           if (node &&
               nsContentUtils::ContentIsDescendantOf(node, adoptedNode)) {
             rv.Throw(NS_ERROR_DOM_HIERARCHY_REQUEST_ERR);
             return nullptr;
           }
         }
       } while ((doc = doc->GetParentDocument()));
       // Remove from parent.
       nsCOMPtr<nsINode> parent = adoptedNode->GetParentNode();
       if (parent) {
         int32_t idx = parent->IndexOf(adoptedNode);
         MOZ_ASSERT(idx >= 0);
         parent->RemoveChildAt(idx, true);
       } else {
         MOZ_ASSERT(!adoptedNode->IsInDoc());
         // If we're adopting a node that's not in a document, it might still
         // have a binding applied. Remove the binding from the element now
         // that it's getting adopted into a new document.
         // TODO Fully tear down the binding.
         adoptedNode->AsContent()->SetXBLBinding(nullptr);
       }
       break;
     }
     case nsIDOMNode::DOCUMENT_NODE:
     {
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return nullptr;
     }
     default:
     {
       NS_WARNING("Don't know how to adopt this nodetype for adoptNode.");
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return nullptr;
     }
   }
   nsCOMPtr<nsIDocument> oldDocument = adoptedNode->OwnerDoc();
   bool sameDocument = oldDocument == this;
   AutoJSContext cx;
   JS::Rooted<JSObject*> newScope(cx, nullptr);
   if (!sameDocument) {
     newScope = GetWrapper();
     if (!newScope && GetScopeObject() && GetScopeObject()->GetGlobalJSObject()) {
       // Make sure cx is in a semi-sane compartment before we call WrapNative.
       // It's kind of irrelevant, given that we're passing aAllowWrapping =
       // false, and documents should always insist on being wrapped in an
       // canonical scope. But we try to pass something sane anyway.
       JSAutoCompartment ac(cx, GetScopeObject()->GetGlobalJSObject());
       JS::Rooted<JS::Value> v(cx);
       rv = nsContentUtils::WrapNative(cx, this, this, &v,
                                       /* aAllowWrapping = */ false);
       if (rv.Failed())
         return nullptr;
       newScope = &v.toObject();
     }
   }
   nsCOMArray<nsINode> nodesWithProperties;
   rv = nsNodeUtils::Adopt(adoptedNode, sameDocument ? nullptr : mNodeInfoManager,
                           newScope, nodesWithProperties);
   if (rv.Failed()) {
     // Disconnect all nodes from their parents, since some have the old document
     // as their ownerDocument and some have this as their ownerDocument.
     BlastSubtreeToPieces(adoptedNode);
     if (!sameDocument && oldDocument) {
       uint32_t count = nodesWithProperties.Count();
       for (uint32_t j = 0; j < oldDocument->GetPropertyTableCount(); ++j) {
         for (uint32_t i = 0; i < count; ++i) {
           // Remove all properties.
           oldDocument->PropertyTable(j)->
             DeleteAllPropertiesFor(nodesWithProperties[i]);
         }
       }
     }
     return nullptr;
   }
   uint32_t count = nodesWithProperties.Count();
   if (!sameDocument && oldDocument) {
     for (uint32_t j = 0; j < oldDocument->GetPropertyTableCount(); ++j) {
       nsPropertyTable *oldTable = oldDocument->PropertyTable(j);
       nsPropertyTable *newTable = PropertyTable(j);
       for (uint32_t i = 0; i < count; ++i) {
         rv = oldTable->TransferOrDeleteAllPropertiesFor(nodesWithProperties[i],
                                                         newTable);
       }
     }
     if (rv.Failed()) {
       // Disconnect all nodes from their parents.
       BlastSubtreeToPieces(adoptedNode);
       return nullptr;
     }
   }
   if (nodesWithProperties.Count()) {
     nsContentUtils::AddScriptRunner(new nsUserDataCaller(nodesWithProperties,
                                                          this));
   }
   NS_ASSERTION(adoptedNode->OwnerDoc() == this,
                "Should still be in the document we just got adopted into");
   return adoptedNode;
 }
 nsViewportInfo
 nsDocument::GetViewportInfo(const ScreenIntSize& aDisplaySize)
 {
   // In cases where the width of the CSS viewport is less than or equal to the width
   // of the display (i.e. width <= device-width) then we disable double-tap-to-zoom
   // behaviour. See bug 941995 for details.
   switch (mViewportType) {
   case DisplayWidthHeight:
     return nsViewportInfo(aDisplaySize);
   case DisplayWidthHeightNoZoom:
     return nsViewportInfo(aDisplaySize, /*allowZoom*/ false, /*allowDoubleTapZoom*/ false);
   case Unknown:
   {
     nsAutoString viewport;
     GetHeaderData(nsGkAtoms::viewport, viewport);
     if (viewport.IsEmpty()) {
       // If the docType specifies that we are on a site optimized for mobile,
       // then we want to return specially crafted defaults for the viewport info.
       nsCOMPtr<nsIDOMDocumentType> docType;
       nsresult rv = GetDoctype(getter_AddRefs(docType));
       if (NS_SUCCEEDED(rv) && docType) {
         nsAutoString docId;
         rv = docType->GetPublicId(docId);
         if (NS_SUCCEEDED(rv)) {
           if ((docId.Find("WAP") != -1) ||
               (docId.Find("Mobile") != -1) ||
               (docId.Find("WML") != -1))
           {
             // We're making an assumption that the docType can't change here
             mViewportType = DisplayWidthHeight;
             return nsViewportInfo(aDisplaySize, /*allowZoom*/true, /*allowDoubleTapZoom*/false);
           }
         }
       }
       nsAutoString handheldFriendly;
       GetHeaderData(nsGkAtoms::handheldFriendly, handheldFriendly);
       if (handheldFriendly.EqualsLiteral("true")) {
         mViewportType = DisplayWidthHeight;
         return nsViewportInfo(aDisplaySize, /*allowZoom*/true, /*allowDoubleTapZoom*/false);
       }
       // Bug 940036. This is bad. When FirefoxOS was built, apps installed
       // where not using the AsyncPanZoom code. As a result a lot of apps
       // in the marketplace does not use it yet and instead are built to
       // render correctly in FirefoxOS only. For a smooth transition the above
       // code force installed apps to render as if they have a viewport with
       // content="width=device-width, height=device-height, user-scalable=no".
       // This could be safely remove once it is known that most apps in the
       // marketplace use it and that users does not use an old version of the
       // app that does not use it.
       nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
       if (docShell && docShell->GetIsApp()) {
         nsString uri;
         GetDocumentURI(uri);
         if (!uri.EqualsLiteral("about:blank")) {
           nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                           NS_LITERAL_CSTRING("DOM"), this,
                                           nsContentUtils::eDOM_PROPERTIES,
                                           "ImplicitMetaViewportTagFallback");
         }
         mViewportType = DisplayWidthHeightNoZoom;
         return nsViewportInfo(aDisplaySize, /*allowZoom*/false, /*allowDoubleTapZoom*/false);
       }
     }
     nsAutoString minScaleStr;
     GetHeaderData(nsGkAtoms::viewport_minimum_scale, minScaleStr);
     nsresult errorCode;
     mScaleMinFloat = LayoutDeviceToScreenScale(minScaleStr.ToFloat(&errorCode));
     if (NS_FAILED(errorCode)) {
       mScaleMinFloat = kViewportMinScale;
     }
     mScaleMinFloat = mozilla::clamped(
         mScaleMinFloat, kViewportMinScale, kViewportMaxScale);
     nsAutoString maxScaleStr;
     GetHeaderData(nsGkAtoms::viewport_maximum_scale, maxScaleStr);
     // We define a special error code variable for the scale and max scale,
     // because they are used later (see the width calculations).
     nsresult scaleMaxErrorCode;
     mScaleMaxFloat = LayoutDeviceToScreenScale(maxScaleStr.ToFloat(&scaleMaxErrorCode));
     if (NS_FAILED(scaleMaxErrorCode)) {
       mScaleMaxFloat = kViewportMaxScale;
     }
     mScaleMaxFloat = mozilla::clamped(
         mScaleMaxFloat, kViewportMinScale, kViewportMaxScale);
     nsAutoString scaleStr;
     GetHeaderData(nsGkAtoms::viewport_initial_scale, scaleStr);
     nsresult scaleErrorCode;
     mScaleFloat = LayoutDeviceToScreenScale(scaleStr.ToFloat(&scaleErrorCode));
     nsAutoString widthStr, heightStr;
     GetHeaderData(nsGkAtoms::viewport_height, heightStr);
     GetHeaderData(nsGkAtoms::viewport_width, widthStr);
     mAutoSize = false;
     if (widthStr.EqualsLiteral("device-width")) {
       mAutoSize = true;
     }
     if (widthStr.IsEmpty() &&
         (heightStr.EqualsLiteral("device-height") ||
          (mScaleFloat.scale == 1.0)))
     {
       mAutoSize = true;
     }
     nsresult widthErrorCode, heightErrorCode;
     mViewportSize.width = widthStr.ToInteger(&widthErrorCode);
     mViewportSize.height = heightStr.ToInteger(&heightErrorCode);
     // If width or height has not been set to a valid number by this point,
     // fall back to a default value.
     mValidWidth = (!widthStr.IsEmpty() && NS_SUCCEEDED(widthErrorCode) && mViewportSize.width > 0);
     mValidHeight = (!heightStr.IsEmpty() && NS_SUCCEEDED(heightErrorCode) && mViewportSize.height > 0);
     mAllowZoom = true;
     nsAutoString userScalable;
     GetHeaderData(nsGkAtoms::viewport_user_scalable, userScalable);
     if ((userScalable.EqualsLiteral("0")) ||
         (userScalable.EqualsLiteral("no")) ||
         (userScalable.EqualsLiteral("false"))) {
       mAllowZoom = false;
     }
     mAllowDoubleTapZoom = mAllowZoom;
     mScaleStrEmpty = scaleStr.IsEmpty();
     mWidthStrEmpty = widthStr.IsEmpty();
     mValidScaleFloat = !scaleStr.IsEmpty() && NS_SUCCEEDED(scaleErrorCode);
     mValidMaxScale = !maxScaleStr.IsEmpty() && NS_SUCCEEDED(scaleMaxErrorCode);
     mViewportType = Specified;
   }
   case Specified:
   default:
     CSSIntSize size = mViewportSize;
     if (!mValidWidth) {
       if (mValidHeight && !aDisplaySize.IsEmpty()) {
         size.width = int32_t(size.height * aDisplaySize.width / aDisplaySize.height);
       } else {
         size.width = Preferences::GetInt("browser.viewport.desktopWidth",
                                          kViewportDefaultScreenWidth);
       }
     }
     if (!mValidHeight) {
       if (!aDisplaySize.IsEmpty()) {
         size.height = int32_t(size.width * aDisplaySize.height / aDisplaySize.width);
       } else {
         size.height = size.width;
       }
     }
     // Now convert the scale into device pixels per CSS pixel.
     nsIWidget *widget = nsContentUtils::WidgetForDocument(this);
     CSSToLayoutDeviceScale pixelRatio = widget ? widget->GetDefaultScale()
                                                : CSSToLayoutDeviceScale(1.0f);
     CSSToScreenScale scaleFloat = mScaleFloat * pixelRatio;
     CSSToScreenScale scaleMinFloat = mScaleMinFloat * pixelRatio;
     CSSToScreenScale scaleMaxFloat = mScaleMaxFloat * pixelRatio;
     if (mAutoSize) {
       // aDisplaySize is in screen pixels; convert them to CSS pixels for the viewport size.
       CSSToScreenScale defaultPixelScale = pixelRatio * LayoutDeviceToScreenScale(1.0f);
       size = mozilla::gfx::RoundedToInt(ScreenSize(aDisplaySize) / defaultPixelScale);
     }
     size.width = clamped(size.width, kViewportMinSize.width, kViewportMaxSize.width);
     // Also recalculate the default zoom, if it wasn't specified in the metadata,
     // and the width is specified.
     if (mScaleStrEmpty && !mWidthStrEmpty) {
       CSSToScreenScale defaultScale(float(aDisplaySize.width) / float(size.width));
       scaleFloat = (scaleFloat > defaultScale) ? scaleFloat : defaultScale;
     }
     size.height = clamped(size.height, kViewportMinSize.height, kViewportMaxSize.height);
     // We need to perform a conversion, but only if the initial or maximum
     // scale were set explicitly by the user.
     if (mValidScaleFloat) {
       CSSIntSize displaySize = RoundedToInt(ScreenSize(aDisplaySize) / scaleFloat);
       size.width = std::max(size.width, displaySize.width);
       size.height = std::max(size.height, displaySize.height);
     } else if (mValidMaxScale) {
       CSSIntSize displaySize = RoundedToInt(ScreenSize(aDisplaySize) / scaleMaxFloat);
       size.width = std::max(size.width, displaySize.width);
       size.height = std::max(size.height, displaySize.height);
     }
     return nsViewportInfo(scaleFloat, scaleMinFloat, scaleMaxFloat, size,
                           mAutoSize, mAllowZoom, mAllowDoubleTapZoom);
   }
 }
 EventListenerManager*
 nsDocument::GetOrCreateListenerManager()
 {
   if (!mListenerManager) {
     mListenerManager =
       new EventListenerManager(static_cast<EventTarget*>(this));
     SetFlags(NODE_HAS_LISTENERMANAGER);
   }
   return mListenerManager;
 }
 EventListenerManager*
 nsDocument::GetExistingListenerManager() const
 {
   return mListenerManager;
 }
 nsresult
 nsDocument::PreHandleEvent(EventChainPreVisitor& aVisitor)
 {
   aVisitor.mCanHandle = true;
    // FIXME! This is a hack to make middle mouse paste working also in Editor.
    // Bug 329119
   aVisitor.mForceContentDispatch = true;
   // Load events must not propagate to |window| object, see bug 335251.
   if (aVisitor.mEvent->message != NS_LOAD) {
     nsGlobalWindow* window = static_cast<nsGlobalWindow*>(GetWindow());
     aVisitor.mParentTarget =
       window ? window->GetTargetForEventTargetChain() : nullptr;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::CreateEvent(const nsAString& aEventType, nsIDOMEvent** aReturn)
 {
   NS_ENSURE_ARG_POINTER(aReturn);
   ErrorResult rv;
   *aReturn = nsIDocument::CreateEvent(aEventType, rv).take();
   return rv.ErrorCode();
 }
 already_AddRefed<Event>
 nsIDocument::CreateEvent(const nsAString& aEventType, ErrorResult& rv) const
 {
   nsIPresShell *shell = GetShell();
   nsPresContext *presContext = nullptr;
   if (shell) {
     // Retrieve the context
     presContext = shell->GetPresContext();
   }
   // Create event even without presContext.
   nsCOMPtr<nsIDOMEvent> ev;
   rv = EventDispatcher::CreateEvent(const_cast<nsIDocument*>(this),
                                     presContext, nullptr, aEventType,
                                     getter_AddRefs(ev));
   if (!ev) {
     return nullptr;
   }
   WidgetEvent* e = ev->GetInternalNSEvent();
   e->mFlags.mBubbles = false;
   e->mFlags.mCancelable = false;
   return dont_AddRef(ev.forget().take()->InternalDOMEvent());
 }
 void
 nsDocument::FlushPendingNotifications(mozFlushType aType)
 {
   nsDocumentOnStack dos(this);
   // We need to flush the sink for non-HTML documents (because the XML
   // parser still does insertion with deferred notifications).  We
   // also need to flush the sink if this is a layout-related flush, to
   // make sure that layout is started as needed.  But we can skip that
   // part if we have no presshell or if it's already done an initial
   // reflow.
   if ((!IsHTML() ||
        (aType > Flush_ContentAndNotify && mPresShell &&
         !mPresShell->DidInitialize())) &&
       (mParser || mWeakSink)) {
     nsCOMPtr<nsIContentSink> sink;
     if (mParser) {
       sink = mParser->GetContentSink();
     } else {
       sink = do_QueryReferent(mWeakSink);
       if (!sink) {
         mWeakSink = nullptr;
       }
     }
     // Determine if it is safe to flush the sink notifications
     // by determining if it safe to flush all the presshells.
     if (sink && (aType == Flush_Content || IsSafeToFlush())) {
       sink->FlushPendingNotifications(aType);
     }
   }
   // Should we be flushing pending binding constructors in here?
   if (aType <= Flush_ContentAndNotify) {
     // Nothing to do here
     return;
   }
   // If we have a parent we must flush the parent too to ensure that our
   // container is reflowed if its size was changed.  But if it's not safe to
   // flush ourselves, then don't flush the parent, since that can cause things
   // like resizes of our frame's widget, which we can't handle while flushing
   // is unsafe.
   // Since media queries mean that a size change of our container can
   // affect style, we need to promote a style flush on ourself to a
   // layout flush on our parent, since we need our container to be the
   // correct size to determine the correct style.
   if (mParentDocument && IsSafeToFlush()) {
     mozFlushType parentType = aType;
     if (aType >= Flush_Style)
       parentType = std::max(Flush_Layout, aType);
     mParentDocument->FlushPendingNotifications(parentType);
   }
   // We can optimize away getting our presshell and calling
   // FlushPendingNotifications on it if we don't need a flush of the sort we're
   // looking at.  The one exception is if mInFlush is true, because in that
   // case we might have set mNeedStyleFlush and mNeedLayoutFlush to false
   // already but the presshell hasn't actually done the corresponding work yet.
   // So if mInFlush and reentering this code, we need to flush the presshell.
   if (mNeedStyleFlush ||
       (mNeedLayoutFlush && aType >= Flush_InterruptibleLayout) ||
       aType >= Flush_Display ||
       mInFlush) {
     nsCOMPtr<nsIPresShell> shell = GetShell();
     if (shell) {
       mNeedStyleFlush = false;
       mNeedLayoutFlush = mNeedLayoutFlush && (aType < Flush_InterruptibleLayout);
       // mInFlush is a bitfield, so can't us AutoRestore here.  But we
       // need to keep track of multi-level reentry correctly, so need
       // to restore the old mInFlush value.
       bool oldInFlush = mInFlush;
       mInFlush = true;
       shell->FlushPendingNotifications(aType);
       mInFlush = oldInFlush;
     }
   }
 }
 static bool
 Copy(nsIDocument* aDocument, void* aData)
 {
   nsTArray<nsCOMPtr<nsIDocument> >* resources =
     static_cast<nsTArray<nsCOMPtr<nsIDocument> >* >(aData);
   resources->AppendElement(aDocument);
   return true;
 }
 void
 nsDocument::FlushExternalResources(mozFlushType aType)
 {
   NS_ASSERTION(aType >= Flush_Style,
     "should only need to flush for style or higher in external resources");
   if (GetDisplayDocument()) {
     return;
   }
   nsTArray<nsCOMPtr<nsIDocument> > resources;
   EnumerateExternalResources(Copy, &resources);
   for (uint32_t i = 0; i < resources.Length(); i++) {
     resources[i]->FlushPendingNotifications(aType);
   }
 }
 void
 nsDocument::SetXMLDeclaration(const char16_t *aVersion,
                               const char16_t *aEncoding,
                               const int32_t aStandalone)
 {
   if (!aVersion || *aVersion == '\0') {
     mXMLDeclarationBits = 0;
     return;
   }
   mXMLDeclarationBits = XML_DECLARATION_BITS_DECLARATION_EXISTS;
   if (aEncoding && *aEncoding != '\0') {
     mXMLDeclarationBits |= XML_DECLARATION_BITS_ENCODING_EXISTS;
   }
   if (aStandalone == 1) {
     mXMLDeclarationBits |= XML_DECLARATION_BITS_STANDALONE_EXISTS |
                            XML_DECLARATION_BITS_STANDALONE_YES;
   }
   else if (aStandalone == 0) {
     mXMLDeclarationBits |= XML_DECLARATION_BITS_STANDALONE_EXISTS;
   }
 }
 void
 nsDocument::GetXMLDeclaration(nsAString& aVersion, nsAString& aEncoding,
                               nsAString& aStandalone)
 {
   aVersion.Truncate();
   aEncoding.Truncate();
   aStandalone.Truncate();
   if (!(mXMLDeclarationBits & XML_DECLARATION_BITS_DECLARATION_EXISTS)) {
     return;
   }
   // always until we start supporting 1.1 etc.
   aVersion.AssignLiteral("1.0");
   if (mXMLDeclarationBits & XML_DECLARATION_BITS_ENCODING_EXISTS) {
     // This is what we have stored, not necessarily what was written
     // in the original
     GetCharacterSet(aEncoding);
   }
   if (mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_EXISTS) {
     if (mXMLDeclarationBits & XML_DECLARATION_BITS_STANDALONE_YES) {
       aStandalone.AssignLiteral("yes");
     } else {
       aStandalone.AssignLiteral("no");
     }
   }
 }
 bool
 nsDocument::IsScriptEnabled()
 {
   // If this document is sandboxed without 'allow-scripts'
   // script is not enabled
   if (mSandboxFlags & SANDBOXED_SCRIPTS) {
     return false;
   }
   nsCOMPtr<nsIScriptSecurityManager> sm(do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID));
   NS_ENSURE_TRUE(sm, false);
   nsCOMPtr<nsIScriptGlobalObject> globalObject = do_QueryInterface(GetInnerWindow());
   NS_ENSURE_TRUE(globalObject && globalObject->GetGlobalJSObject(), false);
   return sm->ScriptAllowed(globalObject->GetGlobalJSObject());
 }
 nsRadioGroupStruct*
 nsDocument::GetRadioGroupInternal(const nsAString& aName) const
 {
 #ifdef DEBUG
   if (IsHTML()) {
     nsAutoString lcName;
     ToLowerCase(aName, lcName);
     MOZ_ASSERT(aName == lcName);
   }
 #endif
   nsRadioGroupStruct* radioGroup;
   if (!mRadioGroups.Get(aName, &radioGroup)) {
     return nullptr;
   }
   return radioGroup;
 }
 nsRadioGroupStruct*
 nsDocument::GetRadioGroup(const nsAString& aName) const
 {
   nsAutoString tmKey(aName);
   if (IsHTML()) {
     ToLowerCase(tmKey); //should case-insensitive.
   }
   return GetRadioGroupInternal(tmKey);
 }
 nsRadioGroupStruct*
 nsDocument::GetOrCreateRadioGroup(const nsAString& aName)
 {
   nsAutoString tmKey(aName);
   if (IsHTML()) {
     ToLowerCase(tmKey); //should case-insensitive.
   }
   if (nsRadioGroupStruct* radioGroup = GetRadioGroupInternal(tmKey)) {
     return radioGroup;
   }
   nsAutoPtr<nsRadioGroupStruct> newRadioGroup(new nsRadioGroupStruct());
   mRadioGroups.Put(tmKey, newRadioGroup);
   return newRadioGroup.forget();
 }
 void
 nsDocument::SetCurrentRadioButton(const nsAString& aName,
                                   HTMLInputElement* aRadio)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   radioGroup->mSelectedRadioButton = aRadio;
 }
 HTMLInputElement*
 nsDocument::GetCurrentRadioButton(const nsAString& aName)
 {
   return GetOrCreateRadioGroup(aName)->mSelectedRadioButton;
 }
 NS_IMETHODIMP
 nsDocument::GetNextRadioButton(const nsAString& aName,
                                const bool aPrevious,
                                HTMLInputElement* aFocusedRadio,
                                HTMLInputElement** aRadioOut)
 {
   // XXX Can we combine the HTML radio button method impls of
   //     nsDocument and nsHTMLFormControl?
   // XXX Why is HTML radio button stuff in nsDocument, as
   //     opposed to nsHTMLDocument?
   *aRadioOut = nullptr;
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   // Return the radio button relative to the focused radio button.
   // If no radio is focused, get the radio relative to the selected one.
   nsRefPtr<HTMLInputElement> currentRadio;
   if (aFocusedRadio) {
     currentRadio = aFocusedRadio;
   }
   else {
     currentRadio = radioGroup->mSelectedRadioButton;
     if (!currentRadio) {
       return NS_ERROR_FAILURE;
     }
   }
   int32_t index = radioGroup->mRadioButtons.IndexOf(currentRadio);
   if (index < 0) {
     return NS_ERROR_FAILURE;
   }
   int32_t numRadios = radioGroup->mRadioButtons.Count();
   nsRefPtr<HTMLInputElement> radio;
   do {
     if (aPrevious) {
       if (--index < 0) {
         index = numRadios -1;
       }
     }
     else if (++index >= numRadios) {
       index = 0;
     }
     NS_ASSERTION(static_cast<nsGenericHTMLFormElement*>(radioGroup->mRadioButtons[index])->IsHTML(nsGkAtoms::input),
                  "mRadioButtons holding a non-radio button");
     radio = static_cast<HTMLInputElement*>(radioGroup->mRadioButtons[index]);
   } while (radio->Disabled() && radio != currentRadio);
   radio.forget(aRadioOut);
   return NS_OK;
 }
 void
 nsDocument::AddToRadioGroup(const nsAString& aName,
                             nsIFormControl* aRadio)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   radioGroup->mRadioButtons.AppendObject(aRadio);
   nsCOMPtr<nsIContent> element = do_QueryInterface(aRadio);
   NS_ASSERTION(element, "radio controls have to be content elements");
   if (element->HasAttr(kNameSpaceID_None, nsGkAtoms::required)) {
     radioGroup->mRequiredRadioCount++;
   }
 }
 void
 nsDocument::RemoveFromRadioGroup(const nsAString& aName,
                                  nsIFormControl* aRadio)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   radioGroup->mRadioButtons.RemoveObject(aRadio);
   nsCOMPtr<nsIContent> element = do_QueryInterface(aRadio);
   NS_ASSERTION(element, "radio controls have to be content elements");
   if (element->HasAttr(kNameSpaceID_None, nsGkAtoms::required)) {
     NS_ASSERTION(radioGroup->mRequiredRadioCount != 0,
                  "mRequiredRadioCount about to wrap below 0!");
     radioGroup->mRequiredRadioCount--;
   }
 }
 NS_IMETHODIMP
 nsDocument::WalkRadioGroup(const nsAString& aName,
                            nsIRadioVisitor* aVisitor,
                            bool aFlushContent)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   for (int i = 0; i < radioGroup->mRadioButtons.Count(); i++) {
     if (!aVisitor->Visit(radioGroup->mRadioButtons[i])) {
       return NS_OK;
     }
   }
   return NS_OK;
 }
 uint32_t
 nsDocument::GetRequiredRadioCount(const nsAString& aName) const
 {
   nsRadioGroupStruct* radioGroup = GetRadioGroup(aName);
   return radioGroup ? radioGroup->mRequiredRadioCount : 0;
 }
 void
 nsDocument::RadioRequiredChanged(const nsAString& aName, nsIFormControl* aRadio)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   nsCOMPtr<nsIContent> element = do_QueryInterface(aRadio);
   NS_ASSERTION(element, "radio controls have to be content elements");
   if (element->HasAttr(kNameSpaceID_None, nsGkAtoms::required)) {
     radioGroup->mRequiredRadioCount++;
   } else {
     NS_ASSERTION(radioGroup->mRequiredRadioCount != 0,
                  "mRequiredRadioCount about to wrap below 0!");
     radioGroup->mRequiredRadioCount--;
   }
 }
 bool
 nsDocument::GetValueMissingState(const nsAString& aName) const
 {
   nsRadioGroupStruct* radioGroup = GetRadioGroup(aName);
   return radioGroup && radioGroup->mGroupSuffersFromValueMissing;
 }
 void
 nsDocument::SetValueMissingState(const nsAString& aName, bool aValue)
 {
   nsRadioGroupStruct* radioGroup = GetOrCreateRadioGroup(aName);
   radioGroup->mGroupSuffersFromValueMissing = aValue;
 }
 void
 nsDocument::RetrieveRelevantHeaders(nsIChannel *aChannel)
 {
   nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aChannel);
   PRTime modDate = 0;
   nsresult rv;
   if (httpChannel) {
     nsAutoCString tmp;
     rv = httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("last-modified"),
                                         tmp);
     if (NS_SUCCEEDED(rv)) {
       PRTime time;
       PRStatus st = PR_ParseTimeString(tmp.get(), true, &time);
       if (st == PR_SUCCESS) {
         modDate = time;
       }
     }
     // The misspelled key 'referer' is as per the HTTP spec
     rv = httpChannel->GetRequestHeader(NS_LITERAL_CSTRING("referer"),
                                        mReferrer);
     if (NS_FAILED(rv)) {
       mReferrer.Truncate();
     }
     static const char *const headers[] = {
       "default-style",
       "content-style-type",
       "content-language",
       "content-disposition",
       "refresh",
       "x-dns-prefetch-control",
       "x-frame-options",
       // add more http headers if you need
       // XXXbz don't add content-location support without reading bug
       // 238654 and its dependencies/dups first.
 
     };
     nsAutoCString headerVal;
     const char *const *name = headers;
     while (*name) {
       rv =
         httpChannel->GetResponseHeader(nsDependentCString(*name), headerVal);
       if (NS_SUCCEEDED(rv) && !headerVal.IsEmpty()) {
         nsCOMPtr<nsIAtom> key = do_GetAtom(*name);
         SetHeaderData(key, NS_ConvertASCIItoUTF16(headerVal));
       }
       ++name;
     }
   } else {
     nsCOMPtr<nsIFileChannel> fileChannel = do_QueryInterface(aChannel);
     if (fileChannel) {
       nsCOMPtr<nsIFile> file;
       fileChannel->GetFile(getter_AddRefs(file));
       if (file) {
         PRTime msecs;
         rv = file->GetLastModifiedTime(&msecs);
         if (NS_SUCCEEDED(rv)) {
           modDate = msecs * int64_t(PR_USEC_PER_MSEC);
         }
       }
     } else {
       nsAutoCString contentDisp;
       rv = aChannel->GetContentDispositionHeader(contentDisp);
       if (NS_SUCCEEDED(rv)) {
         SetHeaderData(nsGkAtoms::headerContentDisposition,
                       NS_ConvertASCIItoUTF16(contentDisp));
       }
     }
   }
   if (modDate == 0) {
     // We got nothing from our attempt to ask nsIFileChannel and
     // nsIHttpChannel for the last modified time. Return the current
     // time.
     modDate = PR_Now();
   }
   mLastModified.Truncate();
   if (modDate != 0) {
     PRExplodedTime prtime;
     PR_ExplodeTime(modDate, PR_LocalTimeParameters, &prtime);
     // "MM/DD/YYYY hh:mm:ss"
     char formatedTime[24];
     if (PR_snprintf(formatedTime, sizeof(formatedTime),
                     "%02ld/%02ld/%04hd %02ld:%02ld:%02ld",
                     prtime.tm_month + 1, prtime.tm_mday, prtime.tm_year,
                     prtime.tm_hour     ,  prtime.tm_min,  prtime.tm_sec)) {
       CopyASCIItoUTF16(nsDependentCString(formatedTime), mLastModified);
     }
   }
 }
 nsresult
 nsDocument::CreateElem(const nsAString& aName, nsIAtom *aPrefix, int32_t aNamespaceID,
                        nsIContent **aResult)
 {
 #ifdef DEBUG
   nsAutoString qName;
   if (aPrefix) {
     aPrefix->ToString(qName);
     qName.Append(':');
   }
   qName.Append(aName);
   // Note: "a:b:c" is a valid name in non-namespaces XML, and
   // nsDocument::CreateElement can call us with such a name and no prefix,
   // which would cause an error if we just used true here.
   bool nsAware = aPrefix != nullptr || aNamespaceID != GetDefaultNamespaceID();
   NS_ASSERTION(NS_SUCCEEDED(nsContentUtils::CheckQName(qName, nsAware)),
                "Don't pass invalid prefixes to nsDocument::CreateElem, "
                "check caller.");
 #endif
   *aResult = nullptr;
   nsCOMPtr<nsINodeInfo> nodeInfo;
   mNodeInfoManager->GetNodeInfo(aName, aPrefix, aNamespaceID,
                                 nsIDOMNode::ELEMENT_NODE,
                                 getter_AddRefs(nodeInfo));
   NS_ENSURE_TRUE(nodeInfo, NS_ERROR_OUT_OF_MEMORY);
   nsCOMPtr<Element> element;
   nsresult rv = NS_NewElement(getter_AddRefs(element), nodeInfo.forget(),
                               NOT_FROM_PARSER);
   element.forget(aResult);
   return rv;
 }
 bool
 nsDocument::IsSafeToFlush() const
 {
   nsIPresShell* shell = GetShell();
   if (!shell)
     return true;
   return shell->IsSafeToFlush();
 }
 void
 nsDocument::Sanitize()
 {
   // Sanitize the document by resetting all password fields and any form
   // fields with autocomplete=off to their default values.  We do this now,
   // instead of when the presentation is restored, to offer some protection
   // in case there is ever an exploit that allows a cached document to be
   // accessed from a different document.
   // First locate all input elements, regardless of whether they are
   // in a form, and reset the password and autocomplete=off elements.
   nsRefPtr<nsContentList> nodes = GetElementsByTagName(NS_LITERAL_STRING("input"));
   nsCOMPtr<nsIContent> item;
   nsAutoString value;
   uint32_t length = nodes->Length(true);
   for (uint32_t i = 0; i < length; ++i) {
     NS_ASSERTION(nodes->Item(i), "null item in node list!");
     nsRefPtr<HTMLInputElement> input = HTMLInputElement::FromContentOrNull(nodes->Item(i));
     if (!input)
       continue;
     bool resetValue = false;
     input->GetAttribute(NS_LITERAL_STRING("autocomplete"), value);
     if (value.LowerCaseEqualsLiteral("off")) {
       resetValue = true;
     } else {
       input->GetType(value);
       if (value.LowerCaseEqualsLiteral("password"))
         resetValue = true;
     }
     if (resetValue) {
       input->Reset();
     }
   }
   // Now locate all _form_ elements that have autocomplete=off and reset them
   nodes = GetElementsByTagName(NS_LITERAL_STRING("form"));
   length = nodes->Length(true);
   for (uint32_t i = 0; i < length; ++i) {
     NS_ASSERTION(nodes->Item(i), "null item in nodelist");
     nsCOMPtr<nsIDOMHTMLFormElement> form = do_QueryInterface(nodes->Item(i));
     if (!form)
       continue;
     nodes->Item(i)->AsElement()->GetAttr(kNameSpaceID_None,
                                          nsGkAtoms::autocomplete, value);
     if (value.LowerCaseEqualsLiteral("off"))
       form->Reset();
   }
 }
 struct SubDocEnumArgs
 {
   nsIDocument::nsSubDocEnumFunc callback;
   void *data;
 };
 static PLDHashOperator
 SubDocHashEnum(PLDHashTable *table, PLDHashEntryHdr *hdr,
                uint32_t number, void *arg)
 {
   SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
   SubDocEnumArgs *args = static_cast<SubDocEnumArgs*>(arg);
   nsIDocument *subdoc = entry->mSubDocument;
   bool next = subdoc ? args->callback(subdoc, args->data) : true;
   return next ? PL_DHASH_NEXT : PL_DHASH_STOP;
 }
 void
 nsDocument::EnumerateSubDocuments(nsSubDocEnumFunc aCallback, void *aData)
 {
   if (mSubDocuments) {
     SubDocEnumArgs args = { aCallback, aData };
     PL_DHashTableEnumerate(mSubDocuments, SubDocHashEnum, &args);
   }
 }
 static PLDHashOperator
 CanCacheSubDocument(PLDHashTable *table, PLDHashEntryHdr *hdr,
                     uint32_t number, void *arg)
 {
   SubDocMapEntry *entry = static_cast<SubDocMapEntry*>(hdr);
   bool *canCacheArg = static_cast<bool*>(arg);
   nsIDocument *subdoc = entry->mSubDocument;
   // The aIgnoreRequest we were passed is only for us, so don't pass it on.
   bool canCache = subdoc ? subdoc->CanSavePresentation(nullptr) : false;
   if (!canCache) {
     *canCacheArg = false;
     return PL_DHASH_STOP;
   }
   return PL_DHASH_NEXT;
 }
 #ifdef DEBUG_bryner
 #define DEBUG_PAGE_CACHE
 #endif
 bool
 nsDocument::CanSavePresentation(nsIRequest *aNewRequest)
 {
   if (EventHandlingSuppressed()) {
     return false;
   }
   nsPIDOMWindow* win = GetInnerWindow();
   if (win && win->TimeoutSuspendCount()) {
     return false;
   }
   // Check our event listener manager for unload/beforeunload listeners.
   nsCOMPtr<EventTarget> piTarget = do_QueryInterface(mScriptGlobalObject);
   if (piTarget) {
     EventListenerManager* manager = piTarget->GetExistingListenerManager();
     if (manager && manager->HasUnloadListeners()) {
       return false;
     }
   }
   // Check if we have pending network requests
   nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
   if (loadGroup) {
     nsCOMPtr<nsISimpleEnumerator> requests;
     loadGroup->GetRequests(getter_AddRefs(requests));
     bool hasMore = false;
     // We want to bail out if we have any requests other than aNewRequest (or
     // in the case when aNewRequest is a part of a multipart response the base
     // channel the multipart response is coming in on).
     nsCOMPtr<nsIChannel> baseChannel;
     nsCOMPtr<nsIMultiPartChannel> part(do_QueryInterface(aNewRequest));
     if (part) {
       part->GetBaseChannel(getter_AddRefs(baseChannel));
     }
     while (NS_SUCCEEDED(requests->HasMoreElements(&hasMore)) && hasMore) {
       nsCOMPtr<nsISupports> elem;
       requests->GetNext(getter_AddRefs(elem));
       nsCOMPtr<nsIRequest> request = do_QueryInterface(elem);
       if (request && request != aNewRequest && request != baseChannel) {
 #ifdef DEBUG_PAGE_CACHE
         nsAutoCString requestName, docSpec;
         request->GetName(requestName);
         if (mDocumentURI)
           mDocumentURI->GetSpec(docSpec);
         printf("document %s has request %s\n",
                docSpec.get(), requestName.get());
 #endif
         return false;
       }
     }
   }
   // Check if we have running offline storage transactions
   quota::QuotaManager* quotaManager =
     win ? quota::QuotaManager::Get() : nullptr;
   if (quotaManager && quotaManager->HasOpenTransactions(win)) {
    return false;
   }
 #ifdef MOZ_MEDIA_NAVIGATOR
   // Check if we have active GetUserMedia use
   if (MediaManager::Exists() && win &&
       MediaManager::Get()->IsWindowStillActive(win->WindowID())) {
     return false;
   }
 #endif // MOZ_MEDIA_NAVIGATOR
 #ifdef MOZ_WEBRTC
   // Check if we have active PeerConnections
   nsCOMPtr<IPeerConnectionManager> pcManager =
     do_GetService(IPEERCONNECTION_MANAGER_CONTRACTID);
   if (pcManager && win) {
     bool active;
     pcManager->HasActivePeerConnection(win->WindowID(), &active);
     if (active) {
       return false;
     }
   }
 #endif // MOZ_WEBRTC
   bool canCache = true;
   if (mSubDocuments)
     PL_DHashTableEnumerate(mSubDocuments, CanCacheSubDocument, &canCache);
   return canCache;
 }
 void
 nsDocument::Destroy()
 {
   // The ContentViewer wants to release the document now.  So, tell our content
   // to drop any references to the document so that it can be destroyed.
   if (mIsGoingAway)
     return;
   mIsGoingAway = true;
   RemovedFromDocShell();
   bool oldVal = mInUnlinkOrDeletion;
   mInUnlinkOrDeletion = true;
   uint32_t i, count = mChildren.ChildCount();
   for (i = 0; i < count; ++i) {
     mChildren.ChildAt(i)->DestroyContent();
   }
   mInUnlinkOrDeletion = oldVal;
   mLayoutHistoryState = nullptr;
   // Shut down our external resource map.  We might not need this for
   // leak-fixing if we fix nsDocumentViewer to do cycle-collection, but
   // tearing down all those frame trees right now is the right thing to do.
   mExternalResourceMap.Shutdown();
   mRegistry = nullptr;
   // XXX We really should let cycle collection do this, but that currently still
   //     leaks (see https://bugzilla.mozilla.org/show_bug.cgi?id=406684).
   ReleaseWrapper(static_cast<nsINode*>(this));
 }
 void
 nsDocument::RemovedFromDocShell()
 {
   if (mRemovedFromDocShell)
     return;
   mRemovedFromDocShell = true;
   EnumerateFreezableElements(NotifyActivityChanged, nullptr);
   uint32_t i, count = mChildren.ChildCount();
   for (i = 0; i < count; ++i) {
     mChildren.ChildAt(i)->SaveSubtreeState();
   }
 }
 already_AddRefed<nsILayoutHistoryState>
 nsDocument::GetLayoutHistoryState() const
 {
   nsCOMPtr<nsILayoutHistoryState> state;
   if (!mScriptGlobalObject) {
     state = mLayoutHistoryState;
   } else {
     nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
     if (docShell) {
       docShell->GetLayoutHistoryState(getter_AddRefs(state));
     }
   }
   return state.forget();
 }
 void
 nsDocument::EnsureOnloadBlocker()
 {
   // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup
   // -- it's not ours.
   if (mOnloadBlockCount != 0 && mScriptGlobalObject) {
     nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
     if (loadGroup) {
       // Check first to see if mOnloadBlocker is in the loadgroup.
       nsCOMPtr<nsISimpleEnumerator> requests;
       loadGroup->GetRequests(getter_AddRefs(requests));
       bool hasMore = false;
       while (NS_SUCCEEDED(requests->HasMoreElements(&hasMore)) && hasMore) {
         nsCOMPtr<nsISupports> elem;
         requests->GetNext(getter_AddRefs(elem));
         nsCOMPtr<nsIRequest> request = do_QueryInterface(elem);
         if (request && request == mOnloadBlocker) {
           return;
         }
       }
       // Not in the loadgroup, so add it.
       loadGroup->AddRequest(mOnloadBlocker, nullptr);
     }
   }
 }
 void
 nsDocument::AsyncBlockOnload()
 {
   while (mAsyncOnloadBlockCount) {
     --mAsyncOnloadBlockCount;
     BlockOnload();
   }
 }
 void
 nsDocument::BlockOnload()
 {
   if (mDisplayDocument) {
     mDisplayDocument->BlockOnload();
     return;
   }
   // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup
   // -- it's not ours.
   if (mOnloadBlockCount == 0 && mScriptGlobalObject) {
     if (!nsContentUtils::IsSafeToRunScript()) {
       // Because AddRequest may lead to OnStateChange calls in chrome,
       // block onload only when there are no script blockers.
       ++mAsyncOnloadBlockCount;
       if (mAsyncOnloadBlockCount == 1) {
         bool success = nsContentUtils::AddScriptRunner(
           NS_NewRunnableMethod(this, &nsDocument::AsyncBlockOnload));
         // The script runner shouldn't fail to add. But if somebody broke
         // something and it does, we'll thrash at 100% cpu forever. The best
         // response is just to ignore the onload blocking request. See bug 579535.
         if (!success) {
           NS_WARNING("Disaster! Onload blocking script runner failed to add - expect bad things!");
           mAsyncOnloadBlockCount = 0;
         }
       }
       return;
     }
     nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
     if (loadGroup) {
       loadGroup->AddRequest(mOnloadBlocker, nullptr);
     }
   }
   ++mOnloadBlockCount;
 }
 void
 nsDocument::UnblockOnload(bool aFireSync)
 {
   if (mDisplayDocument) {
     mDisplayDocument->UnblockOnload(aFireSync);
     return;
   }
   if (mOnloadBlockCount == 0 && mAsyncOnloadBlockCount == 0) {
     NS_NOTREACHED("More UnblockOnload() calls than BlockOnload() calls; dropping call");
     return;
   }
   --mOnloadBlockCount;
   if (mOnloadBlockCount == 0) {
     if (mScriptGlobalObject) {
       // Only manipulate the loadgroup in this case, because if mScriptGlobalObject
       // is null, it's not ours.
       if (aFireSync && mAsyncOnloadBlockCount == 0) {
         // Increment mOnloadBlockCount, since DoUnblockOnload will decrement it
         ++mOnloadBlockCount;
         DoUnblockOnload();
       } else {
         PostUnblockOnloadEvent();
       }
     } else if (mIsBeingUsedAsImage) {
       // To correctly unblock onload for a document that contains an SVG
       // image, we need to know when all of the SVG document's resources are
       // done loading, in a way comparable to |window.onload|. We fire this
       // event to indicate that the SVG should be considered fully loaded.
       // Because scripting is disabled on SVG-as-image documents, this event
       // is not accessible to content authors. (See bug 837135.)
       nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
         new AsyncEventDispatcher(this,
                                  NS_LITERAL_STRING("MozSVGAsImageDocumentLoad"),
                                  false,
                                  false);
       asyncDispatcher->PostDOMEvent();
     }
   }
 }
 class nsUnblockOnloadEvent : public nsRunnable {
 public:
   nsUnblockOnloadEvent(nsDocument *doc) : mDoc(doc) {}
   NS_IMETHOD Run() {
     mDoc->DoUnblockOnload();
     return NS_OK;
   }
 private:
   nsRefPtr<nsDocument> mDoc;
 };
 void
 nsDocument::PostUnblockOnloadEvent()
 {
   nsCOMPtr<nsIRunnable> evt = new nsUnblockOnloadEvent(this);
   nsresult rv = NS_DispatchToCurrentThread(evt);
   if (NS_SUCCEEDED(rv)) {
     // Stabilize block count so we don't post more events while this one is up
     ++mOnloadBlockCount;
   } else {
     NS_WARNING("failed to dispatch nsUnblockOnloadEvent");
   }
 }
 void
 nsDocument::DoUnblockOnload()
 {
   NS_PRECONDITION(!mDisplayDocument,
                   "Shouldn't get here for resource document");
   NS_PRECONDITION(mOnloadBlockCount != 0,
                   "Shouldn't have a count of zero here, since we stabilized in "
                   "PostUnblockOnloadEvent");
   --mOnloadBlockCount;
   if (mOnloadBlockCount != 0) {
     // We blocked again after the last unblock.  Nothing to do here.  We'll
     // post a new event when we unblock again.
     return;
   }
   if (mAsyncOnloadBlockCount != 0) {
     // We need to wait until the async onload block has been handled.
     PostUnblockOnloadEvent();
   }
   // If mScriptGlobalObject is null, we shouldn't be messing with the loadgroup
   // -- it's not ours.
   if (mScriptGlobalObject) {
     nsCOMPtr<nsILoadGroup> loadGroup = GetDocumentLoadGroup();
     if (loadGroup) {
       loadGroup->RemoveRequest(mOnloadBlocker, nullptr, NS_OK);
     }
   }
 }
 nsIContent*
 nsDocument::GetContentInThisDocument(nsIFrame* aFrame) const
 {
   for (nsIFrame* f = aFrame; f;
        f = nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(f)) {
     nsIContent* content = f->GetContent();
     if (!content || content->IsInAnonymousSubtree())
       continue;
     if (content->OwnerDoc() == this) {
       return content;
     }
     // We must be in a subdocument so jump directly to the root frame.
     // GetParentOrPlaceholderForCrossDoc gets called immediately to jump up to
     // the containing document.
     f = f->PresContext()->GetPresShell()->GetRootFrame();
   }
   return nullptr;
 }
 void
 nsDocument::DispatchPageTransition(EventTarget* aDispatchTarget,
                                    const nsAString& aType,
                                    bool aPersisted)
 {
   if (aDispatchTarget) {
     nsCOMPtr<nsIDOMEvent> event;
     CreateEvent(NS_LITERAL_STRING("pagetransition"), getter_AddRefs(event));
     nsCOMPtr<nsIDOMPageTransitionEvent> ptEvent = do_QueryInterface(event);
     if (ptEvent && NS_SUCCEEDED(ptEvent->InitPageTransitionEvent(aType, true,
                                                                  true,
                                                                  aPersisted))) {
       event->SetTrusted(true);
       event->SetTarget(this);
       EventDispatcher::DispatchDOMEvent(aDispatchTarget, nullptr, event,
                                         nullptr, nullptr);
     }
   }
 }
 static bool
 NotifyPageShow(nsIDocument* aDocument, void* aData)
 {
   const bool* aPersistedPtr = static_cast<const bool*>(aData);
   aDocument->OnPageShow(*aPersistedPtr, nullptr);
   return true;
 }
 void
 nsDocument::OnPageShow(bool aPersisted,
                        EventTarget* aDispatchStartTarget)
 {
   mVisible = true;
   EnumerateFreezableElements(NotifyActivityChanged, nullptr);
   EnumerateExternalResources(NotifyPageShow, &aPersisted);
   Element* root = GetRootElement();
   if (aPersisted && root) {
     // Send out notifications that our <link> elements are attached.
     nsRefPtr<nsContentList> links = NS_GetContentList(root,
                                                       kNameSpaceID_XHTML,
                                                       NS_LITERAL_STRING("link"));
     uint32_t linkCount = links->Length(true);
     for (uint32_t i = 0; i < linkCount; ++i) {
       static_cast<HTMLLinkElement*>(links->Item(i, false))->LinkAdded();
     }
   }
   // See nsIDocument
   if (!aDispatchStartTarget) {
     // Set mIsShowing before firing events, in case those event handlers
     // move us around.
     mIsShowing = true;
   }
   if (mAnimationController) {
     mAnimationController->OnPageShow();
   }
   if (aPersisted) {
     SetImagesNeedAnimating(true);
   }
   UpdateVisibilityState();
   nsCOMPtr<EventTarget> target = aDispatchStartTarget;
   if (!target) {
     target = do_QueryInterface(GetWindow());
   }
   // Dispatch observer notification to notify observers page is shown.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   nsIPrincipal *principal = GetPrincipal();
   os->NotifyObservers(static_cast<nsIDocument*>(this),
                       nsContentUtils::IsSystemPrincipal(principal) ?
                         "chrome-page-shown" :
                         "content-page-shown",
                       nullptr);
   DispatchPageTransition(target, NS_LITERAL_STRING("pageshow"), aPersisted);
 }
 static bool
 NotifyPageHide(nsIDocument* aDocument, void* aData)
 {
   const bool* aPersistedPtr = static_cast<const bool*>(aData);
   aDocument->OnPageHide(*aPersistedPtr, nullptr);
   return true;
 }
 static void
 DispatchFullScreenChange(nsIDocument* aTarget)
 {
   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(aTarget,
                              NS_LITERAL_STRING("mozfullscreenchange"),
                              true,
                              false);
   asyncDispatcher->PostDOMEvent();
 }
 void
 nsDocument::OnPageHide(bool aPersisted,
                        EventTarget* aDispatchStartTarget)
 {
   // Send out notifications that our <link> elements are detached,
   // but only if this is not a full unload.
   Element* root = GetRootElement();
   if (aPersisted && root) {
     nsRefPtr<nsContentList> links = NS_GetContentList(root,
                                                       kNameSpaceID_XHTML,
                                                       NS_LITERAL_STRING("link"));
     uint32_t linkCount = links->Length(true);
     for (uint32_t i = 0; i < linkCount; ++i) {
       static_cast<HTMLLinkElement*>(links->Item(i, false))->LinkRemoved();
     }
   }
   // See nsIDocument
   if (!aDispatchStartTarget) {
     // Set mIsShowing before firing events, in case those event handlers
     // move us around.
     mIsShowing = false;
   }
   if (mAnimationController) {
     mAnimationController->OnPageHide();
   }
   if (aPersisted) {
     SetImagesNeedAnimating(false);
   }
   MozExitPointerLock();
   // Now send out a PageHide event.
   nsCOMPtr<EventTarget> target = aDispatchStartTarget;
   if (!target) {
     target = do_QueryInterface(GetWindow());
   }
   // Dispatch observer notification to notify observers page is hidden.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   nsIPrincipal *principal = GetPrincipal();
   os->NotifyObservers(static_cast<nsIDocument*>(this),
                       nsContentUtils::IsSystemPrincipal(principal) ?
                         "chrome-page-hidden" :
                         "content-page-hidden",
                       nullptr);
   DispatchPageTransition(target, NS_LITERAL_STRING("pagehide"), aPersisted);
   mVisible = false;
   UpdateVisibilityState();
   EnumerateExternalResources(NotifyPageHide, &aPersisted);
   EnumerateFreezableElements(NotifyActivityChanged, nullptr);
   if (IsFullScreenDoc()) {
     // If this document was fullscreen, we should exit fullscreen in this
     // doctree branch. This ensures that if the user navigates while in
     // fullscreen mode we don't leave its still visible ancestor documents
     // in fullscreen mode. So exit fullscreen in the document's fullscreen
     // root document, as this will exit fullscreen in all the root's
     // descendant documents. Note that documents are removed from the
     // doctree by the time OnPageHide() is called, so we must store a
     // reference to the root (in nsDocument::mFullscreenRoot) since we can't
     // just traverse the doctree to get the root.
     nsIDocument::ExitFullscreen(this, /* async */ false);
     // Since the document is removed from the doctree before OnPageHide() is
     // called, ExitFullscreen() can't traverse from the root down to *this*
     // document, so we must manually call CleanupFullscreenState() below too.
     // Note that CleanupFullscreenState() clears nsDocument::mFullscreenRoot,
     // so we *must* call it after ExitFullscreen(), not before.
     // OnPageHide() is called in every hidden (i.e. descendant) document,
     // so calling CleanupFullscreenState() here will ensure all hidden
     // documents have their fullscreen state reset.
     CleanupFullscreenState();
     // If anyone was listening to this document's state, advertizing the state
     // change would be the least of the politeness.
     DispatchFullScreenChange(this);
   }
 }
 void
 nsDocument::WillDispatchMutationEvent(nsINode* aTarget)
 {
   NS_ASSERTION(mSubtreeModifiedDepth != 0 ||
                mSubtreeModifiedTargets.Count() == 0,
                "mSubtreeModifiedTargets not cleared after dispatching?");
   ++mSubtreeModifiedDepth;
   if (aTarget) {
     // MayDispatchMutationEvent is often called just before this method,
     // so it has already appended the node to mSubtreeModifiedTargets.
     int32_t count = mSubtreeModifiedTargets.Count();
     if (!count || mSubtreeModifiedTargets[count - 1] != aTarget) {
       mSubtreeModifiedTargets.AppendObject(aTarget);
     }
   }
 }
 void
 nsDocument::MutationEventDispatched(nsINode* aTarget)
 {
   --mSubtreeModifiedDepth;
   if (mSubtreeModifiedDepth == 0) {
     int32_t count = mSubtreeModifiedTargets.Count();
     if (!count) {
       return;
     }
     nsCOMPtr<nsPIDOMWindow> window;
     window = do_QueryInterface(GetWindow());
     if (window &&
         !window->HasMutationListeners(NS_EVENT_BITS_MUTATION_SUBTREEMODIFIED)) {
       mSubtreeModifiedTargets.Clear();
       return;
     }
     nsCOMArray<nsINode> realTargets;
     for (int32_t i = 0; i < count; ++i) {
       nsINode* possibleTarget = mSubtreeModifiedTargets[i];
       nsCOMPtr<nsIContent> content = do_QueryInterface(possibleTarget);
       if (content && content->ChromeOnlyAccess()) {
         continue;
       }
       nsINode* commonAncestor = nullptr;
       int32_t realTargetCount = realTargets.Count();
       for (int32_t j = 0; j < realTargetCount; ++j) {
         commonAncestor =
           nsContentUtils::GetCommonAncestor(possibleTarget, realTargets[j]);
         if (commonAncestor) {
           realTargets.ReplaceObjectAt(commonAncestor, j);
           break;
         }
       }
       if (!commonAncestor) {
         realTargets.AppendObject(possibleTarget);
       }
     }
     mSubtreeModifiedTargets.Clear();
     int32_t realTargetCount = realTargets.Count();
     for (int32_t k = 0; k < realTargetCount; ++k) {
       InternalMutationEvent mutation(true, NS_MUTATION_SUBTREEMODIFIED);
       (new AsyncEventDispatcher(realTargets[k], mutation))->
         RunDOMEventWhenSafe();
     }
   }
 }
 void
 nsDocument::AddStyleRelevantLink(Link* aLink)
 {
   NS_ASSERTION(aLink, "Passing in a null link.  Expect crashes RSN!");
 #ifdef DEBUG
   nsPtrHashKey<Link>* entry = mStyledLinks.GetEntry(aLink);
   NS_ASSERTION(!entry, "Document already knows about this Link!");
   mStyledLinksCleared = false;
 #endif
   (void)mStyledLinks.PutEntry(aLink);
 }
 void
 nsDocument::ForgetLink(Link* aLink)
 {
   NS_ASSERTION(aLink, "Passing in a null link.  Expect crashes RSN!");
 #ifdef DEBUG
   nsPtrHashKey<Link>* entry = mStyledLinks.GetEntry(aLink);
   NS_ASSERTION(entry || mStyledLinksCleared,
                "Document knows nothing about this Link!");
 #endif
   (void)mStyledLinks.RemoveEntry(aLink);
 }
 void
 nsDocument::DestroyElementMaps()
 {
 #ifdef DEBUG
   mStyledLinksCleared = true;
 #endif
   mStyledLinks.Clear();
   mIdentifierMap.Clear();
   ++mExpandoAndGeneration.generation;
 }
 static
 PLDHashOperator
 EnumerateStyledLinks(nsPtrHashKey<Link>* aEntry, void* aArray)
 {
   LinkArray* array = static_cast<LinkArray*>(aArray);
   (void)array->AppendElement(aEntry->GetKey());
   return PL_DHASH_NEXT;
 }
 void
 nsDocument::RefreshLinkHrefs()
 {
   // Get a list of all links we know about.  We will reset them, which will
   // remove them from the document, so we need a copy of what is in the
   // hashtable.
   LinkArray linksToNotify(mStyledLinks.Count());
   (void)mStyledLinks.EnumerateEntries(EnumerateStyledLinks, &linksToNotify);
   // Reset all of our styled links.
   nsAutoScriptBlocker scriptBlocker;
   for (LinkArray::size_type i = 0; i < linksToNotify.Length(); i++) {
     linksToNotify[i]->ResetLinkState(true, linksToNotify[i]->ElementHasHref());
   }
 }
 nsresult
 nsDocument::CloneDocHelper(nsDocument* clone) const
 {
   clone->mIsStaticDocument = mCreatingStaticClone;
   // Init document
   nsresult rv = clone->Init();
   NS_ENSURE_SUCCESS(rv, rv);
   // Set URI/principal
   clone->nsDocument::SetDocumentURI(nsIDocument::GetDocumentURI());
   clone->SetChromeXHRDocURI(mChromeXHRDocURI);
   // Must set the principal first, since SetBaseURI checks it.
   clone->SetPrincipal(NodePrincipal());
   clone->mDocumentBaseURI = mDocumentBaseURI;
   clone->SetChromeXHRDocBaseURI(mChromeXHRDocBaseURI);
   if (mCreatingStaticClone) {
     nsCOMPtr<nsILoadGroup> loadGroup;
     // |mDocumentContainer| is the container of the document that is being
     // created and not the original container. See CreateStaticClone function().
     nsCOMPtr<nsIDocumentLoader> docLoader(mDocumentContainer);
     if (docLoader) {
       docLoader->GetLoadGroup(getter_AddRefs(loadGroup));
     }
     nsCOMPtr<nsIChannel> channel = GetChannel();
     if (channel && loadGroup) {
       clone->Reset(channel, loadGroup);
     } else {
       nsIURI* uri = static_cast<const nsIDocument*>(this)->GetDocumentURI();
       if (uri) {
         clone->ResetToURI(uri, loadGroup, NodePrincipal());
       }
     }
     clone->SetContainer(mDocumentContainer);
   }
   // Set scripting object
   bool hasHadScriptObject = true;
   nsIScriptGlobalObject* scriptObject =
     GetScriptHandlingObject(hasHadScriptObject);
   NS_ENSURE_STATE(scriptObject || !hasHadScriptObject);
   if (scriptObject) {
     clone->SetScriptHandlingObject(scriptObject);
   } else {
     clone->SetScopeObject(GetScopeObject());
   }
   // Make the clone a data document
   clone->SetLoadedAsData(true);
   // Misc state
   // State from nsIDocument
   clone->mCharacterSet = mCharacterSet;
   clone->mCharacterSetSource = mCharacterSetSource;
   clone->mCompatMode = mCompatMode;
   clone->mBidiOptions = mBidiOptions;
   clone->mContentLanguage = mContentLanguage;
   clone->SetContentTypeInternal(GetContentTypeInternal());
   clone->mSecurityInfo = mSecurityInfo;
   // State from nsDocument
   clone->mIsRegularHTML = mIsRegularHTML;
   clone->mXMLDeclarationBits = mXMLDeclarationBits;
   clone->mBaseTarget = mBaseTarget;
   return NS_OK;
 }
 void
 nsDocument::SetReadyStateInternal(ReadyState rs)
 {
   mReadyState = rs;
   if (rs == READYSTATE_UNINITIALIZED) {
     // Transition back to uninitialized happens only to keep assertions happy
     // right before readyState transitions to something else. Make this
     // transition undetectable by Web content.
     return;
   }
   if (mTiming) {
     switch (rs) {
       case READYSTATE_LOADING:
         mTiming->NotifyDOMLoading(nsIDocument::GetDocumentURI());
         break;
       case READYSTATE_INTERACTIVE:
         mTiming->NotifyDOMInteractive(nsIDocument::GetDocumentURI());
         break;
       case READYSTATE_COMPLETE:
         mTiming->NotifyDOMComplete(nsIDocument::GetDocumentURI());
         break;
       default:
         NS_WARNING("Unexpected ReadyState value");
         break;
     }
   }
   // At the time of loading start, we don't have timing object, record time.
   if (READYSTATE_LOADING == rs) {
     mLoadingTimeStamp = mozilla::TimeStamp::Now();
   }
   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(this, NS_LITERAL_STRING("readystatechange"),
                              false, false);
   asyncDispatcher->RunDOMEventWhenSafe();
 }
 NS_IMETHODIMP
 nsDocument::GetReadyState(nsAString& aReadyState)
 {
   nsIDocument::GetReadyState(aReadyState);
   return NS_OK;
 }
 void
 nsIDocument::GetReadyState(nsAString& aReadyState) const
 {
   switch(mReadyState) {
   case READYSTATE_LOADING :
     aReadyState.Assign(NS_LITERAL_STRING("loading"));
     break;
   case READYSTATE_INTERACTIVE :
     aReadyState.Assign(NS_LITERAL_STRING("interactive"));
     break;
   case READYSTATE_COMPLETE :
     aReadyState.Assign(NS_LITERAL_STRING("complete"));
     break;
   default:
     aReadyState.Assign(NS_LITERAL_STRING("uninitialized"));
   }
 }
 namespace {
 struct SuppressArgs
 {
   nsIDocument::SuppressionType mWhat;
   uint32_t mIncrease;
 };
 }
 static bool
 SuppressEventHandlingInDocument(nsIDocument* aDocument, void* aData)
 {
   SuppressArgs* args = static_cast<SuppressArgs*>(aData);
   aDocument->SuppressEventHandling(args->mWhat, args->mIncrease);
   return true;
 }
 void
 nsDocument::SuppressEventHandling(nsIDocument::SuppressionType aWhat,
                                   uint32_t aIncrease)
 {
   if (mEventsSuppressed == 0 && mAnimationsPaused == 0 &&
       aIncrease != 0 && mPresShell && mScriptGlobalObject) {
     RevokeAnimationFrameNotifications();
   }
   if (aWhat == eAnimationsOnly) {
     mAnimationsPaused += aIncrease;
   } else {
     mEventsSuppressed += aIncrease;
   }
   SuppressArgs args = { aWhat, aIncrease };
   EnumerateSubDocuments(SuppressEventHandlingInDocument, &args);
 }
 static void
 FireOrClearDelayedEvents(nsTArray<nsCOMPtr<nsIDocument> >& aDocuments,
                          bool aFireEvents)
 {
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm)
     return;
   for (uint32_t i = 0; i < aDocuments.Length(); ++i) {
     // NB: Don't bother trying to fire delayed events on documents that were
     // closed before this event ran.
     if (!aDocuments[i]->EventHandlingSuppressed()) {
       fm->FireDelayedEvents(aDocuments[i]);
       nsCOMPtr<nsIPresShell> shell = aDocuments[i]->GetShell();
       if (shell) {
         // Only fire events for active documents.
         bool fire = aFireEvents &&
                     aDocuments[i]->GetInnerWindow() &&
                     aDocuments[i]->GetInnerWindow()->IsCurrentInnerWindow();
         shell->FireOrClearDelayedEvents(fire);
       }
     }
   }
 }
 void
 nsDocument::MaybePreLoadImage(nsIURI* uri, const nsAString &aCrossOriginAttr)
 {
   // Early exit if the img is already present in the img-cache
   // which indicates that the "real" load has already started and
   // that we shouldn't preload it.
   int16_t blockingStatus;
   if (nsContentUtils::IsImageInCache(uri, static_cast<nsIDocument *>(this)) ||
       !nsContentUtils::CanLoadImage(uri, static_cast<nsIDocument *>(this),
                                     this, NodePrincipal(), &blockingStatus)) {
     return;
   }
   nsLoadFlags loadFlags = nsIRequest::LOAD_NORMAL;
   switch (Element::StringToCORSMode(aCrossOriginAttr)) {
   case CORS_NONE:
     // Nothing to do
     break;
   case CORS_ANONYMOUS:
     loadFlags |= imgILoader::LOAD_CORS_ANONYMOUS;
     break;
   case CORS_USE_CREDENTIALS:
     loadFlags |= imgILoader::LOAD_CORS_USE_CREDENTIALS;
     break;
   default:
     MOZ_CRASH("Unknown CORS mode!");
   }
   // Image not in cache - trigger preload
   nsRefPtr<imgRequestProxy> request;
   nsresult rv =
     nsContentUtils::LoadImage(uri,
                               this,
                               NodePrincipal(),
                               mDocumentURI, // uri of document used as referrer
                               nullptr,       // no observer
                               loadFlags,
                               NS_LITERAL_STRING("img"),
                               getter_AddRefs(request));
   // Pin image-reference to avoid evicting it from the img-cache before
   // the "real" load occurs. Unpinned in DispatchContentLoadedEvents and
   // unlink
   if (NS_SUCCEEDED(rv)) {
     mPreloadingImages.AppendObject(request);
   }
 }
 EventStates
 nsDocument::GetDocumentState()
 {
   if (!mGotDocumentState.HasState(NS_DOCUMENT_STATE_RTL_LOCALE)) {
     if (IsDocumentRightToLeft()) {
       mDocumentState |= NS_DOCUMENT_STATE_RTL_LOCALE;
     }
     mGotDocumentState |= NS_DOCUMENT_STATE_RTL_LOCALE;
   }
   if (!mGotDocumentState.HasState(NS_DOCUMENT_STATE_WINDOW_INACTIVE)) {
     nsIPresShell* shell = GetShell();
     if (shell && shell->GetPresContext() &&
         shell->GetPresContext()->IsTopLevelWindowInactive()) {
       mDocumentState |= NS_DOCUMENT_STATE_WINDOW_INACTIVE;
     }
     mGotDocumentState |= NS_DOCUMENT_STATE_WINDOW_INACTIVE;
   }
   return mDocumentState;
 }
 namespace {
 /**
  * Stub for LoadSheet(), since all we want is to get the sheet into
  * the CSSLoader's style cache
  */
 class StubCSSLoaderObserver MOZ_FINAL : public nsICSSLoaderObserver {
 public:
   NS_IMETHOD
   StyleSheetLoaded(nsCSSStyleSheet*, bool, nsresult)
   {
     return NS_OK;
   }
   NS_DECL_ISUPPORTS
 };
 NS_IMPL_ISUPPORTS(StubCSSLoaderObserver, nsICSSLoaderObserver)
 }
 void
 nsDocument::PreloadStyle(nsIURI* uri, const nsAString& charset,
                          const nsAString& aCrossOriginAttr)
 {
   // The CSSLoader will retain this object after we return.
   nsCOMPtr<nsICSSLoaderObserver> obs = new StubCSSLoaderObserver();
   // Charset names are always ASCII.
   CSSLoader()->LoadSheet(uri, NodePrincipal(),
                          NS_LossyConvertUTF16toASCII(charset),
                          obs,
                          Element::StringToCORSMode(aCrossOriginAttr));
 }
 nsresult
 nsDocument::LoadChromeSheetSync(nsIURI* uri, bool isAgentSheet,
                                 nsCSSStyleSheet** sheet)
 {
   return CSSLoader()->LoadSheetSync(uri, isAgentSheet, isAgentSheet, sheet);
 }
 class nsDelayedEventDispatcher : public nsRunnable
 {
 public:
   nsDelayedEventDispatcher(nsTArray<nsCOMPtr<nsIDocument> >& aDocuments)
   {
     mDocuments.SwapElements(aDocuments);
   }
   virtual ~nsDelayedEventDispatcher() {}
   NS_IMETHOD Run()
   {
     FireOrClearDelayedEvents(mDocuments, true);
     return NS_OK;
   }
 private:
   nsTArray<nsCOMPtr<nsIDocument> > mDocuments;
 };
 namespace {
 struct UnsuppressArgs
 {
   UnsuppressArgs(nsIDocument::SuppressionType aWhat)
     : mWhat(aWhat)
   {
   }
   nsIDocument::SuppressionType mWhat;
   nsTArray<nsCOMPtr<nsIDocument>> mDocs;
 };
 }
 static bool
 GetAndUnsuppressSubDocuments(nsIDocument* aDocument,
                              void* aData)
 {
   UnsuppressArgs* args = static_cast<UnsuppressArgs*>(aData);
   if (args->mWhat != nsIDocument::eAnimationsOnly &&
       aDocument->EventHandlingSuppressed() > 0) {
     static_cast<nsDocument*>(aDocument)->DecreaseEventSuppression();
   } else if (args->mWhat == nsIDocument::eAnimationsOnly &&
              aDocument->AnimationsPaused()) {
     static_cast<nsDocument*>(aDocument)->ResumeAnimations();
   }
   if (args->mWhat != nsIDocument::eAnimationsOnly) {
     // No need to remember documents if we only care about animation frames.
     args->mDocs.AppendElement(aDocument);
   }
   aDocument->EnumerateSubDocuments(GetAndUnsuppressSubDocuments, aData);
   return true;
 }
 void
 nsDocument::UnsuppressEventHandlingAndFireEvents(nsIDocument::SuppressionType aWhat,
                                                  bool aFireEvents)
 {
   UnsuppressArgs args(aWhat);
   GetAndUnsuppressSubDocuments(this, &args);
   if (aWhat == nsIDocument::eAnimationsOnly) {
     // No need to fire events if we only care about animations here.
     return;
   }
   if (aFireEvents) {
     NS_DispatchToCurrentThread(new nsDelayedEventDispatcher(args.mDocs));
   } else {
     FireOrClearDelayedEvents(args.mDocs, false);
   }
 }
 nsISupports*
 nsDocument::GetCurrentContentSink()
 {
   return mParser ? mParser->GetContentSink() : nullptr;
 }
 nsIDocument*
 nsDocument::GetTemplateContentsOwner()
 {
   if (!mTemplateContentsOwner) {
     bool hasHadScriptObject = true;
     nsIScriptGlobalObject* scriptObject =
       GetScriptHandlingObject(hasHadScriptObject);
     NS_ENSURE_TRUE(scriptObject || !hasHadScriptObject, nullptr);
     nsCOMPtr<nsIDOMDocument> domDocument;
     nsresult rv = NS_NewDOMDocument(getter_AddRefs(domDocument),
                                     EmptyString(), // aNamespaceURI
                                     EmptyString(), // aQualifiedName
                                     nullptr, // aDoctype
                                     nsIDocument::GetDocumentURI(),
                                     nsIDocument::GetDocBaseURI(),
                                     NodePrincipal(),
                                     true, // aLoadedAsData
                                     scriptObject, // aEventObject
                                     DocumentFlavorHTML);
     NS_ENSURE_SUCCESS(rv, nullptr);
     mTemplateContentsOwner = do_QueryInterface(domDocument);
     NS_ENSURE_TRUE(mTemplateContentsOwner, nullptr);
     mTemplateContentsOwner->SetScriptHandlingObject(scriptObject);
     // Set |doc| as the template contents owner of itself so that
     // |doc| is the template contents owner of template elements created
     // by |doc|.
     nsDocument* doc = static_cast<nsDocument*>(mTemplateContentsOwner.get());
     doc->mTemplateContentsOwner = doc;
   }
   return mTemplateContentsOwner;
 }
 void
 nsDocument::RegisterHostObjectUri(const nsACString& aUri)
 {
   mHostObjectURIs.AppendElement(aUri);
 }
 void
 nsDocument::UnregisterHostObjectUri(const nsACString& aUri)
 {
   mHostObjectURIs.RemoveElement(aUri);
 }
 void
 nsDocument::SetScrollToRef(nsIURI *aDocumentURI)
 {
   if (!aDocumentURI) {
     return;
   }
   nsAutoCString ref;
   // Since all URI's that pass through here aren't URL's we can't
   // rely on the nsIURI implementation for providing a way for
   // finding the 'ref' part of the URI, we'll haveto revert to
   // string routines for finding the data past '#'
   aDocumentURI->GetSpec(ref);
   nsReadingIterator<char> start, end;
   ref.BeginReading(start);
   ref.EndReading(end);
   if (FindCharInReadable('#', start, end)) {
     ++start; // Skip over the '#'
     mScrollToRef = Substring(start, end);
   }
 }
 void
 nsDocument::ScrollToRef()
 {
   if (mScrolledToRefAlready) {
     nsCOMPtr<nsIPresShell> shell = GetShell();
     if (shell) {
       shell->ScrollToAnchor();
     }
     return;
   }
   if (mScrollToRef.IsEmpty()) {
     return;
   }
   char* tmpstr = ToNewCString(mScrollToRef);
   if (!tmpstr) {
     return;
   }
   nsUnescape(tmpstr);
   nsAutoCString unescapedRef;
   unescapedRef.Assign(tmpstr);
   nsMemory::Free(tmpstr);
   nsresult rv = NS_ERROR_FAILURE;
   // We assume that the bytes are in UTF-8, as it says in the spec:
   // http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
   NS_ConvertUTF8toUTF16 ref(unescapedRef);
   nsCOMPtr<nsIPresShell> shell = GetShell();
   if (shell) {
     // Check an empty string which might be caused by the UTF-8 conversion
     if (!ref.IsEmpty()) {
       // Note that GoToAnchor will handle flushing layout as needed.
       rv = shell->GoToAnchor(ref, mChangeScrollPosWhenScrollingToRef);
     } else {
       rv = NS_ERROR_FAILURE;
     }
     // If UTF-8 URI failed then try to assume the string as a
     // document's charset.
     if (NS_FAILED(rv)) {
       const nsACString &docCharset = GetDocumentCharacterSet();
       rv = nsContentUtils::ConvertStringFromEncoding(docCharset,
                                                      unescapedRef,
                                                      ref);
       if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
         rv = shell->GoToAnchor(ref, mChangeScrollPosWhenScrollingToRef);
       }
     }
     if (NS_SUCCEEDED(rv)) {
       mScrolledToRefAlready = true;
     }
   }
 }
 void
 nsDocument::ResetScrolledToRefAlready()
 {
   mScrolledToRefAlready = false;
 }
 void
 nsDocument::SetChangeScrollPosWhenScrollingToRef(bool aValue)
 {
   mChangeScrollPosWhenScrollingToRef = aValue;
 }
 void
 nsIDocument::RegisterFreezableElement(nsIContent* aContent)
 {
   if (!mFreezableElements) {
     mFreezableElements = new nsTHashtable<nsPtrHashKey<nsIContent> >();
     if (!mFreezableElements)
       return;
   }
   mFreezableElements->PutEntry(aContent);
 }
 bool
 nsIDocument::UnregisterFreezableElement(nsIContent* aContent)
 {
   if (!mFreezableElements)
     return false;
   if (!mFreezableElements->GetEntry(aContent))
     return false;
   mFreezableElements->RemoveEntry(aContent);
   return true;
 }
 struct EnumerateFreezablesData {
   nsIDocument::FreezableElementEnumerator mEnumerator;
   void* mData;
 };
 static PLDHashOperator
 EnumerateFreezables(nsPtrHashKey<nsIContent>* aEntry, void* aData)
 {
   EnumerateFreezablesData* data = static_cast<EnumerateFreezablesData*>(aData);
   data->mEnumerator(aEntry->GetKey(), data->mData);
   return PL_DHASH_NEXT;
 }
 void
 nsIDocument::EnumerateFreezableElements(FreezableElementEnumerator aEnumerator,
                                         void* aData)
 {
   if (!mFreezableElements)
     return;
   EnumerateFreezablesData data = { aEnumerator, aData };
   mFreezableElements->EnumerateEntries(EnumerateFreezables, &data);
 }
 void
 nsIDocument::RegisterPendingLinkUpdate(Link* aLink)
 {
   MOZ_ASSERT(!mIsLinkUpdateRegistrationsForbidden);
   mLinksToUpdate.PutEntry(aLink);
   mHasLinksToUpdate = true;
 }
 void
 nsIDocument::UnregisterPendingLinkUpdate(Link* aLink)
 {
   MOZ_ASSERT(!mIsLinkUpdateRegistrationsForbidden);
   if (!mHasLinksToUpdate)
     return;
   mLinksToUpdate.RemoveEntry(aLink);
 }
 static PLDHashOperator
 EnumeratePendingLinkUpdates(nsPtrHashKey<Link>* aEntry, void* aData)
 {
   aEntry->GetKey()->GetElement()->UpdateLinkState(aEntry->GetKey()->LinkState());
   return PL_DHASH_NEXT;
 }
 void
 nsIDocument::FlushPendingLinkUpdates()
 {
   MOZ_ASSERT(!mIsLinkUpdateRegistrationsForbidden);
   if (!mHasLinksToUpdate)
     return;
 #ifdef DEBUG
   AutoRestore<bool> saved(mIsLinkUpdateRegistrationsForbidden);
   mIsLinkUpdateRegistrationsForbidden = true;
 #endif
   mLinksToUpdate.EnumerateEntries(EnumeratePendingLinkUpdates, nullptr);
   mLinksToUpdate.Clear();
   mHasLinksToUpdate = false;
 }
 already_AddRefed<nsIDocument>
 nsIDocument::CreateStaticClone(nsIDocShell* aCloneContainer)
 {
   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(this);
   NS_ENSURE_TRUE(domDoc, nullptr);
   mCreatingStaticClone = true;
   // Make document use different container during cloning.
   nsRefPtr<nsDocShell> originalShell = mDocumentContainer.get();
   SetContainer(static_cast<nsDocShell*>(aCloneContainer));
   nsCOMPtr<nsIDOMNode> clonedNode;
   nsresult rv = domDoc->CloneNode(true, 1, getter_AddRefs(clonedNode));
   SetContainer(originalShell);
   nsCOMPtr<nsIDocument> clonedDoc;
   if (NS_SUCCEEDED(rv)) {
     clonedDoc = do_QueryInterface(clonedNode);
     if (clonedDoc) {
       if (IsStaticDocument()) {
         clonedDoc->mOriginalDocument = mOriginalDocument;
       } else {
         clonedDoc->mOriginalDocument = this;
       }
       int32_t sheetsCount = GetNumberOfStyleSheets();
       for (int32_t i = 0; i < sheetsCount; ++i) {
         nsRefPtr<nsCSSStyleSheet> sheet = do_QueryObject(GetStyleSheetAt(i));
         if (sheet) {
           if (sheet->IsApplicable()) {
             nsRefPtr<nsCSSStyleSheet> clonedSheet =
               sheet->Clone(nullptr, nullptr, clonedDoc, nullptr);
             NS_WARN_IF_FALSE(clonedSheet, "Cloning a stylesheet didn't work!");
             if (clonedSheet) {
               clonedDoc->AddStyleSheet(clonedSheet);
             }
           }
         }
       }
       sheetsCount = GetNumberOfCatalogStyleSheets();
       for (int32_t i = 0; i < sheetsCount; ++i) {
         nsRefPtr<nsCSSStyleSheet> sheet =
           do_QueryObject(GetCatalogStyleSheetAt(i));
         if (sheet) {
           if (sheet->IsApplicable()) {
             nsRefPtr<nsCSSStyleSheet> clonedSheet =
               sheet->Clone(nullptr, nullptr, clonedDoc, nullptr);
             NS_WARN_IF_FALSE(clonedSheet, "Cloning a stylesheet didn't work!");
             if (clonedSheet) {
               clonedDoc->AddCatalogStyleSheet(clonedSheet);
             }
           }
         }
       }
     }
   }
   mCreatingStaticClone = false;
   return clonedDoc.forget();
 }
 nsresult
 nsIDocument::ScheduleFrameRequestCallback(const FrameRequestCallbackHolder& aCallback,
                                           int32_t *aHandle)
 {
   if (mFrameRequestCallbackCounter == INT32_MAX) {
     // Can't increment without overflowing; bail out
     return NS_ERROR_NOT_AVAILABLE;
   }
   int32_t newHandle = ++mFrameRequestCallbackCounter;
   bool alreadyRegistered = !mFrameRequestCallbacks.IsEmpty();
   DebugOnly<FrameRequest*> request =
     mFrameRequestCallbacks.AppendElement(FrameRequest(aCallback, newHandle));
   NS_ASSERTION(request, "This is supposed to be infallible!");
   if (!alreadyRegistered && mPresShell && IsEventHandlingEnabled()) {
     mPresShell->GetPresContext()->RefreshDriver()->
       ScheduleFrameRequestCallbacks(this);
   }
   *aHandle = newHandle;
   return NS_OK;
 }
 void
 nsIDocument::CancelFrameRequestCallback(int32_t aHandle)
 {
   // mFrameRequestCallbacks is stored sorted by handle
   if (mFrameRequestCallbacks.RemoveElementSorted(aHandle) &&
       mFrameRequestCallbacks.IsEmpty() &&
       mPresShell && IsEventHandlingEnabled()) {
     mPresShell->GetPresContext()->RefreshDriver()->
       RevokeFrameRequestCallbacks(this);
   }
 }
 nsresult
 nsDocument::GetStateObject(nsIVariant** aState)
 {
   // Get the document's current state object. This is the object backing both
   // history.state and popStateEvent.state.
   //
   // mStateObjectContainer may be null; this just means that there's no
   // current state object.
   nsCOMPtr<nsIVariant> stateObj;
   if (!mStateObjectCached && mStateObjectContainer) {
     AutoJSContext cx;
     nsIGlobalObject* sgo = GetScopeObject();
     NS_ENSURE_TRUE(sgo, NS_ERROR_UNEXPECTED);
     JS::Rooted<JSObject*> global(cx, sgo->GetGlobalJSObject());
     NS_ENSURE_TRUE(global, NS_ERROR_UNEXPECTED);
     JSAutoCompartment ac(cx, global);
     mStateObjectContainer->
       DeserializeToVariant(cx, getter_AddRefs(mStateObjectCached));
   }
   NS_IF_ADDREF(*aState = mStateObjectCached);
   return NS_OK;
 }
 nsDOMNavigationTiming*
 nsDocument::GetNavigationTiming() const
 {
   return mTiming;
 }
 nsresult
 nsDocument::SetNavigationTiming(nsDOMNavigationTiming* aTiming)
 {
   mTiming = aTiming;
   if (!mLoadingTimeStamp.IsNull() && mTiming) {
     mTiming->SetDOMLoadingTimeStamp(nsIDocument::GetDocumentURI(), mLoadingTimeStamp);
   }
   return NS_OK;
 }
 Element*
 nsDocument::FindImageMap(const nsAString& aUseMapValue)
 {
   if (aUseMapValue.IsEmpty()) {
     return nullptr;
   }
   nsAString::const_iterator start, end;
   aUseMapValue.BeginReading(start);
   aUseMapValue.EndReading(end);
   int32_t hash = aUseMapValue.FindChar('#');
   if (hash < 0) {
     return nullptr;
   }
   // aUsemap contains a '#', set start to point right after the '#'
   start.advance(hash + 1);
   if (start == end) {
     return nullptr; // aUsemap == "#"
   }
   const nsAString& mapName = Substring(start, end);
   if (!mImageMaps) {
     mImageMaps = new nsContentList(this, kNameSpaceID_XHTML, nsGkAtoms::map, nsGkAtoms::map);
   }
   uint32_t i, n = mImageMaps->Length(true);
   nsString name;
   for (i = 0; i < n; ++i) {
     nsIContent* map = mImageMaps->Item(i);
     if (map->AttrValueIs(kNameSpaceID_None, nsGkAtoms::id, mapName,
                          eCaseMatters) ||
         (map->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name) &&
          mapName.Equals(name, nsCaseInsensitiveStringComparator()))) {
       return map->AsElement();
     }
   }
   return nullptr;
 }
 #define DEPRECATED_OPERATION(_op) #_op "Warning",
 static const char* kWarnings[] = {
 #include "nsDeprecatedOperationList.h"
   nullptr
 };
 #undef DEPRECATED_OPERATION
 void
 nsIDocument::WarnOnceAbout(DeprecatedOperations aOperation,
                            bool asError /* = false */)
 {
   static_assert(eDeprecatedOperationCount <= 64,
                 "Too many deprecated operations");
   if (mWarnedAbout & (1ull << aOperation)) {
     return;
   }
   mWarnedAbout |= (1ull << aOperation);
   uint32_t flags = asError ? nsIScriptError::errorFlag
                            : nsIScriptError::warningFlag;
   nsContentUtils::ReportToConsole(flags,
                                   NS_LITERAL_CSTRING("DOM Core"), this,
                                   nsContentUtils::eDOM_PROPERTIES,
                                   kWarnings[aOperation]);
 }
 nsresult
 nsDocument::AddImage(imgIRequest* aImage)
 {
   NS_ENSURE_ARG_POINTER(aImage);
   // See if the image is already in the hashtable. If it is, get the old count.
   uint32_t oldCount = 0;
   mImageTracker.Get(aImage, &oldCount);
   // Put the image in the hashtable, with the proper count.
   mImageTracker.Put(aImage, oldCount + 1);
   nsresult rv = NS_OK;
   // If this is the first insertion and we're locking images, lock this image
   // too.
   if (oldCount == 0) {
     if (mLockingImages)
       rv = aImage->LockImage();
     if (NS_SUCCEEDED(rv) && (!sOnloadDecodeLimit ||
                              mImageTracker.Count() < sOnloadDecodeLimit))
       rv = aImage->StartDecoding();
   }
   // If this is the first insertion and we're animating images, request
   // that this image be animated too.
   if (oldCount == 0 && mAnimatingImages) {
     nsresult rv2 = aImage->IncrementAnimationConsumers();
     rv = NS_SUCCEEDED(rv) ? rv2 : rv;
   }
   return rv;
 }
 nsresult
 nsDocument::RemoveImage(imgIRequest* aImage, uint32_t aFlags)
 {
   NS_ENSURE_ARG_POINTER(aImage);
   // Get the old count. It should exist and be > 0.
   uint32_t count = 0;
   DebugOnly<bool> found = mImageTracker.Get(aImage, &count);
   NS_ABORT_IF_FALSE(found, "Removing image that wasn't in the tracker!");
   NS_ABORT_IF_FALSE(count > 0, "Entry in the cache tracker with count 0!");
   // We're removing, so decrement the count.
   count--;
   // If the count is now zero, remove from the tracker.
   // Otherwise, set the new value.
   if (count != 0) {
     mImageTracker.Put(aImage, count);
     return NS_OK;
   }
   mImageTracker.Remove(aImage);
   nsresult rv = NS_OK;
   // Now that we're no longer tracking this image, unlock it if we'd
   // previously locked it.
   if (mLockingImages) {
     rv = aImage->UnlockImage();
   }
   // If we're animating images, remove our request to animate this one.
   if (mAnimatingImages) {
     nsresult rv2 = aImage->DecrementAnimationConsumers();
     rv = NS_SUCCEEDED(rv) ? rv2 : rv;
   }
   if (aFlags & REQUEST_DISCARD) {
     // Request that the image be discarded if nobody else holds a lock on it.
     // Do this even if !mLockingImages, because even if we didn't just unlock
     // this image, it might still be a candidate for discarding.
     aImage->RequestDiscard();
   }
   return rv;
 }
 nsresult
 nsDocument::AddPlugin(nsIObjectLoadingContent* aPlugin)
 {
   MOZ_ASSERT(aPlugin);
   if (!mPlugins.PutEntry(aPlugin)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   return NS_OK;
 }
 void
 nsDocument::RemovePlugin(nsIObjectLoadingContent* aPlugin)
 {
   MOZ_ASSERT(aPlugin);
   mPlugins.RemoveEntry(aPlugin);
 }
 static bool
 AllSubDocumentPluginEnum(nsIDocument* aDocument, void* userArg)
 {
   nsTArray<nsIObjectLoadingContent*>* plugins =
     reinterpret_cast< nsTArray<nsIObjectLoadingContent*>* >(userArg);
   MOZ_ASSERT(plugins);
   aDocument->GetPlugins(*plugins);
   return true;
 }
 static PLDHashOperator
 AllPluginEnum(nsPtrHashKey<nsIObjectLoadingContent>* aPlugin, void* userArg)
 {
   nsTArray<nsIObjectLoadingContent*>* allPlugins =
     reinterpret_cast< nsTArray<nsIObjectLoadingContent*>* >(userArg);
   MOZ_ASSERT(allPlugins);
   allPlugins->AppendElement(aPlugin->GetKey());
   return PL_DHASH_NEXT;
 }
 void
 nsDocument::GetPlugins(nsTArray<nsIObjectLoadingContent*>& aPlugins)
 {
   aPlugins.SetCapacity(aPlugins.Length() + mPlugins.Count());
   mPlugins.EnumerateEntries(AllPluginEnum, &aPlugins);
   EnumerateSubDocuments(AllSubDocumentPluginEnum, &aPlugins);
 }
 PLDHashOperator LockEnumerator(imgIRequest* aKey,
                                uint32_t aData,
                                void*    userArg)
 {
   aKey->LockImage();
   aKey->RequestDecode();
   return PL_DHASH_NEXT;
 }
 PLDHashOperator UnlockEnumerator(imgIRequest* aKey,
                                  uint32_t aData,
                                  void*    userArg)
 {
   aKey->UnlockImage();
   return PL_DHASH_NEXT;
 }
 nsresult
 nsDocument::SetImageLockingState(bool aLocked)
 {
   if (XRE_GetProcessType() == GeckoProcessType_Content &&
       !Preferences::GetBool("image.mem.allow_locking_in_content_processes", true)) {
     return NS_OK;
   }
   // If there's no change, there's nothing to do.
   if (mLockingImages == aLocked)
     return NS_OK;
   // Otherwise, iterate over our images and perform the appropriate action.
   mImageTracker.EnumerateRead(aLocked ? LockEnumerator
                                       : UnlockEnumerator,
                               nullptr);
   // Update state.
   mLockingImages = aLocked;
   return NS_OK;
 }
 PLDHashOperator IncrementAnimationEnumerator(imgIRequest* aKey,
                                              uint32_t aData,
                                              void*    userArg)
 {
   aKey->IncrementAnimationConsumers();
   return PL_DHASH_NEXT;
 }
 PLDHashOperator DecrementAnimationEnumerator(imgIRequest* aKey,
                                              uint32_t aData,
                                              void*    userArg)
 {
   aKey->DecrementAnimationConsumers();
   return PL_DHASH_NEXT;
 }
 void
 nsDocument::SetImagesNeedAnimating(bool aAnimating)
 {
   // If there's no change, there's nothing to do.
   if (mAnimatingImages == aAnimating)
     return;
   // Otherwise, iterate over our images and perform the appropriate action.
   mImageTracker.EnumerateRead(aAnimating ? IncrementAnimationEnumerator
                                          : DecrementAnimationEnumerator,
                               nullptr);
   // Update state.
   mAnimatingImages = aAnimating;
 }
 already_AddRefed<Touch>
 nsIDocument::CreateTouch(nsIDOMWindow* aView,
                          EventTarget* aTarget,
                          int32_t aIdentifier,
                          int32_t aPageX, int32_t aPageY,
                          int32_t aScreenX, int32_t aScreenY,
                          int32_t aClientX, int32_t aClientY,
                          int32_t aRadiusX, int32_t aRadiusY,
                          float aRotationAngle,
                          float aForce)
 {
   nsRefPtr<Touch> touch = new Touch(aTarget,
                                     aIdentifier,
                                     aPageX, aPageY,
                                     aScreenX, aScreenY,
                                     aClientX, aClientY,
                                     aRadiusX, aRadiusY,
                                     aRotationAngle,
                                     aForce);
   return touch.forget();
 }
 already_AddRefed<TouchList>
 nsIDocument::CreateTouchList()
 {
   nsRefPtr<TouchList> retval = new TouchList(ToSupports(this));
   return retval.forget();
 }
 already_AddRefed<TouchList>
 nsIDocument::CreateTouchList(Touch& aTouch,
                              const Sequence<OwningNonNull<Touch> >& aTouches)
 {
   nsRefPtr<TouchList> retval = new TouchList(ToSupports(this));
   retval->Append(&aTouch);
   for (uint32_t i = 0; i < aTouches.Length(); ++i) {
     retval->Append(aTouches[i].get());
   }
   return retval.forget();
 }
 already_AddRefed<TouchList>
 nsIDocument::CreateTouchList(const Sequence<OwningNonNull<Touch> >& aTouches)
 {
   nsRefPtr<TouchList> retval = new TouchList(ToSupports(this));
   for (uint32_t i = 0; i < aTouches.Length(); ++i) {
     retval->Append(aTouches[i].get());
   }
   return retval.forget();
 }
 already_AddRefed<nsDOMCaretPosition>
 nsIDocument::CaretPositionFromPoint(float aX, float aY)
 {
   nscoord x = nsPresContext::CSSPixelsToAppUnits(aX);
   nscoord y = nsPresContext::CSSPixelsToAppUnits(aY);
   nsPoint pt(x, y);
   FlushPendingNotifications(Flush_Layout);
   nsIPresShell *ps = GetShell();
   if (!ps) {
     return nullptr;
   }
   nsIFrame *rootFrame = ps->GetRootFrame();
   // XUL docs, unlike HTML, have no frame tree until everything's done loading
   if (!rootFrame) {
     return nullptr;
   }
   nsIFrame *ptFrame = nsLayoutUtils::GetFrameForPoint(rootFrame, pt,
       nsLayoutUtils::IGNORE_PAINT_SUPPRESSION | nsLayoutUtils::IGNORE_CROSS_DOC);
   if (!ptFrame) {
     return nullptr;
   }
   // GetContentOffsetsFromPoint requires frame-relative coordinates, so we need
   // to adjust to frame-relative coordinates before we can perform this call.
   // It should also not take into account the padding of the frame.
   nsPoint adjustedPoint = pt - ptFrame->GetOffsetTo(rootFrame);
   nsFrame::ContentOffsets offsets =
     ptFrame->GetContentOffsetsFromPoint(adjustedPoint);
   nsCOMPtr<nsIContent> node = offsets.content;
   uint32_t offset = offsets.offset;
   nsCOMPtr<nsIContent> anonNode = node;
   bool nodeIsAnonymous = node && node->IsInNativeAnonymousSubtree();
   if (nodeIsAnonymous) {
     node = ptFrame->GetContent();
     nsIContent* nonanon = node->FindFirstNonChromeOnlyAccessContent();
     nsCOMPtr<nsIDOMHTMLInputElement> input = do_QueryInterface(nonanon);
     nsCOMPtr<nsIDOMHTMLTextAreaElement> textArea = do_QueryInterface(nonanon);
     bool isText;
     if (textArea || (input &&
                      NS_SUCCEEDED(input->MozIsTextField(false, &isText)) &&
                      isText)) {
       // If the anonymous content node has a child, then we need to make sure
       // that we get the appropriate child, as otherwise the offset may not be
       // correct when we construct a range for it.
       nsCOMPtr<nsIContent> firstChild = anonNode->GetFirstChild();
       if (firstChild) {
         anonNode = firstChild;
       }
       if (textArea) {
         offset = nsContentUtils::GetAdjustedOffsetInTextControl(ptFrame, offset);
       }
       node = nonanon;
     } else {
       node = nullptr;
       offset = 0;
     }
   }
   nsRefPtr<nsDOMCaretPosition> aCaretPos = new nsDOMCaretPosition(node, offset);
   if (nodeIsAnonymous) {
     aCaretPos->SetAnonymousContentNode(anonNode);
   }
   return aCaretPos.forget();
 }
 NS_IMETHODIMP
 nsDocument::CaretPositionFromPoint(float aX, float aY, nsISupports** aCaretPos)
 {
   NS_ENSURE_ARG_POINTER(aCaretPos);
   *aCaretPos = nsIDocument::CaretPositionFromPoint(aX, aY).take();
   return NS_OK;
 }
 void
 nsIDocument::ObsoleteSheet(nsIURI *aSheetURI, ErrorResult& rv)
 {
   nsresult res = CSSLoader()->ObsoleteSheet(aSheetURI);
   if (NS_FAILED(res)) {
     rv.Throw(res);
   }
 }
 void
 nsIDocument::ObsoleteSheet(const nsAString& aSheetURI, ErrorResult& rv)
 {
   nsCOMPtr<nsIURI> uri;
   nsresult res = NS_NewURI(getter_AddRefs(uri), aSheetURI);
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return;
   }
   res = CSSLoader()->ObsoleteSheet(uri);
   if (NS_FAILED(res)) {
     rv.Throw(res);
   }
 }
 nsIHTMLCollection*
 nsIDocument::Children()
 {
   if (!mChildrenCollection) {
     mChildrenCollection = new nsContentList(this, kNameSpaceID_Wildcard,
                                             nsGkAtoms::_asterix,
                                             nsGkAtoms::_asterix,
                                             false);
   }
   return mChildrenCollection;
 }
 uint32_t
 nsIDocument::ChildElementCount()
 {
   return Children()->Length();
 }
 namespace mozilla {
 // Singleton class to manage the list of fullscreen documents which are the
 // root of a branch which contains fullscreen documents. We maintain this list
 // so that we can easily exit all windows from fullscreen when the user
 // presses the escape key.
 class FullscreenRoots {
 public:
   // Adds a root to the manager. Adding a root multiple times does not result
   // in duplicate entries for that item, only one.
   static void Add(nsIDocument* aRoot);
   // Iterates over every root in the root list, and calls aFunction, passing
   // each root once to aFunction. It is safe to call Add() and Remove() while
   // iterating over the list (i.e. in aFunction). Documents that are removed
   // from the manager during traversal are not traversed, and documents that
   // are added to the manager during traversal are also not traversed.
   static void ForEach(void(*aFunction)(nsIDocument* aDoc));
   // Removes a specific root from the manager.
   static void Remove(nsIDocument* aRoot);
   // Returns true if all roots added to the list have been removed.
   static bool IsEmpty();
 private:
   FullscreenRoots() {
     MOZ_COUNT_CTOR(FullscreenRoots);
   }
   ~FullscreenRoots() {
     MOZ_COUNT_DTOR(FullscreenRoots);
   }
   enum {
     NotFound = uint32_t(-1)
   };
   // Looks in mRoots for aRoot. Returns the index if found, otherwise NotFound.
   static uint32_t Find(nsIDocument* aRoot);
   // Returns true if aRoot is in the list of fullscreen roots.
   static bool Contains(nsIDocument* aRoot);
   // Singleton instance of the FullscreenRoots. This is instantiated when a
   // root is added, and it is deleted when the last root is removed.
   static FullscreenRoots* sInstance;
   // List of weak pointers to roots.
   nsTArray<nsWeakPtr> mRoots;
 };
 FullscreenRoots* FullscreenRoots::sInstance = nullptr;
 /* static */
 void
 FullscreenRoots::ForEach(void(*aFunction)(nsIDocument* aDoc))
 {
   if (!sInstance) {
     return;
   }
   // Create a copy of the roots array, and iterate over the copy. This is so
   // that if an element is removed from mRoots we don't mess up our iteration.
   nsTArray<nsWeakPtr> roots(sInstance->mRoots);
   // Call aFunction on all entries.
   for (uint32_t i = 0; i < roots.Length(); i++) {
     nsCOMPtr<nsIDocument> root = do_QueryReferent(roots[i]);
     // Check that the root isn't in the manager. This is so that new additions
     // while we were running don't get traversed.
     if (root && FullscreenRoots::Contains(root)) {
       aFunction(root);
     }
   }
 }
 /* static */
 bool
 FullscreenRoots::Contains(nsIDocument* aRoot)
 {
   return FullscreenRoots::Find(aRoot) != NotFound;
 }
 /* static */
 void
 FullscreenRoots::Add(nsIDocument* aRoot)
 {
   if (!FullscreenRoots::Contains(aRoot)) {
     if (!sInstance) {
       sInstance = new FullscreenRoots();
     }
     nsWeakPtr weakRoot = do_GetWeakReference(aRoot);
     sInstance->mRoots.AppendElement(weakRoot);
   }
 }
 /* static */
 uint32_t
 FullscreenRoots::Find(nsIDocument* aRoot)
 {
   if (!sInstance) {
     return NotFound;
   }
   nsTArray<nsWeakPtr>& roots = sInstance->mRoots;
   for (uint32_t i = 0; i < roots.Length(); i++) {
     nsCOMPtr<nsIDocument> otherRoot(do_QueryReferent(roots[i]));
     if (otherRoot == aRoot) {
       return i;
     }
   }
   return NotFound;
 }
 /* static */
 void
 FullscreenRoots::Remove(nsIDocument* aRoot)
 {
   uint32_t index = Find(aRoot);
   NS_ASSERTION(index != NotFound,
     "Should only try to remove roots which are still added!");
   if (index == NotFound || !sInstance) {
     return;
   }
   sInstance->mRoots.RemoveElementAt(index);
   if (sInstance->mRoots.IsEmpty()) {
     delete sInstance;
     sInstance = nullptr;
   }
 }
 /* static */
 bool
 FullscreenRoots::IsEmpty()
 {
   return !sInstance;
 }
 } // end namespace mozilla.
 using mozilla::FullscreenRoots;
 nsIDocument*
 nsDocument::GetFullscreenRoot()
 {
   nsCOMPtr<nsIDocument> root = do_QueryReferent(mFullscreenRoot);
   return root;
 }
 void
 nsDocument::SetFullscreenRoot(nsIDocument* aRoot)
 {
   mFullscreenRoot = do_GetWeakReference(aRoot);
 }
 NS_IMETHODIMP
 nsDocument::MozCancelFullScreen()
 {
   nsIDocument::MozCancelFullScreen();
   return NS_OK;
 }
 void
 nsIDocument::MozCancelFullScreen()
 {
   RestorePreviousFullScreenState();
 }
 // Runnable to set window full-screen mode. Used as a script runner
 // to ensure we only call nsGlobalWindow::SetFullScreen() when it's safe to
 // run script. nsGlobalWindow::SetFullScreen() dispatches a synchronous event
 // (handled in chome code) which is unsafe to run if this is called in
 // Element::UnbindFromTree().
 class nsSetWindowFullScreen : public nsRunnable {
 public:
   nsSetWindowFullScreen(nsIDocument* aDoc, bool aValue)
     : mDoc(aDoc), mValue(aValue) {}
   NS_IMETHOD Run()
   {
     if (mDoc->GetWindow()) {
       mDoc->GetWindow()->SetFullScreenInternal(mValue, false);
     }
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIDocument> mDoc;
   bool mValue;
 };
 static nsIDocument*
 GetFullscreenRootDocument(nsIDocument* aDoc)
 {
   if (!aDoc) {
     return nullptr;
   }
   nsIDocument* doc = aDoc;
   nsIDocument* parent;
   while ((parent = doc->GetParentDocument()) &&
          (!nsContentUtils::IsFullscreenApiContentOnly() ||
           !nsContentUtils::IsChromeDoc(parent))) {
     doc = parent;
   }
   return doc;
 }
 static void
 SetWindowFullScreen(nsIDocument* aDoc, bool aValue)
 {
   // Maintain list of fullscreen root documents.
   nsCOMPtr<nsIDocument> root = GetFullscreenRootDocument(aDoc);
   if (aValue) {
     FullscreenRoots::Add(root);
   } else {
     FullscreenRoots::Remove(root);
   }
   if (!nsContentUtils::IsFullscreenApiContentOnly()) {
     nsContentUtils::AddScriptRunner(new nsSetWindowFullScreen(aDoc, aValue));
   }
 }
 class nsCallExitFullscreen : public nsRunnable {
 public:
   nsCallExitFullscreen(nsIDocument* aDoc)
     : mDoc(aDoc) {}
   NS_IMETHOD Run()
   {
     nsDocument::ExitFullscreen(mDoc);
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIDocument> mDoc;
 };
 /* static */
 void
 nsIDocument::ExitFullscreen(nsIDocument* aDoc, bool aRunAsync)
 {
   if (aDoc && !aDoc->IsFullScreenDoc()) {
     return;
   }
   if (aRunAsync) {
     NS_DispatchToCurrentThread(new nsCallExitFullscreen(aDoc));
     return;
   }
   nsDocument::ExitFullscreen(aDoc);
 }
 // Returns true if the document is a direct child of a cross process parent
 // mozbrowser iframe. This is the case when the document has a null parent,
 // and its DocShell reports that it is a browser frame.
 static bool
 HasCrossProcessParent(nsIDocument* aDocument)
 {
   if (XRE_GetProcessType() != GeckoProcessType_Content) {
     return false;
   }
   if (aDocument->GetParentDocument() != nullptr) {
     return false;
   }
   nsPIDOMWindow* win = aDocument->GetWindow();
   if (!win) {
     return false;
   }
   nsCOMPtr<nsIDocShell> docShell = win->GetDocShell();
   if (!docShell) {
     return false;
   }
   return docShell->GetIsBrowserOrApp();
 }
 static bool
 CountFullscreenSubDocuments(nsIDocument* aDoc, void* aData)
 {
   if (aDoc->IsFullScreenDoc()) {
     uint32_t* count = static_cast<uint32_t*>(aData);
     (*count)++;
   }
   return true;
 }
 static uint32_t
 CountFullscreenSubDocuments(nsIDocument* aDoc)
 {
   uint32_t count = 0;
   aDoc->EnumerateSubDocuments(CountFullscreenSubDocuments, &count);
   return count;
 }
 bool
 nsDocument::IsFullscreenLeaf()
 {
   // A fullscreen leaf document is fullscreen, and has no fullscreen
   // subdocuments.
   if (!IsFullScreenDoc()) {
     return false;
   }
   return CountFullscreenSubDocuments(this) == 0;
 }
 static bool
 ResetFullScreen(nsIDocument* aDocument, void* aData)
 {
   if (aDocument->IsFullScreenDoc()) {
     NS_ASSERTION(CountFullscreenSubDocuments(aDocument) <= 1,
         "Should have at most 1 fullscreen subdocument.");
     static_cast<nsDocument*>(aDocument)->CleanupFullscreenState();
     NS_ASSERTION(!aDocument->IsFullScreenDoc(), "Should reset full-screen");
     nsTArray<nsIDocument*>* changed = reinterpret_cast<nsTArray<nsIDocument*>*>(aData);
     changed->AppendElement(aDocument);
     if (HasCrossProcessParent(aDocument)) {
       // We're at the top of the content-process side doc tree. Ask the parent
       // process to exit fullscreen.
       nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
       os->NotifyObservers(aDocument, "ask-parent-to-exit-fullscreen", nullptr);
     }
     // Dispatch a notification so that if this document has any
     // cross-process subdocuments, they'll be notified to exit fullscreen.
     // The BrowserElementParent listens for this event and performs the
     // cross process notification if it has a remote child process.
     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
     os->NotifyObservers(aDocument, "ask-children-to-exit-fullscreen", nullptr);
     aDocument->EnumerateSubDocuments(ResetFullScreen, aData);
   }
   return true;
 }
 static void
 ExitFullscreenInDocTree(nsIDocument* aMaybeNotARootDoc)
 {
   MOZ_ASSERT(aMaybeNotARootDoc);
   nsCOMPtr<nsIDocument> root = aMaybeNotARootDoc->GetFullscreenRoot();
   NS_ASSERTION(root, "Should have root when in fullscreen!");
   if (!root) {
     return;
   }
   NS_ASSERTION(root->IsFullScreenDoc(),
     "Fullscreen root should be a fullscreen doc...");
   // Stores a list of documents to which we must dispatch "mozfullscreenchange".
   // We're required by the spec to dispatch the events in leaf-to-root
   // order when exiting fullscreen, but we traverse the doctree in a
   // root-to-leaf order, so we save references to the documents we must
   // dispatch to so that we dispatch in the specified order.
   nsAutoTArray<nsIDocument*, 8> changed;
   // Walk the tree of fullscreen documents, and reset their fullscreen state.
   ResetFullScreen(root, static_cast<void*>(&changed));
   // Dispatch "mozfullscreenchange" events. Note this loop is in reverse
   // order so that the events for the leaf document arrives before the root
   // document, as required by the spec.
   for (uint32_t i = 0; i < changed.Length(); ++i) {
     DispatchFullScreenChange(changed[changed.Length() - i - 1]);
   }
   NS_ASSERTION(!root->IsFullScreenDoc(),
     "Fullscreen root should no longer be a fullscreen doc...");
   // Move the top-level window out of fullscreen mode.
   SetWindowFullScreen(root, false);
 }
 /* static */
 void
 nsDocument::ExitFullscreen(nsIDocument* aDoc)
 {
   // Unlock the pointer, if it's locked.
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (pointerLockedElement) {
     UnlockPointer();
   }
   if (aDoc)  {
     ExitFullscreenInDocTree(aDoc);
     return;
   }
   // Clear fullscreen stacks in all fullscreen roots' descendant documents.
   FullscreenRoots::ForEach(&ExitFullscreenInDocTree);
   NS_ASSERTION(FullscreenRoots::IsEmpty(),
       "Should have exited all fullscreen roots from fullscreen");
 }
 bool
 GetFullscreenLeaf(nsIDocument* aDoc, void* aData)
 {
   if (aDoc->IsFullscreenLeaf()) {
     nsIDocument** result = static_cast<nsIDocument**>(aData);
     *result = aDoc;
     return false;
   } else if (aDoc->IsFullScreenDoc()) {
     aDoc->EnumerateSubDocuments(GetFullscreenLeaf, aData);
   }
   return true;
 }
 static nsIDocument*
 GetFullscreenLeaf(nsIDocument* aDoc)
 {
   nsIDocument* leaf = nullptr;
   GetFullscreenLeaf(aDoc, &leaf);
   if (leaf) {
     return leaf;
   }
   // Otherwise we could be either in a non-fullscreen doc tree, or we're
   // below the fullscreen doc. Start the search from the root.
   nsIDocument* root = GetFullscreenRootDocument(aDoc);
   // Check that the root is actually fullscreen so we don't waste time walking
   // around its descendants.
   if (!root->IsFullScreenDoc()) {
     return nullptr;
   }
   GetFullscreenLeaf(root, &leaf);
   return leaf;
 }
 void
 nsDocument::RestorePreviousFullScreenState()
 {
   NS_ASSERTION(!IsFullScreenDoc() || !FullscreenRoots::IsEmpty(),
     "Should have at least 1 fullscreen root when fullscreen!");
   NS_ASSERTION(!nsContentUtils::IsFullscreenApiContentOnly() ||
                !nsContentUtils::IsChromeDoc(this),
                "Should not run RestorePreviousFullScreenState() on "
                "chrome document when fullscreen is content only");
   if (!IsFullScreenDoc() || !GetWindow() || FullscreenRoots::IsEmpty()) {
     return;
   }
   // If fullscreen mode is updated the pointer should be unlocked
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (pointerLockedElement) {
     UnlockPointer();
   }
   nsCOMPtr<nsIDocument> fullScreenDoc = GetFullscreenLeaf(this);
   // The fullscreen document may contain a <iframe mozbrowser> element which
   // has a cross process child. So send a notification so that its browser
   // parent will send a message to its child process to also exit fullscreen.
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   os->NotifyObservers(fullScreenDoc, "ask-children-to-exit-fullscreen", nullptr);
   // Clear full-screen stacks in all descendant in process documents, bottom up.
   nsIDocument* doc = fullScreenDoc;
   while (doc != this) {
     NS_ASSERTION(doc->IsFullScreenDoc(), "Should be full-screen doc");
     static_cast<nsDocument*>(doc)->CleanupFullscreenState();
     UnlockPointer();
     DispatchFullScreenChange(doc);
     doc = doc->GetParentDocument();
   }
   // Roll-back full-screen state to previous full-screen element.
   NS_ASSERTION(doc == this, "Must have reached this doc.");
   while (doc != nullptr) {
     static_cast<nsDocument*>(doc)->FullScreenStackPop();
     UnlockPointer();
     DispatchFullScreenChange(doc);
     if (static_cast<nsDocument*>(doc)->mFullScreenStack.IsEmpty()) {
       if (HasCrossProcessParent(doc)) {
         // Send notification to the parent process to tell it to rollback to
         // the previous fullscreen elements in its fullscreen element stacks.
         nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
         os->NotifyObservers(doc, "ask-parent-to-rollback-fullscreen", nullptr);
       }
       // Full-screen stack in document is empty. Go back up to the parent
       // document. We'll pop the containing element off its stack, and use
       // its next full-screen element as the full-screen element.
       static_cast<nsDocument*>(doc)->CleanupFullscreenState();
       doc = doc->GetParentDocument();
     } else {
       // Else we popped the top of the stack, and there's still another
       // element in there, so that will become the full-screen element.
       if (fullScreenDoc != doc) {
         // We've popped so enough off the stack that we've rolled back to
         // a fullscreen element in a parent document. If this document isn't
         // approved for fullscreen, or if it's cross origin, dispatch an
         // event to chrome so it knows to show the authorization/warning UI.
         if (!nsContentUtils::HaveEqualPrincipals(fullScreenDoc, doc) ||
             (!nsContentUtils::IsSitePermAllow(doc->NodePrincipal(), "fullscreen") &&
              !static_cast<nsDocument*>(doc)->mIsApprovedForFullscreen)) {
           nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
             new AsyncEventDispatcher(doc,
                   NS_LITERAL_STRING("MozEnteredDomFullscreen"),
                   true,
                   true);
           asyncDispatcher->PostDOMEvent();
         }
       }
       if (!nsContentUtils::HaveEqualPrincipals(doc, fullScreenDoc)) {
         // The origin which is fullscreen changed. Send a notification to
         // the root process so that a warning or approval UI can be shown
         // as necessary.
         nsAutoString origin;
         nsContentUtils::GetUTFOrigin(doc->NodePrincipal(), origin);
         nsIDocument* root = GetFullscreenRootDocument(doc);
         nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
         os->NotifyObservers(root, "fullscreen-origin-change", origin.get());
       }
       break;
     }
   }
   if (doc == nullptr) {
     // We moved all documents in this doctree out of fullscreen mode,
     // move the top-level window out of fullscreen mode.
     NS_ASSERTION(!GetFullscreenRootDocument(this)->IsFullScreenDoc(),
       "Should have cleared all docs' stacks");
     SetWindowFullScreen(this, false);
   }
 }
 bool
 nsDocument::IsFullScreenDoc()
 {
   return GetFullScreenElement() != nullptr;
 }
 class nsCallRequestFullScreen : public nsRunnable
 {
 public:
   nsCallRequestFullScreen(Element* aElement)
     : mElement(aElement),
       mDoc(aElement->OwnerDoc()),
       mWasCallerChrome(nsContentUtils::IsCallerChrome()),
       mHadRequestPending(static_cast<nsDocument*>(mDoc.get())->
                            mAsyncFullscreenPending)
   {
     static_cast<nsDocument*>(mDoc.get())->
       mAsyncFullscreenPending = true;
   }
   NS_IMETHOD Run()
   {
     static_cast<nsDocument*>(mDoc.get())->
       mAsyncFullscreenPending = mHadRequestPending;
     nsDocument* doc = static_cast<nsDocument*>(mDoc.get());
     doc->RequestFullScreen(mElement,
                            mWasCallerChrome,
                            /* aNotifyOnOriginChange */ true);
     return NS_OK;
   }
   nsRefPtr<Element> mElement;
   nsCOMPtr<nsIDocument> mDoc;
   bool mWasCallerChrome;
   bool mHadRequestPending;
 };
 void
 nsDocument::AsyncRequestFullScreen(Element* aElement)
 {
   NS_ASSERTION(aElement,
     "Must pass non-null element to nsDocument::AsyncRequestFullScreen");
   if (!aElement) {
     return;
   }
   // Request full-screen asynchronously.
   nsCOMPtr<nsIRunnable> event(new nsCallRequestFullScreen(aElement));
   NS_DispatchToCurrentThread(event);
 }
 static void
 LogFullScreenDenied(bool aLogFailure, const char* aMessage, nsIDocument* aDoc)
 {
   if (!aLogFailure) {
     return;
   }
   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(aDoc,
                              NS_LITERAL_STRING("mozfullscreenerror"),
                              true,
                              false);
   asyncDispatcher->PostDOMEvent();
   nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
                                   NS_LITERAL_CSTRING("DOM"), aDoc,
                                   nsContentUtils::eDOM_PROPERTIES,
                                   aMessage);
 }
 nsresult
 nsDocument::AddFullscreenApprovedObserver()
 {
   if (mHasFullscreenApprovedObserver ||
       !Preferences::GetBool("full-screen-api.approval-required")) {
     return NS_OK;
   }
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   NS_ENSURE_TRUE(os, NS_ERROR_FAILURE);
   nsresult res = os->AddObserver(this, "fullscreen-approved", true);
   NS_ENSURE_SUCCESS(res, res);
   mHasFullscreenApprovedObserver = true;
   return NS_OK;
 }
 nsresult
 nsDocument::RemoveFullscreenApprovedObserver()
 {
   if (!mHasFullscreenApprovedObserver) {
     return NS_OK;
   }
   nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
   NS_ENSURE_TRUE(os, NS_ERROR_FAILURE);
   nsresult res = os->RemoveObserver(this, "fullscreen-approved");
   NS_ENSURE_SUCCESS(res, res);
   mHasFullscreenApprovedObserver = false;
   return NS_OK;
 }
 void
 nsDocument::CleanupFullscreenState()
 {
   if (!mFullScreenStack.IsEmpty()) {
     // The top element in the full-screen stack will have full-screen
     // style bits set on it and its ancestors. Remove the style bits.
     // Note the non-top elements won't have the style bits set.
     Element* top = FullScreenStackTop();
     NS_ASSERTION(top, "Should have a top when full-screen stack isn't empty");
     if (top) {
       EventStateManager::SetFullScreenState(top, false);
     }
     mFullScreenStack.Clear();
   }
   SetApprovedForFullscreen(false);
   RemoveFullscreenApprovedObserver();
   mFullscreenRoot = nullptr;
 }
 bool
 nsDocument::FullScreenStackPush(Element* aElement)
 {
   NS_ASSERTION(aElement, "Must pass non-null to FullScreenStackPush()");
   Element* top = FullScreenStackTop();
   if (top == aElement || !aElement) {
     return false;
   }
   if (top) {
     // We're pushing a new element onto the full-screen stack, so we must
     // remove the ancestor and full-screen styles from the former top of the
     // stack.
     EventStateManager::SetFullScreenState(top, false);
   }
   EventStateManager::SetFullScreenState(aElement, true);
   nsWeakPtr weakElement = do_GetWeakReference(aElement);
   mFullScreenStack.AppendElement(weakElement);
   NS_ASSERTION(GetFullScreenElement() == aElement, "Should match");
   return true;
 }
 void
 nsDocument::FullScreenStackPop()
 {
   if (mFullScreenStack.IsEmpty()) {
     return;
   }
   // Remove styles from existing top element.
   Element* top = FullScreenStackTop();
   EventStateManager::SetFullScreenState(top, false);
   // Remove top element. Note the remaining top element in the stack
   // will not have full-screen style bits set, so we will need to restore
   // them on the new top element before returning.
   uint32_t last = mFullScreenStack.Length() - 1;
   mFullScreenStack.RemoveElementAt(last);
   // Pop from the stack null elements (references to elements which have
   // been GC'd since they were added to the stack) and elements which are
   // no longer in this document.
   while (!mFullScreenStack.IsEmpty()) {
     Element* element = FullScreenStackTop();
     if (!element || !element->IsInDoc() || element->OwnerDoc() != this) {
       NS_ASSERTION(!element->IsFullScreenAncestor(),
                    "Should have already removed full-screen styles");
       uint32_t last = mFullScreenStack.Length() - 1;
       mFullScreenStack.RemoveElementAt(last);
     } else {
       // The top element of the stack is now an in-doc element. Apply the
       // full-screen styles and return.
       EventStateManager::SetFullScreenState(element, true);
       break;
     }
   }
 }
 Element*
 nsDocument::FullScreenStackTop()
 {
   if (mFullScreenStack.IsEmpty()) {
     return nullptr;
   }
   uint32_t last = mFullScreenStack.Length() - 1;
   nsCOMPtr<Element> element(do_QueryReferent(mFullScreenStack[last]));
   NS_ASSERTION(element, "Should have full-screen element!");
   NS_ASSERTION(element->IsInDoc(), "Full-screen element should be in doc");
   NS_ASSERTION(element->OwnerDoc() == this, "Full-screen element should be in this doc");
   return element;
 }
 // Returns true if aDoc is in the focused tab in the active window.
 static bool
 IsInActiveTab(nsIDocument* aDoc)
 {
   nsCOMPtr<nsIDocShell> docshell = aDoc->GetDocShell();
   if (!docshell) {
     return false;
   }
   bool isActive = false;
   docshell->GetIsActive(&isActive);
   if (!isActive) {
     return false;
   }
   nsCOMPtr<nsIDocShellTreeItem> rootItem;
   docshell->GetRootTreeItem(getter_AddRefs(rootItem));
   if (!rootItem) {
     return false;
   }
   nsCOMPtr<nsIDOMWindow> rootWin = do_GetInterface(rootItem);
   if (!rootWin) {
     return false;
   }
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     return false;
   }
   nsCOMPtr<nsIDOMWindow> activeWindow;
   fm->GetActiveWindow(getter_AddRefs(activeWindow));
   if (!activeWindow) {
     return false;
   }
   return activeWindow == rootWin;
 }
 nsresult nsDocument::RemoteFrameFullscreenChanged(nsIDOMElement* aFrameElement,
                                                   const nsAString& aOrigin)
 {
   // Ensure the frame element is the fullscreen element in this document.
   // If the frame element is already the fullscreen element in this document,
   // this has no effect.
   nsCOMPtr<nsIContent> content(do_QueryInterface(aFrameElement));
   RequestFullScreen(content->AsElement(),
                     /* aWasCallerChrome */ false,
                     /* aNotifyOnOriginChange */ false);
   // Origin changed in child process, send notifiction, so that chrome can
   // update the UI to reflect the fullscreen origin change if necessary.
   // The BrowserElementChild listens on this, and forwards it over its
   // parent process, where it is redispatched. Chrome (in the root process,
   // which could be *this* process) listens for this notification so that
   // it can show a warning or approval UI.
   if (!aOrigin.IsEmpty()) {
     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
     os->NotifyObservers(GetFullscreenRootDocument(this),
                         "fullscreen-origin-change",
                         PromiseFlatString(aOrigin).get());
   }
   return NS_OK;
 }
 nsresult nsDocument::RemoteFrameFullscreenReverted()
 {
   RestorePreviousFullScreenState();
   return NS_OK;
 }
 void
 nsDocument::RequestFullScreen(Element* aElement,
                               bool aWasCallerChrome,
                               bool aNotifyOnOriginChange)
 {
   NS_ASSERTION(aElement,
     "Must pass non-null element to nsDocument::RequestFullScreen");
   if (!aElement || aElement == GetFullScreenElement()) {
     return;
   }
   if (!aElement->IsInDoc()) {
     LogFullScreenDenied(true, "FullScreenDeniedNotInDocument", this);
     return;
   }
   if (aElement->OwnerDoc() != this) {
     LogFullScreenDenied(true, "FullScreenDeniedMovedDocument", this);
     return;
   }
   if (!GetWindow()) {
     LogFullScreenDenied(true, "FullScreenDeniedLostWindow", this);
     return;
   }
   if (nsContentUtils::IsFullscreenApiContentOnly() &&
       nsContentUtils::IsChromeDoc(this)) {
     // Block fullscreen requests in the chrome document when the fullscreen API
     // is configured for content only.
     LogFullScreenDenied(true, "FullScreenDeniedContentOnly", this);
     return;
   }
   if (!IsFullScreenEnabled(aWasCallerChrome, true)) {
     // IsFullScreenEnabled calls LogFullScreenDenied, no need to log.
     return;
   }
   if (GetFullScreenElement() &&
       !nsContentUtils::ContentIsDescendantOf(aElement, GetFullScreenElement())) {
     // If this document is full-screen, only grant full-screen requests from
     // a descendant of the current full-screen element.
     LogFullScreenDenied(true, "FullScreenDeniedNotDescendant", this);
     return;
   }
   if (!nsContentUtils::IsChromeDoc(this) && !IsInActiveTab(this)) {
     LogFullScreenDenied(true, "FullScreenDeniedNotFocusedTab", this);
     return;
   }
   // Deny requests when a windowed plugin is focused.
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (!fm) {
     NS_WARNING("Failed to retrieve focus manager in full-screen request.");
     return;
   }
   nsCOMPtr<nsIDOMElement> focusedElement;
   fm->GetFocusedElement(getter_AddRefs(focusedElement));
   if (focusedElement) {
     nsCOMPtr<nsIContent> content = do_QueryInterface(focusedElement);
     if (nsContentUtils::HasPluginWithUncontrolledEventDispatch(content)) {
       LogFullScreenDenied(true, "FullScreenDeniedFocusedPlugin", this);
       return;
     }
   }
   // Stash a reference to any existing fullscreen doc, we'll use this later
   // to detect if the origin which is fullscreen has changed.
   nsCOMPtr<nsIDocument> previousFullscreenDoc = GetFullscreenLeaf(this);
   AddFullscreenApprovedObserver();
   // Stores a list of documents which we must dispatch "mozfullscreenchange"
   // too. We're required by the spec to dispatch the events in root-to-leaf
   // order, but we traverse the doctree in a leaf-to-root order, so we save
   // references to the documents we must dispatch to so that we get the order
   // as specified.
   nsAutoTArray<nsIDocument*, 8> changed;
   // Remember the root document, so that if a full-screen document is hidden
   // we can reset full-screen state in the remaining visible full-screen documents.
   nsIDocument* fullScreenRootDoc = GetFullscreenRootDocument(this);
   if (fullScreenRootDoc->IsFullScreenDoc()) {
     // A document is already in fullscreen, unlock the mouse pointer
     // before setting a new document to fullscreen
     UnlockPointer();
   }
   // If a document is already in fullscreen, then unlock the mouse pointer
   // before setting a new document to fullscreen
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (pointerLockedElement) {
     UnlockPointer();
   }
   // Set the full-screen element. This sets the full-screen style on the
   // element, and the full-screen-ancestor styles on ancestors of the element
   // in this document.
   DebugOnly<bool> x = FullScreenStackPush(aElement);
   NS_ASSERTION(x, "Full-screen state of requesting doc should always change!");
   changed.AppendElement(this);
   // Propagate up the document hierarchy, setting the full-screen element as
   // the element's container in ancestor documents. This also sets the
   // appropriate css styles as well. Note we don't propagate down the
   // document hierarchy, the full-screen element (or its container) is not
   // visible there. Stop when we reach the root document.
   nsIDocument* child = this;
   while (true) {
     child->SetFullscreenRoot(fullScreenRootDoc);
     NS_ASSERTION(child->GetFullscreenRoot() == fullScreenRootDoc,
         "Fullscreen root should be set!");
     if (child == fullScreenRootDoc) {
       break;
     }
     nsIDocument* parent = child->GetParentDocument();
     Element* element = parent->FindContentForSubDocument(child)->AsElement();
     if (static_cast<nsDocument*>(parent)->FullScreenStackPush(element)) {
       changed.AppendElement(parent);
       child = parent;
     } else {
       // We've reached either the root, or a point in the doctree where the
       // new full-screen element container is the same as the previous
       // full-screen element's container. No more changes need to be made
       // to the full-screen stacks of documents further up the tree.
       break;
     }
   }
   // Dispatch "mozfullscreenchange" events. Note this loop is in reverse
   // order so that the events for the root document arrives before the leaf
   // document, as required by the spec.
   for (uint32_t i = 0; i < changed.Length(); ++i) {
     DispatchFullScreenChange(changed[changed.Length() - i - 1]);
   }
   // If this document hasn't already been approved in this session,
   // check to see if the user has granted the fullscreen access
   // to the document's principal's host, if it has one. Note that documents
   // in web apps which are the same origin as the web app are considered
   // trusted and so are automatically approved.
   if (!mIsApprovedForFullscreen) {
     mIsApprovedForFullscreen =
       !Preferences::GetBool("full-screen-api.approval-required") ||
       NodePrincipal()->GetAppStatus() >= nsIPrincipal::APP_STATUS_INSTALLED ||
       nsContentUtils::IsSitePermAllow(NodePrincipal(), "fullscreen");
   }
   // If this document, or a document with the same principal has not
   // already been approved for fullscreen this fullscreen-session, dispatch
   // an event so that chrome knows to pop up a warning/approval UI.
   // Note previousFullscreenDoc=nullptr upon first entry, so we always
   // take this path on the first time we enter fullscreen in a fullscreen
   // session.
   if (!mIsApprovedForFullscreen ||
       !nsContentUtils::HaveEqualPrincipals(previousFullscreenDoc, this)) {
     nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
       new AsyncEventDispatcher(this,
                                NS_LITERAL_STRING("MozEnteredDomFullscreen"),
                                true,
                                true);
     asyncDispatcher->PostDOMEvent();
   }
 #ifdef DEBUG
   // Note assertions must run before SetWindowFullScreen() as that does
   // synchronous event dispatch which can run script which exits full-screen!
   NS_ASSERTION(GetFullScreenElement() == aElement,
                "Full-screen element should be the requested element!");
   NS_ASSERTION(IsFullScreenDoc(), "Should be full-screen doc");
   nsCOMPtr<nsIDOMElement> fse;
   GetMozFullScreenElement(getter_AddRefs(fse));
   nsCOMPtr<nsIContent> c(do_QueryInterface(fse));
   NS_ASSERTION(c->AsElement() == aElement,
     "GetMozFullScreenElement should match GetFullScreenElement()");
 #endif
   // The origin which is fullscreen changed, send a notifiction so that the
   // root document knows the origin of the document which requested fullscreen.
   // This is used for the fullscreen approval UI. If we're in a child
   // process, the root BrowserElementChild listens for this notification,
   // and forwards it across to its BrowserElementParent, which
   // re-broadcasts the message for the root document in its process.
   if (aNotifyOnOriginChange &&
       !nsContentUtils::HaveEqualPrincipals(previousFullscreenDoc, this)) {
     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
     nsIDocument* root = GetFullscreenRootDocument(this);
     nsAutoString origin;
     nsContentUtils::GetUTFOrigin(NodePrincipal(), origin);
     os->NotifyObservers(root, "fullscreen-origin-change", origin.get());
   }
   // Make the window full-screen. Note we must make the state changes above
   // before making the window full-screen, as then the document reports as
   // being in full-screen mode when the chrome "fullscreen" event fires,
   // enabling chrome to distinguish between browser and dom full-screen
   // modes. Also note that nsGlobalWindow::SetFullScreen() (which
   // SetWindowFullScreen() calls) proxies to the root window in its hierarchy,
   // and does not operate on the a per-nsIDOMWindow basis.
   SetWindowFullScreen(this, true);
 }
 NS_IMETHODIMP
 nsDocument::GetMozFullScreenElement(nsIDOMElement **aFullScreenElement)
 {
   ErrorResult rv;
   Element* el = GetMozFullScreenElement(rv);
   if (rv.Failed()) {
     return rv.ErrorCode();
   }
   nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(el);
   retval.forget(aFullScreenElement);
   return NS_OK;
 }
 Element*
 nsDocument::GetMozFullScreenElement(ErrorResult& rv)
 {
   if (IsFullScreenDoc()) {
     // Must have a full-screen element while in full-screen mode.
     Element* el = GetFullScreenElement();
     if (!el) {
       rv.Throw(NS_ERROR_UNEXPECTED);
     }
     return el;
   }
   return nullptr;
 }
 Element*
 nsDocument::GetFullScreenElement()
 {
   Element* element = FullScreenStackTop();
   NS_ASSERTION(!element ||
                element->IsFullScreenAncestor(),
     "Fullscreen element should have fullscreen styles applied");
   return element;
 }
 NS_IMETHODIMP
 nsDocument::GetMozFullScreen(bool *aFullScreen)
 {
   *aFullScreen = MozFullScreen();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetMozFullScreenEnabled(bool *aFullScreen)
 {
   NS_ENSURE_ARG_POINTER(aFullScreen);
   *aFullScreen = MozFullScreenEnabled();
   return NS_OK;
 }
 bool
 nsDocument::MozFullScreenEnabled()
 {
   return IsFullScreenEnabled(nsContentUtils::IsCallerChrome(), false);
 }
 static bool
 HasFullScreenSubDocument(nsIDocument* aDoc)
 {
   uint32_t count = CountFullscreenSubDocuments(aDoc);
   NS_ASSERTION(count <= 1, "Fullscreen docs should have at most 1 fullscreen child!");
   return count >= 1;
 }
 bool
 nsDocument::IsFullScreenEnabled(bool aCallerIsChrome, bool aLogFailure)
 {
   if (nsContentUtils::IsFullScreenApiEnabled() && aCallerIsChrome) {
     // Chrome code can always use the full-screen API, provided it's not
     // explicitly disabled. Note IsCallerChrome() returns true when running
     // in an nsRunnable, so don't use GetMozFullScreenEnabled() from an
     // nsRunnable!
     return true;
   }
   if (!nsContentUtils::IsFullScreenApiEnabled()) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedDisabled", this);
     return false;
   }
   if (!IsVisible()) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedHidden", this);
     return false;
   }
   if (HasFullScreenSubDocument(this)) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedSubDocFullScreen", this);
     return false;
   }
   // Ensure that all ancestor <iframe> elements have the allowfullscreen
   // boolean attribute set.
   nsCOMPtr<nsIDocShell> docShell(mDocumentContainer);
   bool allowed = false;
   if (docShell) {
     docShell->GetFullscreenAllowed(&allowed);
   }
   if (!allowed) {
     LogFullScreenDenied(aLogFailure, "FullScreenDeniedIframeNotAllowed", this);
   }
   return allowed;
 }
 static void
 DispatchPointerLockChange(nsIDocument* aTarget)
 {
   if (!aTarget) {
     return;
   }
   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(aTarget,
                              NS_LITERAL_STRING("mozpointerlockchange"),
                              true,
                              false);
   asyncDispatcher->PostDOMEvent();
 }
 static void
 DispatchPointerLockError(nsIDocument* aTarget)
 {
   if (!aTarget) {
     return;
   }
   nsRefPtr<AsyncEventDispatcher> asyncDispatcher =
     new AsyncEventDispatcher(aTarget,
                              NS_LITERAL_STRING("mozpointerlockerror"),
                              true,
                              false);
   asyncDispatcher->PostDOMEvent();
 }
 mozilla::StaticRefPtr<nsPointerLockPermissionRequest> gPendingPointerLockRequest;
 class nsPointerLockPermissionRequest : public nsRunnable,
                                        public nsIContentPermissionRequest
 {
 public:
   nsPointerLockPermissionRequest(Element* aElement, bool aUserInputOrChromeCaller)
   : mElement(do_GetWeakReference(aElement)),
     mDocument(do_GetWeakReference(aElement->OwnerDoc())),
     mUserInputOrChromeCaller(aUserInputOrChromeCaller) {}
   virtual ~nsPointerLockPermissionRequest() {}
   NS_DECL_ISUPPORTS
   NS_DECL_NSICONTENTPERMISSIONREQUEST
   NS_IMETHOD Run()
   {
     nsCOMPtr<Element> e = do_QueryReferent(mElement);
     nsCOMPtr<nsIDocument> d = do_QueryReferent(mDocument);
     if (!e || !d || gPendingPointerLockRequest != this ||
         e->GetCurrentDoc() != d) {
       Handled();
       DispatchPointerLockError(d);
       return NS_OK;
     }
     // We're about to enter fullscreen mode.
     nsDocument* doc = static_cast<nsDocument*>(d.get());
     if (doc->mAsyncFullscreenPending ||
         (doc->mHasFullscreenApprovedObserver && !doc->mIsApprovedForFullscreen)) {
       // We're still waiting for approval.
       return NS_OK;
     }
     if (doc->mIsApprovedForFullscreen || doc->mAllowRelocking) {
       Allow(JS::UndefinedHandleValue);
       return NS_OK;
     }
     // In non-fullscreen mode user input (or chrome caller) is required!
     // Also, don't let the page to try to get the permission too many times.
     if (!mUserInputOrChromeCaller ||
         doc->mCancelledPointerLockRequests > 2) {
       Handled();
       DispatchPointerLockError(d);
       return NS_OK;
     }
     // Handling a request from user input in non-fullscreen mode.
     // Do a normal permission check.
     nsCOMPtr<nsIContentPermissionPrompt> prompt =
       do_CreateInstance(NS_CONTENT_PERMISSION_PROMPT_CONTRACTID);
     if (prompt) {
       prompt->Prompt(this);
     }
     return NS_OK;
   }
   void Handled()
   {
     mElement = nullptr;
     mDocument = nullptr;
     if (gPendingPointerLockRequest == this) {
       gPendingPointerLockRequest = nullptr;
     }
   }
   nsWeakPtr mElement;
   nsWeakPtr mDocument;
   bool mUserInputOrChromeCaller;
 };
 NS_IMPL_ISUPPORTS_INHERITED(nsPointerLockPermissionRequest,
                             nsRunnable,
                             nsIContentPermissionRequest)
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::GetTypes(nsIArray** aTypes)
 {
   nsTArray<nsString> emptyOptions;
   return CreatePermissionArray(NS_LITERAL_CSTRING("pointerLock"),
                                NS_LITERAL_CSTRING("unused"),
                                emptyOptions,
                                aTypes);
 }
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::GetPrincipal(nsIPrincipal** aPrincipal)
 {
   nsCOMPtr<nsIDocument> d = do_QueryReferent(mDocument);
   if (d) {
     NS_ADDREF(*aPrincipal = d->NodePrincipal());
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::GetWindow(nsIDOMWindow** aWindow)
 {
   nsCOMPtr<nsIDocument> d = do_QueryReferent(mDocument);
   if (d) {
     NS_IF_ADDREF(*aWindow = d->GetInnerWindow());
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::GetElement(nsIDOMElement** aElement)
 {
   // It is enough to implement GetWindow.
   *aElement = nullptr;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::Cancel()
 {
   nsCOMPtr<nsIDocument> d = do_QueryReferent(mDocument);
   Handled();
   if (d) {
     static_cast<nsDocument*>(d.get())->mCancelledPointerLockRequests++;
     DispatchPointerLockError(d);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsPointerLockPermissionRequest::Allow(JS::HandleValue aChoices)
 {
   MOZ_ASSERT(aChoices.isUndefined());
   nsCOMPtr<Element> e = do_QueryReferent(mElement);
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
   nsDocument* d = static_cast<nsDocument*>(doc.get());
   if (!e || !d || gPendingPointerLockRequest != this ||
       e->GetCurrentDoc() != d ||
       (!mUserInputOrChromeCaller && !d->mIsApprovedForFullscreen)) {
     Handled();
     DispatchPointerLockError(d);
     return NS_OK;
   }
   // Mark handled here so that we don't need to call it everywhere below.
   Handled();
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (e == pointerLockedElement) {
     DispatchPointerLockChange(d);
     return NS_OK;
   }
   // Note, we must bypass focus change, so pass true as the last parameter!
   if (!d->ShouldLockPointer(e, pointerLockedElement, true)) {
     DispatchPointerLockError(d);
     return NS_OK;
   }
   if (!d->SetPointerLock(e, NS_STYLE_CURSOR_NONE)) {
     DispatchPointerLockError(d);
     return NS_OK;
   }
   d->mCancelledPointerLockRequests = 0;
   e->SetPointerLock();
   EventStateManager::sPointerLockedElement = do_GetWeakReference(e);
   EventStateManager::sPointerLockedDoc = do_GetWeakReference(doc);
   NS_ASSERTION(EventStateManager::sPointerLockedElement &&
                EventStateManager::sPointerLockedDoc,
                "aElement and this should support weak references!");
   DispatchPointerLockChange(d);
   return NS_OK;
 }
 void
 nsDocument::SetApprovedForFullscreen(bool aIsApproved)
 {
   mIsApprovedForFullscreen = aIsApproved;
 }
 nsresult
 nsDocument::Observe(nsISupports *aSubject,
                     const char *aTopic,
                     const char16_t *aData)
 {
   if (strcmp("fullscreen-approved", aTopic) == 0) {
     nsCOMPtr<nsIDocument> subject(do_QueryInterface(aSubject));
     if (subject != this) {
       return NS_OK;
     }
     SetApprovedForFullscreen(true);
     if (gPendingPointerLockRequest) {
       // We have a request pending. Create a clone of it and re-dispatch so that
       // Run() method gets called again.
       nsCOMPtr<Element> el =
         do_QueryReferent(gPendingPointerLockRequest->mElement);
       nsCOMPtr<nsIDocument> doc =
         do_QueryReferent(gPendingPointerLockRequest->mDocument);
       bool userInputOrChromeCaller =
         gPendingPointerLockRequest->mUserInputOrChromeCaller;
       gPendingPointerLockRequest->Handled();
       if (doc == this && el && el->GetCurrentDoc() == doc) {
         nsPointerLockPermissionRequest* clone =
           new nsPointerLockPermissionRequest(el, userInputOrChromeCaller);
         gPendingPointerLockRequest = clone;
         nsCOMPtr<nsIRunnable> r = gPendingPointerLockRequest.get();
         NS_DispatchToMainThread(r);
       }
     }
   }
   return NS_OK;
 }
 void
 nsDocument::RequestPointerLock(Element* aElement)
 {
   NS_ASSERTION(aElement,
     "Must pass non-null element to nsDocument::RequestPointerLock");
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (aElement == pointerLockedElement) {
     DispatchPointerLockChange(this);
     return;
   }
   if (!ShouldLockPointer(aElement, pointerLockedElement)) {
     DispatchPointerLockError(this);
     return;
   }
   bool userInputOrChromeCaller = EventStateManager::IsHandlingUserInput() ||
                                  nsContentUtils::IsCallerChrome();
   gPendingPointerLockRequest =
     new nsPointerLockPermissionRequest(aElement, userInputOrChromeCaller);
   nsCOMPtr<nsIRunnable> r = gPendingPointerLockRequest.get();
   NS_DispatchToMainThread(r);
 }
 bool
 nsDocument::ShouldLockPointer(Element* aElement, Element* aCurrentLock,
                               bool aNoFocusCheck)
 {
   // Check if pointer lock pref is enabled
   if (!Preferences::GetBool("full-screen-api.pointer-lock.enabled")) {
     NS_WARNING("ShouldLockPointer(): Pointer Lock pref not enabled");
     return false;
   }
   if (aCurrentLock && aCurrentLock->OwnerDoc() != aElement->OwnerDoc()) {
     NS_WARNING("ShouldLockPointer(): Existing pointer lock element in a different document");
     return false;
   }
   if (!aElement->IsInDoc()) {
     NS_WARNING("ShouldLockPointer(): Element without Document");
     return false;
   }
   if (mSandboxFlags & SANDBOXED_POINTER_LOCK) {
     NS_WARNING("ShouldLockPointer(): Document is sandboxed and doesn't allow pointer-lock");
     return false;
   }
   // Check if the element is in a document with a docshell.
   nsCOMPtr<nsIDocument> ownerDoc = aElement->OwnerDoc();
   if (!ownerDoc->GetContainer()) {
     return false;
   }
   nsCOMPtr<nsPIDOMWindow> ownerWindow = ownerDoc->GetWindow();
   if (!ownerWindow) {
     return false;
   }
   nsCOMPtr<nsPIDOMWindow> ownerInnerWindow = ownerDoc->GetInnerWindow();
   if (!ownerInnerWindow) {
     return false;
   }
   if (ownerWindow->GetCurrentInnerWindow() != ownerInnerWindow) {
     return false;
   }
   nsCOMPtr<nsIDOMWindow> top;
   ownerWindow->GetScriptableTop(getter_AddRefs(top));
   nsCOMPtr<nsPIDOMWindow> piTop = do_QueryInterface(top);
   if (!piTop || !piTop->GetExtantDoc() ||
       piTop->GetExtantDoc()->Hidden()) {
     NS_WARNING("ShouldLockPointer(): Top document isn't visible.");
     return false;
   }
   if (!aNoFocusCheck) {
     mozilla::ErrorResult rv;
     if (!piTop->GetExtantDoc()->HasFocus(rv)) {
       NS_WARNING("ShouldLockPointer(): Top document isn't focused.");
       return false;
     }
   }
   return true;
 }
 bool
 nsDocument::SetPointerLock(Element* aElement, int aCursorStyle)
 {
   // NOTE: aElement will be nullptr when unlocking.
   nsCOMPtr<nsPIDOMWindow> window = GetWindow();
   if (!window) {
     NS_WARNING("SetPointerLock(): No Window");
     return false;
   }
   nsIDocShell *docShell = window->GetDocShell();
   if (!docShell) {
     NS_WARNING("SetPointerLock(): No DocShell (window already closed?)");
     return false;
   }
   nsRefPtr<nsPresContext> presContext;
   docShell->GetPresContext(getter_AddRefs(presContext));
   if (!presContext) {
     NS_WARNING("SetPointerLock(): Unable to get presContext in \
                 domWindow->GetDocShell()->GetPresContext()");
     return false;
   }
   nsCOMPtr<nsIPresShell> shell = presContext->PresShell();
   if (!shell) {
     NS_WARNING("SetPointerLock(): Unable to find presContext->PresShell()");
     return false;
   }
   nsIFrame* rootFrame = shell->GetRootFrame();
   if (!rootFrame) {
     NS_WARNING("SetPointerLock(): Unable to get root frame");
     return false;
   }
   nsCOMPtr<nsIWidget> widget = rootFrame->GetNearestWidget();
   if (!widget) {
     NS_WARNING("SetPointerLock(): Unable to find widget in \
                 shell->GetRootFrame()->GetNearestWidget();");
     return false;
   }
   if (aElement && (aElement->OwnerDoc() != this)) {
     NS_WARNING("SetPointerLock(): Element not in this document.");
     return false;
   }
   // Hide the cursor and set pointer lock for future mouse events
   nsRefPtr<EventStateManager> esm = presContext->EventStateManager();
   esm->SetCursor(aCursorStyle, nullptr, false,
 .0f, 0.0f, widget, true);
   esm->SetPointerLock(widget, aElement);
   return true;
 }
 void
 nsDocument::UnlockPointer(nsIDocument* aDoc)
 {
   if (!EventStateManager::sIsPointerLocked) {
     return;
   }
   nsCOMPtr<nsIDocument> pointerLockedDoc =
     do_QueryReferent(EventStateManager::sPointerLockedDoc);
   if (!pointerLockedDoc || (aDoc && aDoc != pointerLockedDoc)) {
     return;
   }
   nsDocument* doc = static_cast<nsDocument*>(pointerLockedDoc.get());
   if (!doc->SetPointerLock(nullptr, NS_STYLE_CURSOR_AUTO)) {
     return;
   }
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (pointerLockedElement) {
     pointerLockedElement->ClearPointerLock();
   }
   EventStateManager::sPointerLockedElement = nullptr;
   EventStateManager::sPointerLockedDoc = nullptr;
   static_cast<nsDocument*>(pointerLockedDoc.get())->mAllowRelocking = !!aDoc;
   gPendingPointerLockRequest = nullptr;
   DispatchPointerLockChange(pointerLockedDoc);
 }
 void
 nsIDocument::UnlockPointer(nsIDocument* aDoc)
 {
   nsDocument::UnlockPointer(aDoc);
 }
 NS_IMETHODIMP
 nsDocument::MozExitPointerLock()
 {
   nsIDocument::MozExitPointerLock();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetMozPointerLockElement(nsIDOMElement** aPointerLockedElement)
 {
   Element* el = nsIDocument::GetMozPointerLockElement();
   nsCOMPtr<nsIDOMElement> retval = do_QueryInterface(el);
   retval.forget(aPointerLockedElement);
   return NS_OK;
 }
 Element*
 nsIDocument::GetMozPointerLockElement()
 {
   nsCOMPtr<Element> pointerLockedElement =
     do_QueryReferent(EventStateManager::sPointerLockedElement);
   if (!pointerLockedElement) {
     return nullptr;
   }
   // Make sure pointer locked element is in the same document.
   nsCOMPtr<nsIDocument> pointerLockedDoc =
     do_QueryReferent(EventStateManager::sPointerLockedDoc);
   if (pointerLockedDoc != this) {
     return nullptr;
   }
   return pointerLockedElement;
 }
 void
 nsDocument::XPCOMShutdown()
 {
   gPendingPointerLockRequest = nullptr;
   sProcessingStack.destroyIfConstructed();
 }
 void
 nsDocument::UpdateVisibilityState()
 {
   dom::VisibilityState oldState = mVisibilityState;
   mVisibilityState = GetVisibilityState();
   if (oldState != mVisibilityState) {
     nsContentUtils::DispatchTrustedEvent(this, static_cast<nsIDocument*>(this),
                                          NS_LITERAL_STRING("visibilitychange"),
                                          /* bubbles = */ true,
                                          /* cancelable = */ false);
     nsContentUtils::DispatchTrustedEvent(this, static_cast<nsIDocument*>(this),
                                          NS_LITERAL_STRING("mozvisibilitychange"),
                                          /* bubbles = */ true,
                                          /* cancelable = */ false);
     EnumerateFreezableElements(NotifyActivityChanged, nullptr);
   }
 }
 VisibilityState
 nsDocument::GetVisibilityState() const
 {
   // We have to check a few pieces of information here:
   // 1)  Are we in bfcache (!IsVisible())?  If so, nothing else matters.
   // 2)  Do we have an outer window?  If not, we're hidden.  Note that we don't
   //     want to use GetWindow here because it does weird groveling for windows
   //     in some cases.
   // 3)  Is our outer window background?  If so, we're hidden.
   // Otherwise, we're visible.
   if (!IsVisible() || !mWindow || !mWindow->GetOuterWindow() ||
       mWindow->GetOuterWindow()->IsBackground()) {
     return dom::VisibilityState::Hidden;
   }
   return dom::VisibilityState::Visible;
 }
 /* virtual */ void
 nsDocument::PostVisibilityUpdateEvent()
 {
   nsCOMPtr<nsIRunnable> event =
     NS_NewRunnableMethod(this, &nsDocument::UpdateVisibilityState);
   NS_DispatchToMainThread(event);
 }
 NS_IMETHODIMP
 nsDocument::GetMozHidden(bool* aHidden)
 {
   *aHidden = MozHidden();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetHidden(bool* aHidden)
 {
   *aHidden = Hidden();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsDocument::GetMozVisibilityState(nsAString& aState)
 {
   WarnOnceAbout(ePrefixedVisibilityAPI);
   return GetVisibilityState(aState);
 }
 NS_IMETHODIMP
 nsDocument::GetVisibilityState(nsAString& aState)
 {
   const EnumEntry& entry =
     VisibilityStateValues::strings[static_cast<int>(mVisibilityState)];
   aState.AssignASCII(entry.value, entry.length);
   return NS_OK;
 }
 /* virtual */ void
 nsIDocument::DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const
 {
   aWindowSizes->mDOMOtherSize +=
     nsINode::SizeOfExcludingThis(aWindowSizes->mMallocSizeOf);
   if (mPresShell) {
     mPresShell->AddSizeOfIncludingThis(aWindowSizes->mMallocSizeOf,
                                        &aWindowSizes->mArenaStats,
                                        &aWindowSizes->mLayoutPresShellSize,
                                        &aWindowSizes->mLayoutStyleSetsSize,
                                        &aWindowSizes->mLayoutTextRunsSize,
                                        &aWindowSizes->mLayoutPresContextSize);
   }
   aWindowSizes->mPropertyTablesSize +=
     mPropertyTable.SizeOfExcludingThis(aWindowSizes->mMallocSizeOf);
   for (uint32_t i = 0, count = mExtraPropertyTables.Length();
        i < count; ++i) {
     aWindowSizes->mPropertyTablesSize +=
       mExtraPropertyTables[i]->SizeOfExcludingThis(aWindowSizes->mMallocSizeOf);
   }
   if (EventListenerManager* elm = GetExistingListenerManager()) {
     aWindowSizes->mDOMEventListenersCount += elm->ListenerCount();
   }
   // Measurement of the following members may be added later if DMD finds it
   // is worthwhile:
   // - many!
 }
 void
 nsIDocument::DocAddSizeOfIncludingThis(nsWindowSizes* aWindowSizes) const
 {
   aWindowSizes->mDOMOtherSize += aWindowSizes->mMallocSizeOf(this);
   DocAddSizeOfExcludingThis(aWindowSizes);
 }
 static size_t
 SizeOfStyleSheetsElementIncludingThis(nsIStyleSheet* aStyleSheet,
                                       MallocSizeOf aMallocSizeOf,
                                       void* aData)
 {
   return aStyleSheet->SizeOfIncludingThis(aMallocSizeOf);
 }
 size_t
 nsDocument::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
 {
   // This SizeOfExcludingThis() overrides the one from nsINode.  But
   // nsDocuments can only appear at the top of the DOM tree, and we use the
   // specialized DocAddSizeOfExcludingThis() in that case.  So this should never
   // be called.
   MOZ_CRASH();
 }
 void
 nsDocument::DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const
 {
   nsIDocument::DocAddSizeOfExcludingThis(aWindowSizes);
   for (nsIContent* node = nsINode::GetFirstChild();
        node;
        node = node->GetNextNode(this))
   {
     size_t nodeSize = node->SizeOfIncludingThis(aWindowSizes->mMallocSizeOf);
     size_t* p;
     switch (node->NodeType()) {
     case nsIDOMNode::ELEMENT_NODE:
       p = &aWindowSizes->mDOMElementNodesSize;
       break;
     case nsIDOMNode::TEXT_NODE:
       p = &aWindowSizes->mDOMTextNodesSize;
       break;
     case nsIDOMNode::CDATA_SECTION_NODE:
       p = &aWindowSizes->mDOMCDATANodesSize;
       break;
     case nsIDOMNode::COMMENT_NODE:
       p = &aWindowSizes->mDOMCommentNodesSize;
       break;
     default:
       p = &aWindowSizes->mDOMOtherSize;
       break;
     }
     *p += nodeSize;
     if (EventListenerManager* elm = node->GetExistingListenerManager()) {
       aWindowSizes->mDOMEventListenersCount += elm->ListenerCount();
     }
   }
   aWindowSizes->mStyleSheetsSize +=
     mStyleSheets.SizeOfExcludingThis(SizeOfStyleSheetsElementIncludingThis,
                                      aWindowSizes->mMallocSizeOf);
   aWindowSizes->mStyleSheetsSize +=
     mCatalogSheets.SizeOfExcludingThis(SizeOfStyleSheetsElementIncludingThis,
                                        aWindowSizes->mMallocSizeOf);
   aWindowSizes->mStyleSheetsSize +=
     mAdditionalSheets[eAgentSheet].
       SizeOfExcludingThis(SizeOfStyleSheetsElementIncludingThis,
                           aWindowSizes->mMallocSizeOf);
   aWindowSizes->mStyleSheetsSize +=
     mAdditionalSheets[eUserSheet].
       SizeOfExcludingThis(SizeOfStyleSheetsElementIncludingThis,
                           aWindowSizes->mMallocSizeOf);
   aWindowSizes->mStyleSheetsSize +=
     mAdditionalSheets[eAuthorSheet].
       SizeOfExcludingThis(SizeOfStyleSheetsElementIncludingThis,
                           aWindowSizes->mMallocSizeOf);
   // Lumping in the loader with the style-sheets size is not ideal,
   // but most of the things in there are in fact stylesheets, so it
   // doesn't seem worthwhile to separate it out.
   aWindowSizes->mStyleSheetsSize +=
     CSSLoader()->SizeOfIncludingThis(aWindowSizes->mMallocSizeOf);
   aWindowSizes->mDOMOtherSize +=
     mAttrStyleSheet ?
     mAttrStyleSheet->DOMSizeOfIncludingThis(aWindowSizes->mMallocSizeOf) :
 ;
   aWindowSizes->mDOMOtherSize +=
     mStyledLinks.SizeOfExcludingThis(nullptr, aWindowSizes->mMallocSizeOf);
   aWindowSizes->mDOMOtherSize +=
     mIdentifierMap.SizeOfExcludingThis(nsIdentifierMapEntry::SizeOfExcludingThis,
                                        aWindowSizes->mMallocSizeOf);
   // Measurement of the following members may be added later if DMD finds it
   // is worthwhile:
   // - many!
 }
 NS_IMETHODIMP
 nsDocument::QuerySelector(const nsAString& aSelector, nsIDOMElement **aReturn)
 {
   return nsINode::QuerySelector(aSelector, aReturn);
 }
 NS_IMETHODIMP
 nsDocument::QuerySelectorAll(const nsAString& aSelector, nsIDOMNodeList **aReturn)
 {
   return nsINode::QuerySelectorAll(aSelector, aReturn);
 }
 already_AddRefed<nsIDocument>
 nsIDocument::Constructor(const GlobalObject& aGlobal,
                          ErrorResult& rv)
 {
   nsCOMPtr<nsIScriptGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
   if (!global) {
     rv.Throw(NS_ERROR_UNEXPECTED);
     return nullptr;
   }
   nsCOMPtr<nsIScriptObjectPrincipal> prin = do_QueryInterface(aGlobal.GetAsSupports());
   if (!prin) {
     rv.Throw(NS_ERROR_UNEXPECTED);
     return nullptr;
   }
   nsCOMPtr<nsIURI> uri;
   NS_NewURI(getter_AddRefs(uri), "about:blank");
   if (!uri) {
     rv.Throw(NS_ERROR_OUT_OF_MEMORY);
     return nullptr;
   }
   nsCOMPtr<nsIDOMDocument> document;
   nsresult res =
     NS_NewDOMDocument(getter_AddRefs(document),
                       NullString(),
                       EmptyString(),
                       nullptr,
                       uri,
                       uri,
                       prin->GetPrincipal(),
                       true,
                       global,
                       DocumentFlavorLegacyGuess);
   if (NS_FAILED(res)) {
     rv.Throw(res);
     return nullptr;
   }
   nsCOMPtr<nsIDocument> doc = do_QueryInterface(document);
   doc->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
   return doc.forget();
 }
 already_AddRefed<nsIDOMXPathExpression>
 nsIDocument::CreateExpression(const nsAString& aExpression,
                               nsIDOMXPathNSResolver* aResolver,
                               ErrorResult& rv)
 {
   return XPathEvaluator()->CreateExpression(aExpression, aResolver, rv);
 }
 already_AddRefed<nsIDOMXPathNSResolver>
 nsIDocument::CreateNSResolver(nsINode* aNodeResolver,
                               ErrorResult& rv)
 {
   return XPathEvaluator()->CreateNSResolver(aNodeResolver, rv);
 }
 already_AddRefed<nsISupports>
 nsIDocument::Evaluate(const nsAString& aExpression, nsINode* aContextNode,
                       nsIDOMXPathNSResolver* aResolver, uint16_t aType,
                       nsISupports* aResult, ErrorResult& rv)
 {
   return XPathEvaluator()->Evaluate(aExpression, aContextNode, aResolver, aType,
                                     aResult, rv);
 }
 NS_IMETHODIMP
 nsDocument::CreateExpression(const nsAString& aExpression,
                              nsIDOMXPathNSResolver* aResolver,
                              nsIDOMXPathExpression** aResult)
 {
   return XPathEvaluator()->CreateExpression(aExpression, aResolver, aResult);
 }
 NS_IMETHODIMP
 nsDocument::CreateNSResolver(nsIDOMNode* aNodeResolver,
                              nsIDOMXPathNSResolver** aResult)
 {
   return XPathEvaluator()->CreateNSResolver(aNodeResolver, aResult);
 }
 NS_IMETHODIMP
 nsDocument::Evaluate(const nsAString& aExpression, nsIDOMNode* aContextNode,
                      nsIDOMXPathNSResolver* aResolver, uint16_t aType,
                      nsISupports* aInResult, nsISupports** aResult)
 {
   return XPathEvaluator()->Evaluate(aExpression, aContextNode, aResolver, aType,
                                     aInResult, aResult);
 }
 // This is just a hack around the fact that window.document is not
 // [Unforgeable] yet.
 JSObject*
 nsIDocument::WrapObject(JSContext *aCx)
 {
   MOZ_ASSERT(IsDOMBinding());
   JS::Rooted<JSObject*> obj(aCx, nsINode::WrapObject(aCx));
   if (!obj) {
     return nullptr;
   }
   nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(GetInnerWindow());
   if (!win) {
     // No window, nothing else to do here
     return obj;
   }
   if (this != win->GetExtantDoc()) {
     // We're not the current document; we're also done here
     return obj;
   }
   JSAutoCompartment ac(aCx, obj);
   JS::Rooted<JS::Value> winVal(aCx);
   nsresult rv = nsContentUtils::WrapNative(aCx, win, &NS_GET_IID(nsIDOMWindow),
                                            &winVal,
                                            false);
   if (NS_FAILED(rv)) {
     Throw(aCx, rv);
     return nullptr;
   }
   NS_NAMED_LITERAL_STRING(doc_str, "document");
   if (!JS_DefineUCProperty(aCx, JSVAL_TO_OBJECT(winVal), doc_str.get(),
                            doc_str.Length(), JS::ObjectValue(*obj),
                            JS_PropertyStub, JS_StrictPropertyStub,
                            JSPROP_READONLY | JSPROP_ENUMERATE)) {
     return nullptr;
   }
   return obj;
 }
 XPathEvaluator*
 nsIDocument::XPathEvaluator()
 {
   if (!mXPathEvaluator) {
     mXPathEvaluator = new dom::XPathEvaluator(this);
   }
   return mXPathEvaluator;
 }
 already_AddRefed<nsIDocumentEncoder>
 nsIDocument::GetCachedEncoder()
 {
   return mCachedEncoder.forget();
 }
 void
 nsIDocument::SetCachedEncoder(already_AddRefed<nsIDocumentEncoder> aEncoder)
 {
   mCachedEncoder = aEncoder;
 }
 void
 nsIDocument::SetContentTypeInternal(const nsACString& aType)
 {
   mCachedEncoder = nullptr;
   mContentType = aType;
 }
 nsILoadContext*
 nsIDocument::GetLoadContext() const
 {
   return mDocumentContainer;
 }
 nsIDocShell*
 nsIDocument::GetDocShell() const
 {
   return mDocumentContainer;
 }
 void
 nsIDocument::SetStateObject(nsIStructuredCloneContainer *scContainer)
 {
   mStateObjectContainer = scContainer;
   mStateObjectCached = nullptr;
 }
 already_AddRefed<Element>
 nsIDocument::CreateHTMLElement(nsIAtom* aTag)
 {
   nsCOMPtr<nsINodeInfo> nodeInfo;
   nodeInfo = mNodeInfoManager->GetNodeInfo(aTag, nullptr, kNameSpaceID_XHTML,
                                            nsIDOMNode::ELEMENT_NODE);
   MOZ_ASSERT(nodeInfo, "GetNodeInfo should never fail");
   nsCOMPtr<Element> element;
   DebugOnly<nsresult> rv = NS_NewHTMLElement(getter_AddRefs(element),
                                              nodeInfo.forget(),
                                              mozilla::dom::NOT_FROM_PARSER);
   MOZ_ASSERT(NS_SUCCEEDED(rv), "NS_NewHTMLElement should never fail");
   return element.forget();
 }
 bool
 MarkDocumentTreeToBeInSyncOperation(nsIDocument* aDoc, void* aData)
 {
   nsCOMArray<nsIDocument>* documents =
     static_cast<nsCOMArray<nsIDocument>*>(aData);
   if (aDoc) {
     aDoc->SetIsInSyncOperation(true);
     documents->AppendObject(aDoc);
     aDoc->EnumerateSubDocuments(MarkDocumentTreeToBeInSyncOperation, aData);
   }
   return true;
 }
 nsAutoSyncOperation::nsAutoSyncOperation(nsIDocument* aDoc)
 {
   mMicroTaskLevel = nsContentUtils::MicroTaskLevel();
   nsContentUtils::SetMicroTaskLevel(0);
   if (aDoc) {
     nsPIDOMWindow* win = aDoc->GetWindow();
     if (win) {
       nsCOMPtr<nsIDOMWindow> topWindow;
       win->GetTop(getter_AddRefs(topWindow));
       nsCOMPtr<nsPIDOMWindow> top = do_QueryInterface(topWindow);
       if (top) {
         nsCOMPtr<nsIDocument> doc = top->GetExtantDoc();
         MarkDocumentTreeToBeInSyncOperation(doc, &mDocuments);
       }
     }
   }
 }
 nsAutoSyncOperation::~nsAutoSyncOperation()
 {
   for (int32_t i = 0; i < mDocuments.Count(); ++i) {
     mDocuments[i]->SetIsInSyncOperation(false);
   }
   nsContentUtils::SetMicroTaskLevel(mMicroTaskLevel);
 }

The Tor Browser / annotate

content/base/src/nsDocument.cpp@deefc01c0e14 (annotated)

content/base/src/nsDocument.cpp