Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-20 16:55:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5a0fa68b78
gecko-dev/dom/xul/nsXULContentSink.cpp
Brendan Dahl 7ebaf1cd2b Bug 1527977 - Share XUL prototype cache with XUL and XHTML. r=smaug 
Create a new parser (PrototypeDocumentParser) and content sink
(PrototypeDocumentContentSink) that can be used by both XUL and XHTML.

The new parser moves the code from XULDocument that handles creating and
loading a nsXULPrototypeDocument from either the cache or the source
file. Once the parser has finished loading the prototype it notifies the
content sink. The parser is largely a stub and would be better suited
for use as a nsBaseParser, but nsHTMLDocument unfortunately needs an
nsIParser.

The new content sink has the XULDocument code responsible for the
prototype traversal that creates the DOM (XULDocument::ResumeWalk and
friends) and fires off various events.

To unify XUL and XHTML, the XHTML readystate event sequence is used in
XUL. However, the layout path of XHTML loaded from the prototype cache
more closely follows XUL, where frame initializers and layout don't
start until the entire DOM is built.

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

--HG--
rename : dom/xul/XULDocument.cpp => dom/prototype/PrototypeDocumentContentSink.cpp
rename : parser/moz.build => dom/prototype/moz.build
rename : parser/moz.build => parser/prototype/moz.build
extra : moz-landing-system : lando
2019-03-09 01:00:23 +00:00

941 lines
27 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/. */
/*
* An implementation for a Gecko-style content sink that knows how
* to build a content model (the "prototype" document) from XUL.
*
* For more information on XUL,
* see http://developer.mozilla.org/en/docs/XUL
*/
#include "nsXULContentSink.h"
#include "jsfriendapi.h"
#include "nsCOMPtr.h"
#include "nsHTMLStyleSheet.h"
#include "nsIContentSink.h"
#include "mozilla/dom/Document.h"
#include "nsIDOMEventListener.h"
#include "nsIFormControl.h"
#include "mozilla/dom/NodeInfo.h"
#include "nsIScriptContext.h"
#include "nsIScriptGlobalObject.h"
#include "nsIServiceManager.h"
#include "nsIURL.h"
#include "nsNameSpaceManager.h"
#include "nsParserBase.h"
#include "nsViewManager.h"
#include "nsIScriptSecurityManager.h"
#include "nsLayoutCID.h"
#include "nsNetUtil.h"
#include "nsString.h"
#include "nsReadableUtils.h"
#include "nsXULElement.h"
#include "mozilla/Logging.h"
#include "nsCRT.h"
#include "nsXULPrototypeDocument.h" // XXXbe temporary
#include "mozilla/css/Loader.h"
#include "nsUnicharUtils.h"
#include "nsGkAtoms.h"
#include "nsContentUtils.h"
#include "nsAttrName.h"
#include "nsXMLContentSink.h"
#include "nsIConsoleService.h"
#include "nsIScriptError.h"
#include "nsContentTypeParser.h"
#include "XULDocument.h"
static mozilla::LazyLogModule gContentSinkLog("nsXULContentSink");
;
//----------------------------------------------------------------------
XULContentSinkImpl::ContextStack::ContextStack() : mTop(nullptr), mDepth(0) {}
XULContentSinkImpl::ContextStack::~ContextStack() {
while (mTop) {
Entry* doomed = mTop;
mTop = mTop->mNext;
delete doomed;
}
}
nsresult XULContentSinkImpl::ContextStack::Push(nsXULPrototypeNode* aNode,
State aState) {
Entry* entry = new Entry(aNode, aState, mTop);
mTop = entry;
++mDepth;
return NS_OK;
}
nsresult XULContentSinkImpl::ContextStack::Pop(State* aState) {
if (mDepth == 0) return NS_ERROR_UNEXPECTED;
Entry* entry = mTop;
mTop = mTop->mNext;
--mDepth;
*aState = entry->mState;
delete entry;
return NS_OK;
}
nsresult XULContentSinkImpl::ContextStack::GetTopNode(
RefPtr<nsXULPrototypeNode>& aNode) {
if (mDepth == 0) return NS_ERROR_UNEXPECTED;
aNode = mTop->mNode;
return NS_OK;
}
nsresult XULContentSinkImpl::ContextStack::GetTopChildren(
nsPrototypeArray** aChildren) {
if (mDepth == 0) return NS_ERROR_UNEXPECTED;
*aChildren = &(mTop->mChildren);
return NS_OK;
}
void XULContentSinkImpl::ContextStack::Clear() {
Entry* cur = mTop;
while (cur) {
// Release the root element (and its descendants).
Entry* next = cur->mNext;
delete cur;
cur = next;
}
mTop = nullptr;
mDepth = 0;
}
void XULContentSinkImpl::ContextStack::Traverse(
nsCycleCollectionTraversalCallback& aCb) {
nsCycleCollectionTraversalCallback& cb = aCb;
for (ContextStack::Entry* tmp = mTop; tmp; tmp = tmp->mNext) {
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNode)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mChildren)
}
}
//----------------------------------------------------------------------
XULContentSinkImpl::XULContentSinkImpl()
: mText(nullptr),
mTextLength(0),
mTextSize(0),
mConstrainSize(true),
mState(eInProlog) {}
XULContentSinkImpl::~XULContentSinkImpl() {
// The context stack _should_ be empty, unless something has gone wrong.
NS_ASSERTION(mContextStack.Depth() == 0, "Context stack not empty?");
mContextStack.Clear();
free(mText);
}
//----------------------------------------------------------------------
// nsISupports interface
NS_IMPL_CYCLE_COLLECTION_CLASS(XULContentSinkImpl)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(XULContentSinkImpl)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mNodeInfoManager)
tmp->mContextStack.Clear();
NS_IMPL_CYCLE_COLLECTION_UNLINK(mPrototype)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mParser)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(XULContentSinkImpl)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mNodeInfoManager)
tmp->mContextStack.Traverse(cb);
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPrototype)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParser)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULContentSinkImpl)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXMLContentSink)
NS_INTERFACE_MAP_ENTRY(nsIXMLContentSink)
NS_INTERFACE_MAP_ENTRY(nsIExpatSink)
NS_INTERFACE_MAP_ENTRY(nsIContentSink)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(XULContentSinkImpl)
NS_IMPL_CYCLE_COLLECTING_RELEASE(XULContentSinkImpl)
//----------------------------------------------------------------------
// nsIContentSink interface
NS_IMETHODIMP
XULContentSinkImpl::WillBuildModel(nsDTDMode aDTDMode) {
#if FIXME
if (!mParentContentSink) {
// If we're _not_ an overlay, then notify the document that
// the load is beginning.
mDocument->BeginLoad();
}
#endif
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::DidBuildModel(bool aTerminated) {
nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
if (doc) {
mPrototype->NotifyLoadDone();
mDocument = nullptr;
}
// Drop our reference to the parser to get rid of a circular
// reference.
mParser = nullptr;
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::WillInterrupt(void) {
// XXX Notify the docshell, if necessary
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::WillResume(void) {
// XXX Notify the docshell, if necessary
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::SetParser(nsParserBase* aParser) {
mParser = aParser;
return NS_OK;
}
void XULContentSinkImpl::SetDocumentCharset(
NotNull<const Encoding*> aEncoding) {
nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
if (doc) {
doc->SetDocumentCharacterSet(aEncoding);
}
}
nsISupports* XULContentSinkImpl::GetTarget() {
nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
return ToSupports(doc);
}
//----------------------------------------------------------------------
nsresult XULContentSinkImpl::Init(Document* aDocument,
nsXULPrototypeDocument* aPrototype) {
MOZ_ASSERT(aDocument != nullptr, "null ptr");
if (!aDocument) return NS_ERROR_NULL_POINTER;
mDocument = do_GetWeakReference(aDocument);
mPrototype = aPrototype;
mDocumentURL = mPrototype->GetURI();
mNodeInfoManager = aPrototype->GetNodeInfoManager();
if (!mNodeInfoManager) return NS_ERROR_UNEXPECTED;
mState = eInProlog;
return NS_OK;
}
//----------------------------------------------------------------------
//
// Text buffering
//
bool XULContentSinkImpl::IsDataInBuffer(char16_t* buffer, int32_t length) {
for (int32_t i = 0; i < length; ++i) {
if (buffer[i] == ' ' || buffer[i] == '\t' || buffer[i] == '\n' ||
buffer[i] == '\r')
continue;
return true;
}
return false;
}
nsresult XULContentSinkImpl::FlushText(bool aCreateTextNode) {
nsresult rv;
do {
// Don't do anything if there's no text to create a node from, or
// if they've told us not to create a text node
if (!mTextLength) break;
if (!aCreateTextNode) break;
RefPtr<nsXULPrototypeNode> node;
rv = mContextStack.GetTopNode(node);
if (NS_FAILED(rv)) return rv;
bool stripWhitespace = false;
if (node->mType == nsXULPrototypeNode::eType_Element) {
mozilla::dom::NodeInfo* nodeInfo =
static_cast<nsXULPrototypeElement*>(node.get())->mNodeInfo;
if (nodeInfo->NamespaceEquals(kNameSpaceID_XUL))
stripWhitespace = !nodeInfo->Equals(nsGkAtoms::label) &&
!nodeInfo->Equals(nsGkAtoms::description);
}
// Don't bother if there's nothing but whitespace.
if (stripWhitespace && !IsDataInBuffer(mText, mTextLength)) break;
// Don't bother if we're not in XUL document body
if (mState != eInDocumentElement || mContextStack.Depth() == 0) break;
nsXULPrototypeText* text = new nsXULPrototypeText();
text->mValue.Assign(mText, mTextLength);
if (stripWhitespace) text->mValue.Trim(" \t\n\r");
// hook it up
nsPrototypeArray* children = nullptr;
rv = mContextStack.GetTopChildren(&children);
if (NS_FAILED(rv)) return rv;
// transfer ownership of 'text' to the children array
children->AppendElement(text);
} while (0);
// Reset our text buffer
mTextLength = 0;
return NS_OK;
}
//----------------------------------------------------------------------
nsresult XULContentSinkImpl::NormalizeAttributeString(
const char16_t* aExpatName, nsAttrName& aName) {
int32_t nameSpaceID;
RefPtr<nsAtom> prefix, localName;
nsContentUtils::SplitExpatName(aExpatName, getter_AddRefs(prefix),
getter_AddRefs(localName), &nameSpaceID);
if (nameSpaceID == kNameSpaceID_None) {
aName.SetTo(localName);
return NS_OK;
}
RefPtr<mozilla::dom::NodeInfo> ni;
ni = mNodeInfoManager->GetNodeInfo(localName, prefix, nameSpaceID,
nsINode::ATTRIBUTE_NODE);
aName.SetTo(ni);
return NS_OK;
}
nsresult XULContentSinkImpl::CreateElement(mozilla::dom::NodeInfo* aNodeInfo,
nsXULPrototypeElement** aResult) {
nsXULPrototypeElement* element = new nsXULPrototypeElement();
element->mNodeInfo = aNodeInfo;
*aResult = element;
return NS_OK;
}
/**** BEGIN NEW APIs ****/
NS_IMETHODIMP
XULContentSinkImpl::HandleStartElement(const char16_t* aName,
const char16_t** aAtts,
uint32_t aAttsCount,
uint32_t aLineNumber,
uint32_t aColumnNumber) {
// XXX Hopefully the parser will flag this before we get here. If
// we're in the epilog, there should be no new elements
MOZ_ASSERT(mState != eInEpilog, "tag in XUL doc epilog");
MOZ_ASSERT(aAttsCount % 2 == 0, "incorrect aAttsCount");
// Adjust aAttsCount so it's the actual number of attributes
aAttsCount /= 2;
if (mState == eInEpilog) return NS_ERROR_UNEXPECTED;
if (mState != eInScript) {
FlushText();
}
int32_t nameSpaceID;
RefPtr<nsAtom> prefix, localName;
nsContentUtils::SplitExpatName(aName, getter_AddRefs(prefix),
getter_AddRefs(localName), &nameSpaceID);
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
nodeInfo = mNodeInfoManager->GetNodeInfo(localName, prefix, nameSpaceID,
nsINode::ELEMENT_NODE);
nsresult rv = NS_OK;
switch (mState) {
case eInProlog:
// We're the root document element
rv = OpenRoot(aAtts, aAttsCount, nodeInfo);
break;
case eInDocumentElement:
rv = OpenTag(aAtts, aAttsCount, aLineNumber, nodeInfo);
break;
case eInEpilog:
case eInScript:
MOZ_LOG(
gContentSinkLog, LogLevel::Warning,
("xul: warning: unexpected tags in epilog at line %d", aLineNumber));
rv = NS_ERROR_UNEXPECTED; // XXX
break;
}
return rv;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleEndElement(const char16_t* aName) {
// Never EVER return anything but NS_OK or
// NS_ERROR_HTMLPARSER_BLOCK from this method. Doing so will blow
// the parser's little mind all over the planet.
nsresult rv;
RefPtr<nsXULPrototypeNode> node;
rv = mContextStack.GetTopNode(node);
if (NS_FAILED(rv)) {
return NS_OK;
}
switch (node->mType) {
case nsXULPrototypeNode::eType_Element: {
// Flush any text _now_, so that we'll get text nodes created
// before popping the stack.
FlushText();
// Pop the context stack and do prototype hookup.
nsPrototypeArray* children = nullptr;
rv = mContextStack.GetTopChildren(&children);
if (NS_FAILED(rv)) return rv;
nsXULPrototypeElement* element =
static_cast<nsXULPrototypeElement*>(node.get());
int32_t count = children->Length();
if (count) {
element->mChildren.SetCapacity(count);
for (int32_t i = 0; i < count; ++i)
element->mChildren.AppendElement(children->ElementAt(i));
}
} break;
case nsXULPrototypeNode::eType_Script: {
nsXULPrototypeScript* script =
static_cast<nsXULPrototypeScript*>(node.get());
// If given a src= attribute, we must ignore script tag content.
if (!script->mSrcURI && !script->HasScriptObject()) {
nsCOMPtr<Document> doc = do_QueryReferent(mDocument);
script->mOutOfLine = false;
if (doc) {
script->Compile(mText, mTextLength, JS::SourceOwnership::Borrowed,
mDocumentURL, script->mLineNo, doc);
}
}
FlushText(false);
} break;
default:
NS_ERROR("didn't expect that");
break;
}
rv = mContextStack.Pop(&mState);
NS_ASSERTION(NS_SUCCEEDED(rv), "context stack corrupted");
if (NS_FAILED(rv)) return rv;
if (mContextStack.Depth() == 0) {
// The root element should -always- be an element, because
// it'll have been created via XULContentSinkImpl::OpenRoot().
NS_ASSERTION(node->mType == nsXULPrototypeNode::eType_Element,
"root is not an element");
if (node->mType != nsXULPrototypeNode::eType_Element)
return NS_ERROR_UNEXPECTED;
// Now that we're done parsing, set the prototype document's
// root element. This transfers ownership of the prototype
// element tree to the prototype document.
nsXULPrototypeElement* element =
static_cast<nsXULPrototypeElement*>(node.get());
mPrototype->SetRootElement(element);
mState = eInEpilog;
}
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleComment(const char16_t* aName) {
FlushText();
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleCDataSection(const char16_t* aData,
uint32_t aLength) {
FlushText();
return AddText(aData, aLength);
}
NS_IMETHODIMP
XULContentSinkImpl::HandleDoctypeDecl(const nsAString& aSubset,
const nsAString& aName,
const nsAString& aSystemId,
const nsAString& aPublicId,
nsISupports* aCatalogData) {
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleCharacterData(const char16_t* aData,
uint32_t aLength) {
if (aData && mState != eInProlog && mState != eInEpilog) {
return AddText(aData, aLength);
}
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleProcessingInstruction(const char16_t* aTarget,
const char16_t* aData) {
FlushText();
const nsDependentString target(aTarget);
const nsDependentString data(aData);
// Note: the created nsXULPrototypePI has mRefCnt == 1
RefPtr<nsXULPrototypePI> pi = new nsXULPrototypePI();
pi->mTarget = target;
pi->mData = data;
if (mState == eInProlog) {
// Note: passing in already addrefed pi
return mPrototype->AddProcessingInstruction(pi);
}
nsresult rv;
nsPrototypeArray* children = nullptr;
rv = mContextStack.GetTopChildren(&children);
if (NS_FAILED(rv)) {
return rv;
}
if (!children->AppendElement(pi)) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::HandleXMLDeclaration(const char16_t* aVersion,
const char16_t* aEncoding,
int32_t aStandalone) {
return NS_OK;
}
NS_IMETHODIMP
XULContentSinkImpl::ReportError(const char16_t* aErrorText,
const char16_t* aSourceText,
nsIScriptError* aError, bool* _retval) {
MOZ_ASSERT(aError && aSourceText && aErrorText, "Check arguments!!!");
// The expat driver should report the error.
*_retval = true;
nsresult rv = NS_OK;
// make sure to empty the context stack so that
// <parsererror> could become the root element.
mContextStack.Clear();
mState = eInProlog;
// Clear any buffered-up text we have. It's enough to set the length to 0.
// The buffer itself is allocated when we're created and deleted in our
// destructor, so don't mess with it.
mTextLength = 0;
// return leaving the document empty if we're asked to not add a <parsererror>
// root node
nsCOMPtr<Document> idoc = do_QueryReferent(mDocument);
if (idoc && idoc->SuppressParserErrorElement()) {
return NS_OK;
};
const char16_t* noAtts[] = {0, 0};
NS_NAMED_LITERAL_STRING(
errorNs, "http://www.mozilla.org/newlayout/xml/parsererror.xml");
nsAutoString parsererror(errorNs);
parsererror.Append((char16_t)0xFFFF);
parsererror.AppendLiteral("parsererror");
rv = HandleStartElement(parsererror.get(), noAtts, 0, 0, 0);
NS_ENSURE_SUCCESS(rv, rv);
rv = HandleCharacterData(aErrorText, NS_strlen(aErrorText));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString sourcetext(errorNs);
sourcetext.Append((char16_t)0xFFFF);
sourcetext.AppendLiteral("sourcetext");
rv = HandleStartElement(sourcetext.get(), noAtts, 0, 0, 0);
NS_ENSURE_SUCCESS(rv, rv);
rv = HandleCharacterData(aSourceText, NS_strlen(aSourceText));
NS_ENSURE_SUCCESS(rv, rv);
rv = HandleEndElement(sourcetext.get());
NS_ENSURE_SUCCESS(rv, rv);
rv = HandleEndElement(parsererror.get());
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
nsresult XULContentSinkImpl::OpenRoot(const char16_t** aAttributes,
const uint32_t aAttrLen,
mozilla::dom::NodeInfo* aNodeInfo) {
NS_ASSERTION(mState == eInProlog, "how'd we get here?");
if (mState != eInProlog) return NS_ERROR_UNEXPECTED;
nsresult rv;
if (aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XHTML) ||
aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XUL)) {
MOZ_LOG(gContentSinkLog, LogLevel::Error,
("xul: script tag not allowed as root content element"));
return NS_ERROR_UNEXPECTED;
}
// Create the element
nsXULPrototypeElement* element;
rv = CreateElement(aNodeInfo, &element);
if (NS_FAILED(rv)) {
if (MOZ_LOG_TEST(gContentSinkLog, LogLevel::Error)) {
nsAutoString anodeC;
aNodeInfo->GetName(anodeC);
MOZ_LOG(gContentSinkLog, LogLevel::Error,
("xul: unable to create element '%s' at line %d",
NS_ConvertUTF16toUTF8(anodeC).get(),
-1)); // XXX pass in line number
}
return rv;
}
// Push the element onto the context stack, so that child
// containers will hook up to us as their parent.
rv = mContextStack.Push(element, mState);
if (NS_FAILED(rv)) {
element->Release();
return rv;
}
// Add the attributes
rv = AddAttributes(aAttributes, aAttrLen, element);
if (NS_FAILED(rv)) return rv;
mState = eInDocumentElement;
return NS_OK;
}
nsresult XULContentSinkImpl::OpenTag(const char16_t** aAttributes,
const uint32_t aAttrLen,
const uint32_t aLineNumber,
mozilla::dom::NodeInfo* aNodeInfo) {
nsresult rv;
// Create the element
nsXULPrototypeElement* element;
rv = CreateElement(aNodeInfo, &element);
if (NS_FAILED(rv)) {
if (MOZ_LOG_TEST(gContentSinkLog, LogLevel::Error)) {
nsAutoString anodeC;
aNodeInfo->GetName(anodeC);
MOZ_LOG(gContentSinkLog, LogLevel::Error,
("xul: unable to create element '%s' at line %d",
NS_ConvertUTF16toUTF8(anodeC).get(), aLineNumber));
}
return rv;
}
// Link this element to its parent.
nsPrototypeArray* children = nullptr;
rv = mContextStack.GetTopChildren(&children);
if (NS_FAILED(rv)) {
delete element;
return rv;
}
// Add the attributes
rv = AddAttributes(aAttributes, aAttrLen, element);
if (NS_FAILED(rv)) return rv;
children->AppendElement(element);
if (aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XHTML) ||
aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XUL)) {
// Do scripty things now
rv = OpenScript(aAttributes, aLineNumber);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(mState == eInScript || mState == eInDocumentElement,
"Unexpected state");
if (mState == eInScript) {
// OpenScript has pushed the nsPrototypeScriptElement onto the
// stack, so we're done.
return NS_OK;
}
}
// Push the element onto the context stack, so that child
// containers will hook up to us as their parent.
rv = mContextStack.Push(element, mState);
if (NS_FAILED(rv)) return rv;
mState = eInDocumentElement;
return NS_OK;
}
nsresult XULContentSinkImpl::OpenScript(const char16_t** aAttributes,
const uint32_t aLineNumber) {
bool isJavaScript = true;
nsresult rv;
// Look for SRC attribute and look for a LANGUAGE attribute
nsAutoString src;
while (*aAttributes) {
const nsDependentString key(aAttributes[0]);
if (key.EqualsLiteral("src")) {
src.Assign(aAttributes[1]);
} else if (key.EqualsLiteral("type")) {
nsDependentString str(aAttributes[1]);
nsContentTypeParser parser(str);
nsAutoString mimeType;
rv = parser.GetType(mimeType);
if (NS_FAILED(rv)) {
if (rv == NS_ERROR_INVALID_ARG) {
// Fail immediately rather than checking if later things
// are okay.
return NS_OK;
}
// We do want the warning here
NS_ENSURE_SUCCESS(rv, rv);
}
if (nsContentUtils::IsJavascriptMIMEType(mimeType)) {
isJavaScript = true;
// Get the version string, and ensure that JavaScript supports it.
nsAutoString versionName;
rv = parser.GetParameter("version", versionName);
if (NS_SUCCEEDED(rv)) {
nsContentUtils::ReportToConsoleNonLocalized(
NS_LITERAL_STRING(
"Versioned JavaScripts are no longer supported. "
"Please remove the version parameter."),
nsIScriptError::errorFlag, NS_LITERAL_CSTRING("XUL Document"),
nullptr, mDocumentURL, EmptyString(), aLineNumber);
isJavaScript = false;
} else if (rv != NS_ERROR_INVALID_ARG) {
return rv;
}
} else {
isJavaScript = false;
}
} else if (key.EqualsLiteral("language")) {
// Language is deprecated, and the impl in ScriptLoader ignores the
// various version strings anyway. So we make no attempt to support
// languages other than JS for language=
nsAutoString lang(aAttributes[1]);
if (nsContentUtils::IsJavaScriptLanguage(lang)) {
isJavaScript = true;
}
}
aAttributes += 2;
}
// Don't process scripts that aren't JavaScript.
if (!isJavaScript) {
return NS_OK;
}
nsCOMPtr<Document> doc(do_QueryReferent(mDocument));
nsCOMPtr<nsIScriptGlobalObject> globalObject;
if (doc) globalObject = do_QueryInterface(doc->GetWindow());
RefPtr<nsXULPrototypeScript> script = new nsXULPrototypeScript(aLineNumber);
// If there is a SRC attribute...
if (!src.IsEmpty()) {
// Use the SRC attribute value to load the URL
rv = NS_NewURI(getter_AddRefs(script->mSrcURI), src, nullptr, mDocumentURL);
// Check if this document is allowed to load a script from this source
// NOTE: if we ever allow scripts added via the DOM to run, we need to
// add a CheckLoadURI call for that as well.
if (NS_SUCCEEDED(rv)) {
if (!mSecMan)
mSecMan = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
nsCOMPtr<Document> doc = do_QueryReferent(mDocument, &rv);
if (NS_SUCCEEDED(rv)) {
rv = mSecMan->CheckLoadURIWithPrincipal(
doc->NodePrincipal(), script->mSrcURI,
nsIScriptSecurityManager::ALLOW_CHROME);
}
}
}
if (NS_FAILED(rv)) {
return rv;
}
// Attempt to deserialize an out-of-line script from the FastLoad
// file right away. Otherwise we'll end up reloading the script and
// corrupting the FastLoad file trying to serialize it, in the case
// where it's already there.
script->DeserializeOutOfLine(nullptr, mPrototype);
}
nsPrototypeArray* children = nullptr;
rv = mContextStack.GetTopChildren(&children);
if (NS_FAILED(rv)) {
return rv;
}
children->AppendElement(script);
mConstrainSize = false;
mContextStack.Push(script, mState);
mState = eInScript;
return NS_OK;
}
nsresult XULContentSinkImpl::AddAttributes(const char16_t** aAttributes,
const uint32_t aAttrLen,
nsXULPrototypeElement* aElement) {
// Add tag attributes to the element
nsresult rv;
// Create storage for the attributes
nsXULPrototypeAttribute* attrs = nullptr;
if (aAttrLen > 0) {
attrs = new nsXULPrototypeAttribute[aAttrLen];
}
aElement->mAttributes = attrs;
aElement->mNumAttributes = aAttrLen;
// Copy the attributes into the prototype
uint32_t i;
for (i = 0; i < aAttrLen; ++i) {
rv = NormalizeAttributeString(aAttributes[i * 2], attrs[i].mName);
NS_ENSURE_SUCCESS(rv, rv);
rv = aElement->SetAttrAt(i, nsDependentString(aAttributes[i * 2 + 1]),
mDocumentURL);
NS_ENSURE_SUCCESS(rv, rv);
if (MOZ_LOG_TEST(gContentSinkLog, LogLevel::Debug)) {
nsAutoString extraWhiteSpace;
int32_t cnt = mContextStack.Depth();
while (--cnt >= 0) extraWhiteSpace.AppendLiteral(" ");
nsAutoString qnameC, valueC;
qnameC.Assign(aAttributes[0]);
valueC.Assign(aAttributes[1]);
MOZ_LOG(gContentSinkLog, LogLevel::Debug,
("xul: %.5d. %s %s=%s",
-1, // XXX pass in line number
NS_ConvertUTF16toUTF8(extraWhiteSpace).get(),
NS_ConvertUTF16toUTF8(qnameC).get(),
NS_ConvertUTF16toUTF8(valueC).get()));
}
}
return NS_OK;
}
nsresult XULContentSinkImpl::AddText(const char16_t* aText, int32_t aLength) {
// Create buffer when we first need it
if (0 == mTextSize) {
mText = (char16_t*)malloc(sizeof(char16_t) * 4096);
if (nullptr == mText) {
return NS_ERROR_OUT_OF_MEMORY;
}
mTextSize = 4096;
}
// Copy data from string into our buffer; flush buffer when it fills up
int32_t offset = 0;
while (0 != aLength) {
int32_t amount = mTextSize - mTextLength;
if (amount > aLength) {
amount = aLength;
}
if (0 == amount) {
if (mConstrainSize) {
nsresult rv = FlushText();
if (NS_OK != rv) {
return rv;
}
} else {
CheckedInt32 size = mTextSize;
size += aLength;
if (!size.isValid()) {
return NS_ERROR_OUT_OF_MEMORY;
}
mTextSize = size.value();
mText = (char16_t*)realloc(mText, sizeof(char16_t) * mTextSize);
if (nullptr == mText) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
}
memcpy(&mText[mTextLength], aText + offset, sizeof(char16_t) * amount);
mTextLength += amount;
offset += amount;
aLength -= amount;
}
return NS_OK;
}
Reference in New Issue View Git Blame Copy Permalink