Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-25 19:25:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
41a179ba06
gecko-dev/dom/xml/XMLDocument.cpp
Andrew McCreight 5a1eb609f9 Bug 1493276 - Statically prevent CallQueryInterface to a base class r=froydnj 
If a class A is derived from a class B, then an instance of A can be
converted to an instance of class B via a static cast, so QI is not
needed. QIs are slower than static casts.

TestCallTemplates seems to be testing that CallQueryInterface compiles
even if the first argument's class is only ambiguously castable to
nsISupports, so I changed the second argument to be a class unrelated
to the concrete class.

I also removed some useless null checks on the return value of new.

Differential Revision: https://phabricator.services.mozilla.com/D6838

--HG--
extra : moz-landing-system : lando
2018-09-27 14:59:55 +00:00

645 lines
20 KiB
C++
Raw Blame History

/* -*- 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 "nsIContentViewer.h"
#include "nsIDocShell.h"
#include "nsHTMLParts.h"
#include "nsIComponentManager.h"
#include "nsIBaseWindow.h"
#include "nsIDOMWindow.h"
#include "nsCOMPtr.h"
#include "nsString.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/DocumentType.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(nsIDocument** aInstancePtrResult,
const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
DocumentType* 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(UTF_8_ENCODING);
if (aDoctype) {
ErrorResult result;
d->AppendChild(*aDoctype, result);
// Need to WouldReportJSException() if our callee can throw a JS
// exception (which it can) and we're neither propagating the
// error out nor unconditionally suppressing it.
result.WouldReportJSException();
if (NS_WARN_IF(result.Failed())) {
return result.StealNSResult();
}
}
if (!aQualifiedName.IsEmpty()) {
ErrorResult result;
ElementCreationOptionsOrString options;
options.SetAsString();
nsCOMPtr<Element> root =
doc->CreateElementNS(aNamespaceURI, aQualifiedName, options, result);
if (NS_WARN_IF(result.Failed())) {
return result.StealNSResult();
}
d->AppendChild(*root, result);
// Need to WouldReportJSException() if our callee can throw a JS
// exception (which it can) and we're neither propagating the
// error out nor unconditionally suppressing it.
result.WouldReportJSException();
if (NS_WARN_IF(result.Failed())) {
return result.StealNSResult();
}
}
d.forget(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(nsIDocument** 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);
nsIDocument* idoc = *aInstancePtrResult;
// XBL documents must allow XUL and XBL elements in them but the usual check
// only checks if the document is loaded in the system principal which is
// sometimes not the case.
idoc->ForceEnableXULXBL();
nsDocument* doc = static_cast<nsDocument*>(idoc);
doc->SetLoadedAsInteractiveData(true);
doc->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
return NS_OK;
}
namespace mozilla {
namespace dom {
XMLDocument::XMLDocument(const char* aContentType)
: nsDocument(aContentType),
mChannelIsPending(false),
mAsync(true),
mLoopingForSyncLoad(false),
mIsPlainDocument(false),
mSuppressParserErrorElement(false),
mSuppressParserErrorConsoleMessages(false)
{
mType = eGenericXML;
}
XMLDocument::~XMLDocument()
{
// XXX We rather crash than hang
mLoopingForSyncLoad = false;
}
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, CallerType aCallerType,
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 (aCallerType == CallerType::System) {
docForWarning->WarnOnceAbout(nsIDocument::eChromeUseOfDOM3LoadMethod);
} else {
docForWarning->WarnOnceAbout(nsIDocument::eUseOfDOM3LoadMethod);
}
nsIURI *baseURI = mDocumentURI;
nsAutoCString charset;
if (callingDoc) {
baseURI = callingDoc->GetDocBaseURI();
callingDoc->GetDocumentCharacterSet()->Name(charset);
}
// 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) {
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->InitWithSourceURI(error,
mDocumentURI,
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,
nullptr, // aPerformanceStorage
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) {
rv = httpChannel->SetCorsMode(nsIHttpChannelInternal::CORS_MODE_SAME_ORIGIN);
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
// 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) {
nsAutoSyncOperation sync(this);
mLoopingForSyncLoad = true;
SpinEventLoopUntil([&]() { return !mLoopingForSyncLoad; });
// 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;
NotNull<const Encoding*> encoding = UTF_8_ENCODING;
TryChannelCharset(aChannel, charsetSource, encoding, 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(encoding);
mParser->SetDocumentCharset(encoding, 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);
}
// nsIDocument interface
nsresult
XMLDocument::Clone(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;
clone.forget(aResult);
return NS_OK;
}
JSObject*
XMLDocument::WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto)
{
JSObject* obj;
if (mIsPlainDocument) {
obj = Document_Binding::Wrap(aCx, this, aGivenProto);
} else {
obj = XMLDocument_Binding::Wrap(aCx, this, aGivenProto);
}
if (!obj) {
MOZ_CRASH("Looks like bug 1488480/1405521, with XMLDocument::WrapNode failing");
}
return obj;
}
} // namespace dom
} // namespace mozilla
Reference in New Issue View Git Blame Copy Permalink