import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

dom/xml/XMLDocument.cpp

@@ -0,0 +1,625 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+#include "mozilla/dom/XMLDocument.h"
+#include "nsParserCIID.h"
+#include "nsCharsetSource.h"
+#include "nsIXMLContentSink.h"
+#include "nsPresContext.h"
+#include "nsIContent.h"
+#include "nsIContentViewerContainer.h"
+#include "nsIContentViewer.h"
+#include "nsIDocShell.h"
+#include "nsHTMLParts.h"
+#include "nsIComponentManager.h"
+#include "nsIDOMElement.h"
+#include "nsIBaseWindow.h"
+#include "nsIDOMWindow.h"
+#include "nsIDOMDocumentType.h"
+#include "nsCOMPtr.h"
+#include "nsXPIDLString.h"
+#include "nsIHttpChannelInternal.h"
+#include "nsIURI.h"
+#include "nsIServiceManager.h"
+#include "nsNetUtil.h"
+#include "nsError.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIPrincipal.h"
+#include "nsLayoutCID.h"
+#include "mozilla/dom/Attr.h"
+#include "nsCExternalHandlerService.h"
+#include "nsMimeTypes.h"
+#include "mozilla/EventListenerManager.h"
+#include "nsContentUtils.h"
+#include "nsThreadUtils.h"
+#include "nsJSUtils.h"
+#include "nsCRT.h"
+#include "nsIAuthPrompt.h"
+#include "nsContentCreatorFunctions.h"
+#include "nsContentPolicyUtils.h"
+#include "nsNodeUtils.h"
+#include "nsIConsoleService.h"
+#include "nsIScriptError.h"
+#include "nsIHTMLDocument.h"
+#include "mozilla/BasicEvents.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/XMLDocumentBinding.h"
+#include "mozilla/dom/DocumentBinding.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+// ==================================================================
+// =
+// ==================================================================
+
+
+nsresult
+NS_NewDOMDocument(nsIDOMDocument** aInstancePtrResult,
+                  const nsAString& aNamespaceURI,
+                  const nsAString& aQualifiedName,
+                  nsIDOMDocumentType* aDoctype,
+                  nsIURI* aDocumentURI,
+                  nsIURI* aBaseURI,
+                  nsIPrincipal* aPrincipal,
+                  bool aLoadedAsData,
+                  nsIGlobalObject* aEventObject,
+                  DocumentFlavor aFlavor)
+{
+  // Note: can't require that aDocumentURI/aBaseURI/aPrincipal be non-null,
+  // since at least one caller (XMLHttpRequest) doesn't have decent args to
+  // pass in.
+
+  nsresult rv;
+
+  *aInstancePtrResult = nullptr;
+
+  nsCOMPtr<nsIDocument> d;
+  bool isHTML = false;
+  bool isXHTML = false;
+  if (aFlavor == DocumentFlavorSVG) {
+    rv = NS_NewSVGDocument(getter_AddRefs(d));
+  } else if (aFlavor == DocumentFlavorHTML) {
+    rv = NS_NewHTMLDocument(getter_AddRefs(d));
+    isHTML = true;
+  } else if (aFlavor == DocumentFlavorPlain) {
+    rv = NS_NewXMLDocument(getter_AddRefs(d), aLoadedAsData, true);
+  } else if (aDoctype) {
+    MOZ_ASSERT(aFlavor == DocumentFlavorLegacyGuess);
+    nsAutoString publicId, name;
+    aDoctype->GetPublicId(publicId);
+    if (publicId.IsEmpty()) {
+      aDoctype->GetName(name);
+    }
+    if (name.EqualsLiteral("html") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.01//EN") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Frameset//EN") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.01 Transitional//EN") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.0//EN") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Frameset//EN") ||
+        publicId.EqualsLiteral("-//W3C//DTD HTML 4.0 Transitional//EN")) {
+      rv = NS_NewHTMLDocument(getter_AddRefs(d));
+      isHTML = true;
+    } else if (publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Strict//EN") ||
+               publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Transitional//EN") ||
+               publicId.EqualsLiteral("-//W3C//DTD XHTML 1.0 Frameset//EN")) {
+      rv = NS_NewHTMLDocument(getter_AddRefs(d));
+      isHTML = true;
+      isXHTML = true;
+    }
+    else if (publicId.EqualsLiteral("-//W3C//DTD SVG 1.1//EN")) {
+      rv = NS_NewSVGDocument(getter_AddRefs(d));
+    }
+    // XXX Add support for XUL documents.
+    else {
+      rv = NS_NewXMLDocument(getter_AddRefs(d));
+    }
+  } else {
+    MOZ_ASSERT(aFlavor == DocumentFlavorLegacyGuess);
+    rv = NS_NewXMLDocument(getter_AddRefs(d));
+  }
+
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  if (isHTML) {
+    nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(d);
+    NS_ASSERTION(htmlDoc, "HTML Document doesn't implement nsIHTMLDocument?");
+    htmlDoc->SetCompatibilityMode(eCompatibility_FullStandards);
+    htmlDoc->SetIsXHTML(isXHTML);
+  }
+  nsDocument* doc = static_cast<nsDocument*>(d.get());
+  doc->SetLoadedAsData(aLoadedAsData);
+  doc->nsDocument::SetDocumentURI(aDocumentURI);
+  // Must set the principal first, since SetBaseURI checks it.
+  doc->SetPrincipal(aPrincipal);
+  doc->SetBaseURI(aBaseURI);
+
+  // We need to set the script handling object after we set the principal such
+  // that the doc group is assigned correctly.
+  if (nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aEventObject)) {
+    d->SetScriptHandlingObject(sgo);
+  } else if (aEventObject){
+    d->SetScopeObject(aEventObject);
+  }
+
+  // XMLDocuments and documents "created in memory" get to be UTF-8 by default,
+  // unlike the legacy HTML mess
+  doc->SetDocumentCharacterSet(NS_LITERAL_CSTRING("UTF-8"));
+
+  if (aDoctype) {
+    nsCOMPtr<nsIDOMNode> tmpNode;
+    rv = doc->AppendChild(aDoctype, getter_AddRefs(tmpNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  if (!aQualifiedName.IsEmpty()) {
+    nsCOMPtr<nsIDOMElement> root;
+    rv = doc->CreateElementNS(aNamespaceURI, aQualifiedName,
+                              getter_AddRefs(root));
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsCOMPtr<nsIDOMNode> tmpNode;
+
+    rv = doc->AppendChild(root, getter_AddRefs(tmpNode));
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  *aInstancePtrResult = doc;
+  NS_ADDREF(*aInstancePtrResult);
+
+  return NS_OK;
+}
+
+nsresult
+NS_NewXMLDocument(nsIDocument** aInstancePtrResult, bool aLoadedAsData,
+                  bool aIsPlainDocument)
+{
+  RefPtr<XMLDocument> doc = new XMLDocument();
+
+  nsresult rv = doc->Init();
+
+  if (NS_FAILED(rv)) {
+    *aInstancePtrResult = nullptr;
+    return rv;
+  }
+
+  doc->SetLoadedAsData(aLoadedAsData);
+  doc->mIsPlainDocument = aIsPlainDocument;
+  doc.forget(aInstancePtrResult);
+
+  return NS_OK;
+}
+
+nsresult
+NS_NewXBLDocument(nsIDOMDocument** aInstancePtrResult,
+                  nsIURI* aDocumentURI,
+                  nsIURI* aBaseURI,
+                  nsIPrincipal* aPrincipal)
+{
+  nsresult rv = NS_NewDOMDocument(aInstancePtrResult,
+                                  NS_LITERAL_STRING("http://www.mozilla.org/xbl"),
+                                  NS_LITERAL_STRING("bindings"), nullptr,
+                                  aDocumentURI, aBaseURI, aPrincipal, false,
+                                  nullptr, DocumentFlavorLegacyGuess);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIDocument> idoc = do_QueryInterface(*aInstancePtrResult);
+  nsDocument* doc = static_cast<nsDocument*>(idoc.get());
+  doc->SetLoadedAsInteractiveData(true);
+  doc->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
+
+  return NS_OK;
+}
+
+namespace mozilla {
+namespace dom {
+
+XMLDocument::XMLDocument(const char* aContentType)
+  : nsDocument(aContentType),
+    mAsync(true)
+{
+  // NOTE! nsDocument::operator new() zeroes out all members, so don't
+  // bother initializing members to 0.
+
+  mType = eGenericXML;
+}
+
+XMLDocument::~XMLDocument()
+{
+  // XXX We rather crash than hang
+  mLoopingForSyncLoad = false;
+}
+
+// QueryInterface implementation for XMLDocument
+NS_IMPL_ISUPPORTS_INHERITED(XMLDocument, nsDocument, nsIDOMXMLDocument)
+
+nsresult
+XMLDocument::Init()
+{
+  nsresult rv = nsDocument::Init();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return rv;
+}
+
+void
+XMLDocument::Reset(nsIChannel* aChannel, nsILoadGroup* aLoadGroup)
+{
+  nsDocument::Reset(aChannel, aLoadGroup);
+}
+
+void
+XMLDocument::ResetToURI(nsIURI *aURI, nsILoadGroup *aLoadGroup,
+                        nsIPrincipal* aPrincipal)
+{
+  if (mChannelIsPending) {
+    StopDocumentLoad();
+    mChannel->Cancel(NS_BINDING_ABORTED);
+    mChannelIsPending = false;
+  }
+
+  nsDocument::ResetToURI(aURI, aLoadGroup, aPrincipal);
+}
+
+bool
+XMLDocument::Load(const nsAString& aUrl, ErrorResult& aRv)
+{
+  bool hasHadScriptObject = true;
+  nsIScriptGlobalObject* scriptObject =
+    GetScriptHandlingObject(hasHadScriptObject);
+  if (!scriptObject && hasHadScriptObject) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return false;
+  }
+
+  nsCOMPtr<nsIDocument> callingDoc = GetEntryDocument();
+  nsCOMPtr<nsIPrincipal> principal = NodePrincipal();
+
+  // The callingDoc's Principal and doc's Principal should be the same
+  if (callingDoc && (callingDoc->NodePrincipal() != principal)) {
+    nsContentUtils::ReportToConsole(nsIScriptError::errorFlag,
+                                    NS_LITERAL_CSTRING("DOM"),
+                                    callingDoc,
+                                    nsContentUtils::eDOM_PROPERTIES,
+                                    "XMLDocumentLoadPrincipalMismatch");
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return false;
+  }
+
+  // Reporting a warning on ourselves is rather pointless, because we probably
+  // have no window id (and hence the warning won't show up in any web console)
+  // and probably aren't considered a "content document" because we're not
+  // loaded in a docshell, so won't accumulate telemetry for use counters.  Try
+  // warning on our entry document, if any, since that should have things like
+  // window ids and associated docshells.
+  nsIDocument* docForWarning = callingDoc ? callingDoc.get() : this;
+  if (nsContentUtils::IsCallerChrome()) {
+    docForWarning->WarnOnceAbout(nsIDocument::eChromeUseOfDOM3LoadMethod);
+  } else {
+    docForWarning->WarnOnceAbout(nsIDocument::eUseOfDOM3LoadMethod);
+  }
+
+  nsIURI *baseURI = mDocumentURI;
+  nsAutoCString charset;
+
+  if (callingDoc) {
+    baseURI = callingDoc->GetDocBaseURI();
+    charset = callingDoc->GetDocumentCharacterSet();
+  }
+
+  // Create a new URI
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_NewURI(getter_AddRefs(uri), aUrl, charset.get(), baseURI);
+  if (NS_FAILED(rv)) {
+    aRv.Throw(rv);
+    return false;
+  }
+
+  if (nsContentUtils::IsSystemPrincipal(principal)) {
+    // We're called from chrome, check to make sure the URI we're
+    // about to load is also chrome.
+
+    bool isChrome = false;
+    if (NS_FAILED(uri->SchemeIs("chrome", &isChrome)) || !isChrome) {
+      nsAutoCString spec;
+      if (mDocumentURI)
+        mDocumentURI->GetSpec(spec);
+
+      nsAutoString error;
+      error.AssignLiteral("Cross site loading using document.load is no "
+                          "longer supported. Use XMLHttpRequest instead.");
+      nsCOMPtr<nsIScriptError> errorObject =
+          do_CreateInstance(NS_SCRIPTERROR_CONTRACTID, &rv);
+      if (NS_FAILED(rv)) {
+        aRv.Throw(rv);
+        return false;
+      }
+
+      rv = errorObject->InitWithWindowID(error,
+                                         NS_ConvertUTF8toUTF16(spec),
+                                         EmptyString(),
+                                         0, 0, nsIScriptError::warningFlag,
+                                         "DOM",
+                                         callingDoc ?
+                                           callingDoc->InnerWindowID() :
+                                           this->InnerWindowID());
+
+      if (NS_FAILED(rv)) {
+        aRv.Throw(rv);
+        return false;
+      }
+
+      nsCOMPtr<nsIConsoleService> consoleService =
+        do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+      if (consoleService) {
+        consoleService->LogMessage(errorObject);
+      }
+
+      aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+      return false;
+    }
+  }
+
+  // Partial Reset, need to restore principal for security reasons and
+  // event listener manager so that load listeners etc. will
+  // remain. This should be done before the security check is done to
+  // ensure that the document is reset even if the new document can't
+  // be loaded.  Note that we need to hold a strong ref to |principal|
+  // here, because ResetToURI will null out our node principal before
+  // setting the new one.
+  RefPtr<EventListenerManager> elm(mListenerManager);
+  mListenerManager = nullptr;
+
+  // When we are called from JS we can find the load group for the page,
+  // and add ourselves to it. This way any pending requests
+  // will be automatically aborted if the user leaves the page.
+
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  if (callingDoc) {
+    loadGroup = callingDoc->GetDocumentLoadGroup();
+  }
+
+  ResetToURI(uri, loadGroup, principal);
+
+  mListenerManager = elm;
+
+  // Create a channel
+  nsCOMPtr<nsIInterfaceRequestor> req = nsContentUtils::SameOriginChecker();
+
+  nsCOMPtr<nsIChannel> channel;
+  // nsIRequest::LOAD_BACKGROUND prevents throbber from becoming active,
+  // which in turn keeps STOP button from becoming active
+  rv = NS_NewChannel(getter_AddRefs(channel),
+                     uri,
+                     callingDoc ? callingDoc.get() :
+                                  static_cast<nsIDocument*>(this),
+                     nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED,
+                     nsIContentPolicy::TYPE_INTERNAL_XMLHTTPREQUEST,
+                     loadGroup,
+                     req,
+                     nsIRequest::LOAD_BACKGROUND);
+
+  if (NS_FAILED(rv)) {
+    aRv.Throw(rv);
+    return false;
+  }
+
+  // TODO Bug 1189945: Remove nsIChannel CorsMode flag and set Request.mode
+  // based on nsILoadInfo securityFlags instead. This block will be removed
+  // when Request.mode set correctly.
+  nsCOMPtr<nsIHttpChannelInternal> httpChannel = do_QueryInterface(channel);
+  if (httpChannel) {
+    httpChannel->SetCorsMode(nsIHttpChannelInternal::CORS_MODE_SAME_ORIGIN);
+  }
+
+  // StartDocumentLoad asserts that readyState is uninitialized, so
+  // uninitialize it. SetReadyStateInternal make this transition invisible to
+  // Web content. But before doing that, assert that the current readyState
+  // is complete as it should be after the call to ResetToURI() above.
+  MOZ_ASSERT(GetReadyStateEnum() == nsIDocument::READYSTATE_COMPLETE,
+             "Bad readyState");
+  SetReadyStateInternal(nsIDocument::READYSTATE_UNINITIALIZED);
+
+  // Prepare for loading the XML document "into oneself"
+  nsCOMPtr<nsIStreamListener> listener;
+  if (NS_FAILED(rv = StartDocumentLoad(kLoadAsData, channel,
+                                       loadGroup, nullptr,
+                                       getter_AddRefs(listener),
+                                       false))) {
+    NS_ERROR("XMLDocument::Load: Failed to start the document load.");
+    aRv.Throw(rv);
+    return false;
+  }
+
+  // After this point, if we error out of this method we should clear
+  // mChannelIsPending.
+
+  // Start an asynchronous read of the XML document
+  rv = channel->AsyncOpen2(listener);
+  if (NS_FAILED(rv)) {
+    mChannelIsPending = false;
+    aRv.Throw(rv);
+    return false;
+  }
+
+  if (!mAsync) {
+    nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
+
+    nsAutoSyncOperation sync(this);
+    mLoopingForSyncLoad = true;
+    while (mLoopingForSyncLoad) {
+      if (!NS_ProcessNextEvent(thread))
+        break;
+    }
+
+    // We set return to true unless there was a parsing error
+    Element* rootElement = GetRootElement();
+    if (!rootElement) {
+      return false;
+    }
+
+    if (rootElement->LocalName().EqualsLiteral("parsererror")) {
+      nsAutoString ns;
+      rootElement->GetNamespaceURI(ns);
+      if (ns.EqualsLiteral("http://www.mozilla.org/newlayout/xml/parsererror.xml")) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+void
+XMLDocument::SetSuppressParserErrorElement(bool aSuppress)
+{
+  mSuppressParserErrorElement = aSuppress;
+}
+
+bool
+XMLDocument::SuppressParserErrorElement()
+{
+  return mSuppressParserErrorElement;
+}
+
+void
+XMLDocument::SetSuppressParserErrorConsoleMessages(bool aSuppress)
+{
+  mSuppressParserErrorConsoleMessages = aSuppress;
+}
+
+bool
+XMLDocument::SuppressParserErrorConsoleMessages()
+{
+  return mSuppressParserErrorConsoleMessages;
+}
+
+nsresult
+XMLDocument::StartDocumentLoad(const char* aCommand,
+                               nsIChannel* aChannel,
+                               nsILoadGroup* aLoadGroup,
+                               nsISupports* aContainer,
+                               nsIStreamListener **aDocListener,
+                               bool aReset,
+                               nsIContentSink* aSink)
+{
+  nsresult rv = nsDocument::StartDocumentLoad(aCommand,
+                                              aChannel, aLoadGroup,
+                                              aContainer,
+                                              aDocListener, aReset, aSink);
+  if (NS_FAILED(rv)) return rv;
+
+  if (nsCRT::strcmp("loadAsInteractiveData", aCommand) == 0) {
+    mLoadedAsInteractiveData = true;
+    aCommand = kLoadAsData; // XBL, for example, needs scripts and styles
+  }
+
+
+  int32_t charsetSource = kCharsetFromDocTypeDefault;
+  nsAutoCString charset(NS_LITERAL_CSTRING("UTF-8"));
+  TryChannelCharset(aChannel, charsetSource, charset, nullptr);
+
+  nsCOMPtr<nsIURI> aUrl;
+  rv = aChannel->GetURI(getter_AddRefs(aUrl));
+  if (NS_FAILED(rv)) return rv;
+
+  static NS_DEFINE_CID(kCParserCID, NS_PARSER_CID);
+
+  mParser = do_CreateInstance(kCParserCID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIXMLContentSink> sink;
+
+  if (aSink) {
+    sink = do_QueryInterface(aSink);
+  }
+  else {
+    nsCOMPtr<nsIDocShell> docShell;
+    if (aContainer) {
+      docShell = do_QueryInterface(aContainer);
+      NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
+    }
+    rv = NS_NewXMLContentSink(getter_AddRefs(sink), this, aUrl, docShell,
+                              aChannel);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+
+  // Set the parser as the stream listener for the document loader...
+  rv = CallQueryInterface(mParser, aDocListener);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(mChannel, "How can we not have a channel here?");
+  mChannelIsPending = true;
+
+  SetDocumentCharacterSet(charset);
+  mParser->SetDocumentCharset(charset, charsetSource);
+  mParser->SetCommand(aCommand);
+  mParser->SetContentSink(sink);
+  mParser->Parse(aUrl, nullptr, (void *)this);
+
+  return NS_OK;
+}
+
+void
+XMLDocument::EndLoad()
+{
+  mChannelIsPending = false;
+  mLoopingForSyncLoad = false;
+
+  mSynchronousDOMContentLoaded = (mLoadedAsData || mLoadedAsInteractiveData);
+  nsDocument::EndLoad();
+  if (mSynchronousDOMContentLoaded) {
+    mSynchronousDOMContentLoaded = false;
+    nsDocument::SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
+    // Generate a document load event for the case when an XML
+    // document was loaded as pure data without any presentation
+    // attached to it.
+    WidgetEvent event(true, eLoad);
+    EventDispatcher::Dispatch(static_cast<nsIDocument*>(this), nullptr, &event);
+  }
+}
+
+/* virtual */ void
+XMLDocument::DocAddSizeOfExcludingThis(nsWindowSizes* aWindowSizes) const
+{
+  nsDocument::DocAddSizeOfExcludingThis(aWindowSizes);
+}
+
+// nsIDOMDocument interface
+
+nsresult
+XMLDocument::Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const
+{
+  NS_ASSERTION(aNodeInfo->NodeInfoManager() == mNodeInfoManager,
+               "Can't import this document into another document!");
+
+  RefPtr<XMLDocument> clone = new XMLDocument();
+  nsresult rv = CloneDocHelper(clone);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // State from XMLDocument
+  clone->mAsync = mAsync;
+  clone->mIsPlainDocument = mIsPlainDocument;
+
+  return CallQueryInterface(clone.get(), aResult);
+}
+
+JSObject*
+XMLDocument::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  if (mIsPlainDocument) {
+    return DocumentBinding::Wrap(aCx, this, aGivenProto);
+  }
+
+  return XMLDocumentBinding::Wrap(aCx, this, aGivenProto);
+}
+
+} // namespace dom
+} // namespace mozilla