forked from mirrors/gecko-dev
224 lines
7.8 KiB
C++
224 lines
7.8 KiB
C++
/* -*- 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/. */
|
|
|
|
#ifndef nsXMLContentSink_h__
|
|
#define nsXMLContentSink_h__
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "nsContentSink.h"
|
|
#include "nsIXMLContentSink.h"
|
|
#include "nsIExpatSink.h"
|
|
#include "nsIDocumentTransformer.h"
|
|
#include "nsTArray.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsCRT.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsIDTD.h"
|
|
#include "mozilla/dom/FromParser.h"
|
|
|
|
class nsIDocument;
|
|
class nsIURI;
|
|
class nsIContent;
|
|
class nsIParser;
|
|
class nsTextNode;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
class NodeInfo;
|
|
class ProcessingInstruction;
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
typedef enum {
|
|
eXMLContentSinkState_InProlog,
|
|
eXMLContentSinkState_InDocumentElement,
|
|
eXMLContentSinkState_InEpilog
|
|
} XMLContentSinkState;
|
|
|
|
struct StackNode {
|
|
nsCOMPtr<nsIContent> mContent;
|
|
uint32_t mNumFlushed;
|
|
};
|
|
|
|
class nsXMLContentSink : public nsContentSink,
|
|
public nsIXMLContentSink,
|
|
public nsITransformObserver,
|
|
public nsIExpatSink
|
|
{
|
|
public:
|
|
nsXMLContentSink();
|
|
|
|
nsresult Init(nsIDocument* aDoc,
|
|
nsIURI* aURL,
|
|
nsISupports* aContainer,
|
|
nsIChannel* aChannel);
|
|
|
|
// nsISupports
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED_NO_UNLINK(nsXMLContentSink,
|
|
nsContentSink)
|
|
|
|
NS_DECL_NSIEXPATSINK
|
|
|
|
// nsIContentSink
|
|
NS_IMETHOD WillParse(void) override;
|
|
NS_IMETHOD WillBuildModel(nsDTDMode aDTDMode) override;
|
|
NS_IMETHOD DidBuildModel(bool aTerminated) override;
|
|
NS_IMETHOD WillInterrupt(void) override;
|
|
NS_IMETHOD WillResume(void) override;
|
|
NS_IMETHOD SetParser(nsParserBase* aParser) override;
|
|
virtual void FlushPendingNotifications(mozilla::FlushType aType) override;
|
|
virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding) override;
|
|
virtual nsISupports *GetTarget() override;
|
|
virtual bool IsScriptExecuting() override;
|
|
virtual void ContinueInterruptedParsingAsync() override;
|
|
|
|
// nsITransformObserver
|
|
NS_IMETHOD OnDocumentCreated(nsIDocument *aResultDocument) override;
|
|
NS_IMETHOD OnTransformDone(nsresult aResult, nsIDocument *aResultDocument) override;
|
|
|
|
// nsICSSLoaderObserver
|
|
NS_IMETHOD StyleSheetLoaded(mozilla::StyleSheet* aSheet,
|
|
bool aWasAlternate,
|
|
nsresult aStatus) override;
|
|
static bool ParsePIData(const nsString &aData, nsString &aHref,
|
|
nsString &aTitle, nsString &aMedia,
|
|
bool &aIsAlternate);
|
|
|
|
protected:
|
|
virtual ~nsXMLContentSink();
|
|
|
|
nsIParser* GetParser();
|
|
|
|
void ContinueInterruptedParsingIfEnabled();
|
|
|
|
// Start layout. If aIgnorePendingSheets is true, this will happen even if
|
|
// we still have stylesheet loads pending. Otherwise, we'll wait until the
|
|
// stylesheets are all done loading.
|
|
virtual void MaybeStartLayout(bool aIgnorePendingSheets);
|
|
|
|
virtual nsresult AddAttributes(const char16_t** aNode, Element* aElement);
|
|
nsresult AddText(const char16_t* aString, int32_t aLength);
|
|
|
|
virtual bool OnOpenContainer(const char16_t **aAtts,
|
|
uint32_t aAttsCount,
|
|
int32_t aNameSpaceID,
|
|
nsAtom* aTagName,
|
|
uint32_t aLineNumber) { return true; }
|
|
// Set the given content as the root element for the created document
|
|
// don't set if root element was already set.
|
|
// return TRUE if this call set the root element
|
|
virtual bool SetDocElement(int32_t aNameSpaceID,
|
|
nsAtom *aTagName,
|
|
nsIContent *aContent);
|
|
virtual bool NotifyForDocElement() { return true; }
|
|
virtual nsresult CreateElement(const char16_t** aAtts, uint32_t aAttsCount,
|
|
mozilla::dom::NodeInfo* aNodeInfo,
|
|
uint32_t aLineNumber, uint32_t aColumnNumber,
|
|
nsIContent** aResult, bool* aAppendContent,
|
|
mozilla::dom::FromParser aFromParser);
|
|
|
|
// aParent is allowed to be null here if this is the root content
|
|
// being closed
|
|
virtual nsresult CloseElement(nsIContent* aContent);
|
|
|
|
virtual nsresult FlushText(bool aReleaseTextNode = true);
|
|
|
|
nsresult AddContentAsLeaf(nsIContent *aContent);
|
|
|
|
nsIContent* GetCurrentContent();
|
|
StackNode* GetCurrentStackNode();
|
|
nsresult PushContent(nsIContent *aContent);
|
|
void PopContent();
|
|
bool HaveNotifiedForCurrentContent() const;
|
|
|
|
nsresult FlushTags() override;
|
|
|
|
void UpdateChildCounts() override;
|
|
|
|
void DidAddContent()
|
|
{
|
|
if (!mXSLTProcessor && IsTimeToNotify()) {
|
|
FlushTags();
|
|
}
|
|
}
|
|
|
|
// nsContentSink override
|
|
virtual nsresult ProcessStyleLinkFromHeader(
|
|
const nsAString& aHref,
|
|
bool aAlternate,
|
|
const nsAString& aTitle,
|
|
const nsAString& aType,
|
|
const nsAString& aMedia,
|
|
const nsAString& aReferrerPolicy) override;
|
|
|
|
// Try to handle an XSLT style link. If NS_OK is returned and aWasXSLT is not
|
|
// null, *aWasXSLT will be set to whether we processed this link as XSLT.
|
|
//
|
|
// aProcessingInstruction can be null if this information comes from a Link
|
|
// header; otherwise it will be the xml-styleshset XML PI that the loading
|
|
// information comes from.
|
|
virtual nsresult MaybeProcessXSLTLink(
|
|
mozilla::dom::ProcessingInstruction* aProcessingInstruction,
|
|
const nsAString& aHref,
|
|
bool aAlternate,
|
|
const nsAString& aTitle,
|
|
const nsAString& aType,
|
|
const nsAString& aMedia,
|
|
const nsAString& aReferrerPolicy,
|
|
bool* aWasXSLT = nullptr);
|
|
|
|
nsresult LoadXSLStyleSheet(nsIURI* aUrl);
|
|
|
|
bool CanStillPrettyPrint();
|
|
|
|
nsresult MaybePrettyPrint();
|
|
|
|
bool IsMonolithicContainer(mozilla::dom::NodeInfo* aNodeInfo);
|
|
|
|
nsresult HandleStartElement(const char16_t *aName, const char16_t **aAtts,
|
|
uint32_t aAttsCount, uint32_t aLineNumber,
|
|
uint32_t aColumnNumber, bool aInterruptable);
|
|
nsresult HandleEndElement(const char16_t *aName, bool aInterruptable);
|
|
nsresult HandleCharacterData(const char16_t *aData, uint32_t aLength,
|
|
bool aInterruptable);
|
|
|
|
nsCOMPtr<nsIContent> mDocElement;
|
|
nsCOMPtr<nsIContent> mCurrentHead; // When set, we're in an XHTML <haed>
|
|
|
|
XMLContentSinkState mState;
|
|
|
|
// The length of the valid data in mText.
|
|
int32_t mTextLength;
|
|
|
|
int32_t mNotifyLevel;
|
|
RefPtr<nsTextNode> mLastTextNode;
|
|
|
|
uint8_t mPrettyPrintXML : 1;
|
|
uint8_t mPrettyPrintHasSpecialRoot : 1;
|
|
uint8_t mPrettyPrintHasFactoredElements : 1;
|
|
uint8_t mPrettyPrinting : 1; // True if we called PrettyPrint() and it
|
|
// decided we should in fact prettyprint.
|
|
// True to call prevent script execution in the fragment mode.
|
|
uint8_t mPreventScriptExecution : 1;
|
|
|
|
nsTArray<StackNode> mContentStack;
|
|
|
|
nsCOMPtr<nsIDocumentTransformer> mXSLTProcessor;
|
|
|
|
// Holds the children in the prolog until the root element is added, after which they're
|
|
// inserted in the document. However, if we're doing an XSLT transform this will
|
|
// actually hold all the children of the source document, until the transform is
|
|
// finished. After the transform is finished we'll just discard the children.
|
|
nsTArray<nsCOMPtr<nsIContent>> mDocumentChildren;
|
|
|
|
static const int NS_ACCUMULATION_BUFFER_SIZE = 4096;
|
|
// Our currently accumulated text that we have not flushed to a textnode yet.
|
|
char16_t mText[NS_ACCUMULATION_BUFFER_SIZE];
|
|
};
|
|
|
|
#endif // nsXMLContentSink_h__
|