mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 21:55:31 +00:00
1052 lines
29 KiB
C++
1052 lines
29 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* vim: set ts=8 sts=4 et sw=4 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 "nsForwardReference.h"
|
|
#include "nsHTMLStyleSheet.h"
|
|
#include "nsIContentSink.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIDOMEventListener.h"
|
|
#include "nsIDOMHTMLFormElement.h"
|
|
#include "nsIDOMXULDocument.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 "nsIXULDocument.h"
|
|
#include "nsIScriptSecurityManager.h"
|
|
#include "nsLayoutCID.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsRDFCID.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsXULElement.h"
|
|
#include "mozilla/Logging.h"
|
|
#include "prmem.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"
|
|
|
|
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;
|
|
entry->mNode = aNode;
|
|
entry->mState = aState;
|
|
entry->mNext = 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<nsIDocument> doc = do_QueryReferent(mDocument);
|
|
if (doc) {
|
|
doc->EndLoad();
|
|
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;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
XULContentSinkImpl::SetDocumentCharset(nsACString& aCharset)
|
|
{
|
|
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
|
|
if (doc) {
|
|
doc->SetDocumentCharacterSet(aCharset);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsISupports *
|
|
XULContentSinkImpl::GetTarget()
|
|
{
|
|
nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocument);
|
|
return doc;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsresult
|
|
XULContentSinkImpl::Init(nsIDocument* aDocument,
|
|
nsXULPrototypeDocument* aPrototype)
|
|
{
|
|
NS_PRECONDITION(aDocument != nullptr, "null ptr");
|
|
if (! aDocument)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
nsresult rv;
|
|
|
|
mDocument = do_GetWeakReference(aDocument);
|
|
mPrototype = aPrototype;
|
|
|
|
mDocumentURL = mPrototype->GetURI();
|
|
|
|
// XXX this presumes HTTP header info is already set in document
|
|
// XXX if it isn't we need to set it here...
|
|
// XXXbz not like GetHeaderData on the proto doc _does_ anything....
|
|
nsAutoString preferredStyle;
|
|
rv = mPrototype->GetHeaderData(nsGkAtoms::headerDefaultStyle,
|
|
preferredStyle);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
if (!preferredStyle.IsEmpty()) {
|
|
aDocument->SetHeaderData(nsGkAtoms::headerDefaultStyle,
|
|
preferredStyle);
|
|
}
|
|
|
|
// Set the right preferred style on the document's CSSLoader.
|
|
aDocument->CSSLoader()->SetPreferredSheet(preferredStyle);
|
|
|
|
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;
|
|
nsCOMPtr<nsIAtom> 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,
|
|
nsIDOMNode::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)
|
|
{
|
|
// XXX Hopefully the parser will flag this before we get here. If
|
|
// we're in the epilog, there should be no new elements
|
|
NS_PRECONDITION(mState != eInEpilog, "tag in XUL doc epilog");
|
|
NS_PRECONDITION(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;
|
|
nsCOMPtr<nsIAtom> prefix, localName;
|
|
nsContentUtils::SplitExpatName(aName, getter_AddRefs(prefix),
|
|
getter_AddRefs(localName), &nameSpaceID);
|
|
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
|
|
nodeInfo = mNodeInfoManager->GetNodeInfo(localName, prefix, nameSpaceID,
|
|
nsIDOMNode::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<nsIDocument> doc = do_QueryReferent(mDocument);
|
|
|
|
script->mOutOfLine = false;
|
|
if (doc)
|
|
script->Compile(mText, mTextLength, 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)
|
|
{
|
|
NS_PRECONDITION(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<nsIDocument> idoc = do_QueryReferent(mDocument);
|
|
if (idoc && idoc->SuppressParserErrorElement()) {
|
|
return NS_OK;
|
|
};
|
|
|
|
nsCOMPtr<nsIXULDocument> doc = do_QueryReferent(mDocument);
|
|
if (doc && !doc->OnDocumentParserError()) {
|
|
// The overlay was broken. Don't add a messy element to the master doc.
|
|
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);
|
|
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);
|
|
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;
|
|
uint32_t version = JSVERSION_LATEST;
|
|
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;
|
|
version = JSVERSION_LATEST;
|
|
|
|
// Get the version string, and ensure that JavaScript supports it.
|
|
nsAutoString versionName;
|
|
rv = parser.GetParameter("version", versionName);
|
|
|
|
if (NS_SUCCEEDED(rv)) {
|
|
version = nsContentUtils::ParseJavascriptVersion(versionName);
|
|
} else if (rv != NS_ERROR_INVALID_ARG) {
|
|
return rv;
|
|
}
|
|
} else {
|
|
isJavaScript = false;
|
|
}
|
|
} else if (key.EqualsLiteral("language")) {
|
|
// Language is deprecated, and the impl in nsScriptLoader 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;
|
|
version = JSVERSION_DEFAULT;
|
|
}
|
|
}
|
|
aAttributes += 2;
|
|
}
|
|
|
|
// Don't process scripts that aren't JavaScript.
|
|
if (!isJavaScript) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsCOMPtr<nsIDocument> doc(do_QueryReferent(mDocument));
|
|
nsCOMPtr<nsIScriptGlobalObject> globalObject;
|
|
if (doc)
|
|
globalObject = do_QueryInterface(doc->GetWindow());
|
|
RefPtr<nsXULPrototypeScript> script =
|
|
new nsXULPrototypeScript(aLineNumber, version);
|
|
|
|
// 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<nsIDocument> 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;
|
|
}
|