CTTE: Thread references through markup.h
authorweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 6 Oct 2013 19:18:54 +0000 (19:18 +0000)
committerweinig@apple.com <weinig@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 6 Oct 2013 19:18:54 +0000 (19:18 +0000)
https://bugs.webkit.org/show_bug.cgi?id=122403

Reviewed by Darin Adler and Andreas Kling.

Source/WebCore:

Highlights:
- Removed createFragmentFromMarkupWithContext(), it was unused.
- Moved createFragmentFromNodes() into its one caller (in WebKit/mac)
- Add a bunch more toFoo() overloads.

Source/WebKit/mac:

* DOM/WebDOMOperations.mm:
(-[DOMNode markupString]):
(-[DOMRange markupString]):
* WebView/WebFrame.mm:
(-[WebFrame _documentFragmentWithMarkupString:baseURLString:]):
(-[WebFrame _documentFragmentWithNodesAsParagraphs:]):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@157002 268f45cc-cd09-0410-ab3c-d52691b4dbfc

47 files changed:
Source/WebCore/ChangeLog
Source/WebCore/WebCore.exp.in
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/bindings/objc/DOMHTML.mm
Source/WebCore/dom/CDATASection.h
Source/WebCore/dom/Comment.h
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Document.h
Source/WebCore/dom/DocumentType.h
Source/WebCore/dom/Node.h
Source/WebCore/dom/ProcessingInstruction.h
Source/WebCore/dom/Range.cpp
Source/WebCore/dom/ShadowRoot.cpp
Source/WebCore/dom/StyledElement.h
Source/WebCore/dom/Text.h
Source/WebCore/editing/CompositeEditCommand.cpp
Source/WebCore/editing/EditorCommand.cpp
Source/WebCore/editing/MarkupAccumulator.cpp
Source/WebCore/editing/MarkupAccumulator.h
Source/WebCore/editing/ios/EditorIOS.mm
Source/WebCore/editing/mac/EditorMac.mm
Source/WebCore/editing/markup.cpp
Source/WebCore/editing/markup.h
Source/WebCore/html/HTMLElement.cpp
Source/WebCore/html/HTMLFrameOwnerElement.h
Source/WebCore/html/HTMLTemplateElement.cpp
Source/WebCore/html/HTMLTemplateElement.h
Source/WebCore/inspector/DOMEditor.cpp
Source/WebCore/inspector/DOMEditor.h
Source/WebCore/inspector/DOMPatchSupport.cpp
Source/WebCore/inspector/DOMPatchSupport.h
Source/WebCore/inspector/InspectorDOMAgent.cpp
Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp
Source/WebCore/page/ContextMenuController.cpp
Source/WebCore/page/PageSerializer.cpp
Source/WebCore/platform/gtk/DataObjectGtk.cpp
Source/WebCore/platform/gtk/DragDataGtk.cpp
Source/WebCore/platform/gtk/PasteboardGtk.cpp
Source/WebCore/platform/ios/PasteboardIOS.mm
Source/WebCore/xml/XMLHttpRequest.cpp
Source/WebCore/xml/XMLSerializer.cpp
Source/WebCore/xml/XSLTProcessor.cpp
Source/WebCore/xml/XSLTProcessor.h
Source/WebCore/xml/XSLTProcessorLibxslt.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/DOM/WebDOMOperations.mm
Source/WebKit/mac/WebView/WebFrame.mm

index d18970e..7c4ff9b 100644 (file)
@@ -1,3 +1,15 @@
+2013-10-05  Sam Weinig  <sam@webkit.org>
+
+        CTTE: Thread references through markup.h
+        https://bugs.webkit.org/show_bug.cgi?id=122403
+
+        Reviewed by Darin Adler and Andreas Kling.
+
+        Highlights:
+        - Removed createFragmentFromMarkupWithContext(), it was unused.
+        - Moved createFragmentFromNodes() into its one caller (in WebKit/mac)
+        - Add a bunch more toFoo() overloads.
+
 2013-10-06  Zan Dobersek  <zdobersek@igalia.com>
 
         [WebIDL] Annotate IDL interfaces under Source/WebCore/Modules/ with the OperationsNotDeletable attribute
index 9ad714e..b59d38f 100644 (file)
@@ -232,7 +232,6 @@ __ZN7WebCore12TextIteratorC1EPKNS_5RangeENS_20TextIteratorBehaviorE
 __ZN7WebCore12TextIteratorD1Ev
 __ZN7WebCore12UTF8EncodingEv
 __ZN7WebCore12cacheStorageEv
-__ZN7WebCore12createMarkupEPKNS_5RangeEPN3WTF6VectorIPNS_4NodeELm0ENS3_15CrashOnOverflowEEENS_23EAnnotateForInterchangeEbNS_13EAbsoluteURLsE
 __ZN7WebCore12deleteCookieERKNS_21NetworkStorageSessionERKNS_3URLERKN3WTF6StringE
 __ZN7WebCore12gcControllerEv
 __ZN7WebCore12iconDatabaseEv
@@ -580,8 +579,8 @@ __ZN7WebCore16VisibleSelection22expandUsingGranularityENS_15TextGranularityE
 __ZN7WebCore16VisibleSelectionC1EPKNS_5RangeENS_9EAffinityEb
 __ZN7WebCore16VisibleSelectionC1ERKNS_15VisiblePositionES3_b
 __ZN7WebCore16VisibleSelectionC1ERKNS_15VisiblePositionEb
-__ZN7WebCore16createFullMarkupEPKNS_4NodeE
-__ZN7WebCore16createFullMarkupEPKNS_5RangeE
+__ZN7WebCore16createFullMarkupERKNS_4NodeE
+__ZN7WebCore16createFullMarkupERKNS_5RangeE
 __ZN7WebCore16deleteAllCookiesERKNS_21NetworkStorageSessionE
 __ZN7WebCore16enclosingIntRectERK6CGRect
 __ZN7WebCore16enclosingIntRectERKNS_9FloatRectE
@@ -764,7 +763,6 @@ __ZN7WebCore23AuthenticationChallengeC1ERKNS_15ProtectionSpaceERKNS_10Credential
 __ZN7WebCore23MutableStylePropertySet25ensureCSSStyleDeclarationEv
 __ZN7WebCore23MutableStylePropertySetD1Ev
 __ZN7WebCore23SynchronousLoaderClient24platformBadResponseErrorEv
-__ZN7WebCore23createFragmentFromNodesEPNS_8DocumentERKN3WTF6VectorIPNS_4NodeELm0ENS2_15CrashOnOverflowEEE
 __ZN7WebCore23dataForURLComponentTypeEP5NSURLl
 __ZN7WebCore23decodeHostNameWithRangeEP8NSString8_NSRange
 __ZN7WebCore23encodeHostNameWithRangeEP8NSString8_NSRange
@@ -780,7 +778,7 @@ __ZN7WebCore24FrameDestructionObserver14frameDestroyedEv
 __ZN7WebCore24FrameDestructionObserver14willDetachPageEv
 __ZN7WebCore24FrameDestructionObserverC2EPNS_5FrameE
 __ZN7WebCore24FrameDestructionObserverD2Ev
-__ZN7WebCore24createFragmentFromMarkupEPNS_8DocumentERKN3WTF6StringES5_NS_19ParserContentPolicyE
+__ZN7WebCore24createFragmentFromMarkupERNS_8DocumentERKN3WTF6StringES5_NS_19ParserContentPolicyE
 __ZN7WebCore24decodeURLEscapeSequencesERKN3WTF6StringE
 __ZN7WebCore24deleteCookiesForHostnameERKNS_21NetworkStorageSessionERKN3WTF6StringE
 __ZN7WebCore24fileSystemRepresentationERKN3WTF6StringE
@@ -810,6 +808,7 @@ __ZN7WebCore28DocumentStyleSheetCollection14addAuthorSheetEN3WTF10PassRefPtrINS_
 __ZN7WebCore28encodeWithURLEscapeSequencesERKN3WTF6StringE
 __ZN7WebCore28removeLanguageChangeObserverEPv
 __ZN7WebCore29cookieRequestHeaderFieldValueERKNS_21NetworkStorageSessionERKNS_3URLES5_
+__ZN7WebCore29createDefaultParagraphElementERNS_8DocumentE
 __ZN7WebCore29isCharacterSmartReplaceExemptEib
 __ZN7WebCore30hostNameNeedsDecodingWithRangeEP8NSString8_NSRange
 __ZN7WebCore30hostNameNeedsEncodingWithRangeEP8NSString8_NSRange
index 99ac692..021fa6a 100644 (file)
                1C11CCC80AA6093700DADB20 /* DOMHTMLElement.h in Copy Generated Headers */ = {isa = PBXBuildFile; fileRef = 85DF2EEB0AA387CB00AD64C5 /* DOMHTMLElement.h */; };
                1C26497A0D7E248A00BD10F2 /* DocumentLoaderMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C2649790D7E248A00BD10F2 /* DocumentLoaderMac.cpp */; };
                1C26497C0D7E24EC00BD10F2 /* PageMac.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C26497B0D7E24EC00BD10F2 /* PageMac.cpp */; };
-               1C4C8F020AD85D87009475CE /* DeleteButtonController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C4C8F000AD85D87009475CE /* DeleteButtonController.h */; };
+               1C4C8F020AD85D87009475CE /* DeleteButtonController.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C4C8F000AD85D87009475CE /* DeleteButtonController.h */; settings = {ATTRIBUTES = (Private, ); }; };
                1C4C8F660AD8655D009475CE /* DeleteButton.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C4C8F640AD8655D009475CE /* DeleteButton.h */; };
                1C5FAED10DCFD90100D58F78 /* JSJavaScriptCallFrame.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 1C5FAECF0DCFD90100D58F78 /* JSJavaScriptCallFrame.cpp */; };
                1C5FAED20DCFD90100D58F78 /* JSJavaScriptCallFrame.h in Headers */ = {isa = PBXBuildFile; fileRef = 1C5FAED00DCFD90100D58F78 /* JSJavaScriptCallFrame.h */; };
index 65b8a81..d2eea4b 100644 (file)
@@ -56,7 +56,7 @@
 
 - (DOMDocumentFragment *)createDocumentFragmentWithMarkupString:(NSString *)markupString baseURL:(NSURL *)baseURL
 {
-    return kit(createFragmentFromMarkup(core(self), markupString, [baseURL absoluteString]).get());
+    return kit(createFragmentFromMarkup(*core(self), markupString, [baseURL absoluteString]).get());
 }
 
 - (DOMDocumentFragment *)createDocumentFragmentWithText:(NSString *)text
index a064c4f..3fac16f 100644 (file)
@@ -41,6 +41,13 @@ private:
     virtual PassRefPtr<Text> virtualCreate(const String&);
 };
 
+inline bool isCDATASection(const Node& node)
+{
+    return node.nodeType() == Node::CDATA_SECTION_NODE;
+}
+
+NODE_TYPE_CASTS(CDATASection)
+
 } // namespace WebCore
 
 #endif // CDATASection_h
index 0747c3b..eef37b9 100644 (file)
@@ -27,7 +27,7 @@
 
 namespace WebCore {
 
-class Comment FINAL : public CharacterData {
+class Comment final : public CharacterData {
 public:
     static PassRefPtr<Comment> create(Document&, const String&);
 
@@ -40,6 +40,13 @@ private:
     virtual bool childTypeAllowed(NodeType) const;
 };
 
+inline bool isComment(const Node& node)
+{
+    return node.nodeType() == Node::COMMENT_NODE;
+}
+
+NODE_TYPE_CASTS(Comment)
+
 } // namespace WebCore
 
 #endif // Comment_h
index eec512b..b5f87be 100644 (file)
@@ -4267,7 +4267,7 @@ void Document::applyXSLTransform(ProcessingInstruction* pi)
     String resultMIMEType;
     String newSource;
     String resultEncoding;
-    if (!processor->transformToString(this, resultMIMEType, newSource, resultEncoding))
+    if (!processor->transformToString(*this, resultMIMEType, newSource, resultEncoding))
         return;
     // FIXME: If the transform failed we should probably report an error (like Mozilla does).
     Frame* ownerFrame = frame();
index 4f15968..5f8c665 100644 (file)
@@ -1595,33 +1595,6 @@ inline const Document* Document::templateDocument() const
 }
 #endif
 
-inline Document* toDocument(ScriptExecutionContext* scriptExecutionContext)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
-    return static_cast<Document*>(scriptExecutionContext);
-}
-
-inline const Document* toDocument(const ScriptExecutionContext* scriptExecutionContext)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
-    return static_cast<const Document*>(scriptExecutionContext);
-}
-
-inline Document* toDocument(Node* node)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isDocumentNode());
-    return static_cast<Document*>(node);
-}
-
-inline const Document* toDocument(const Node* node)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isDocumentNode());
-    return static_cast<const Document*>(node);
-}
-
-// This will catch anyone doing an unnecessary cast.
-void toDocument(const Document*);
-
 // Put these methods here, because they require the Document definition, but we really want to inline them.
 
 inline bool Node::isDocumentNode() const
@@ -1652,6 +1625,25 @@ inline ScriptExecutionContext* Node::scriptExecutionContext() const
 
 Element* eventTargetElementForDocument(Document*);
 
+inline Document* toDocument(ScriptExecutionContext* scriptExecutionContext)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
+    return static_cast<Document*>(scriptExecutionContext);
+}
+
+inline const Document* toDocument(const ScriptExecutionContext* scriptExecutionContext)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(!scriptExecutionContext || scriptExecutionContext->isDocument());
+    return static_cast<const Document*>(scriptExecutionContext);
+}
+
+inline bool isDocument(const Node& node)
+{
+    return node.isDocumentNode();
+}
+
+NODE_TYPE_CASTS(Document)
+
 } // namespace WebCore
 
 namespace WTF {
index 6501807..411a441 100644 (file)
@@ -63,6 +63,13 @@ private:
     String m_subset;
 };
 
+inline bool isDocumentType(const Node& node)
+{
+    return node.nodeType() == Node::DOCUMENT_TYPE_NODE;
+}
+
+NODE_TYPE_CASTS(DocumentType)
+
 } // namespace WebCore
 
 #endif
index cadf090..3455d42 100644 (file)
@@ -731,7 +731,31 @@ inline ContainerNode* Node::parentNodeGuaranteedHostFree() const
     return parentNode();
 }
 
-} //namespace
+#define NODE_TYPE_CASTS(NodeClassName) \
+inline const NodeClassName* to##NodeClassName(const Node* node) \
+{ \
+    ASSERT_WITH_SECURITY_IMPLICATION(!node || is##NodeClassName(*node)); \
+    return static_cast<const NodeClassName*>(node); \
+} \
+inline NodeClassName* to##NodeClassName(Node* node) \
+{ \
+    ASSERT_WITH_SECURITY_IMPLICATION(!node || is##NodeClassName(*node)); \
+    return static_cast<NodeClassName*>(node); \
+} \
+inline const NodeClassName& to##NodeClassName(const Node& node) \
+{ \
+    ASSERT_WITH_SECURITY_IMPLICATION(is##NodeClassName(node)); \
+    return static_cast<const NodeClassName&>(node); \
+} \
+inline NodeClassName& to##NodeClassName(Node& node) \
+{ \
+    ASSERT_WITH_SECURITY_IMPLICATION(is##NodeClassName(node)); \
+    return static_cast<NodeClassName&>(node); \
+} \
+void to##NodeClassName(const NodeClassName*); \
+void to##NodeClassName(const NodeClassName&);
+
+} // namespace WebCore
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
index 55a56b7..a816170 100644 (file)
@@ -32,7 +32,7 @@ namespace WebCore {
 class StyleSheet;
 class CSSStyleSheet;
 
-class ProcessingInstruction FINAL : public CharacterData, private CachedStyleSheetClient {
+class ProcessingInstruction final : public CharacterData, private CachedStyleSheetClient {
 public:
     static PassRefPtr<ProcessingInstruction> create(Document&, const String& target, const String& data);
     virtual ~ProcessingInstruction();
@@ -91,12 +91,13 @@ private:
 #endif
 };
 
-inline ProcessingInstruction* toProcessingInstruction(Node* node)
+inline bool isProcessingInstruction(const Node& node)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->nodeType() == Node::PROCESSING_INSTRUCTION_NODE);
-    return static_cast<ProcessingInstruction*>(node);
+    return node.nodeType() == Node::PROCESSING_INSTRUCTION_NODE;
 }
 
+NODE_TYPE_CASTS(ProcessingInstruction)
+
 } //namespace
 
 #endif
index 8ff177c..fda4166 100644 (file)
@@ -1083,7 +1083,7 @@ String Range::toString(ExceptionCode& ec) const
 
 String Range::toHTML() const
 {
-    return createMarkup(this);
+    return createMarkup(*this);
 }
 
 String Range::text() const
index 4a496fc..abf4685 100644 (file)
@@ -94,7 +94,7 @@ PassRefPtr<Node> ShadowRoot::cloneNode(bool, ExceptionCode& ec)
 
 String ShadowRoot::innerHTML() const
 {
-    return createMarkup(this, ChildrenOnly);
+    return createMarkup(*this, ChildrenOnly);
 }
 
 void ShadowRoot::setInnerHTML(const String& markup, ExceptionCode& ec)
index 18c6e99..c94a0c5 100644 (file)
@@ -105,6 +105,10 @@ inline const StylePropertySet* StyledElement::presentationAttributeStyle()
     return elementData()->presentationAttributeStyle();
 }
 
+inline bool isStyledElement(const Node& node) { return node.isStyledElement(); }
+
+ELEMENT_TYPE_CASTS(StyledElement)
+
 } //namespace
 
 #endif
index 67a2491..f4eba4b 100644 (file)
@@ -70,26 +70,12 @@ private:
 #endif
 };
 
-inline Text& toText(Node& node)
+inline bool isText(const Node& node)
 {
-    ASSERT_WITH_SECURITY_IMPLICATION(node.isTextNode());
-    return static_cast<Text&>(node);
+    return node.isTextNode();
 }
 
-inline Text* toText(Node* node)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isTextNode());
-    return static_cast<Text*>(node);
-}
-
-inline const Text* toText(const Node* node)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isTextNode());
-    return static_cast<const Text*>(node);
-}
-
-void toText(const Text&);
-void toText(const Text*);
+NODE_TYPE_CASTS(Text)
 
 } // namespace WebCore
 
index 9f50cd6..b2d2d4c 100644 (file)
@@ -1195,7 +1195,7 @@ void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagrap
     RefPtr<DocumentFragment> fragment;
     // This used to use a ternary for initialization, but that confused some versions of GCC, see bug 37912
     if (startOfParagraphToMove != endOfParagraphToMove)
-        fragment = createFragmentFromMarkup(&document(), createMarkup(range.get(), 0, DoNotAnnotateForInterchange, true), "");
+        fragment = createFragmentFromMarkup(document(), createMarkup(*range, 0, DoNotAnnotateForInterchange, true), "");
 
     // A non-empty paragraph's style is moved when we copy and move it.  We don't move 
     // anything if we're given an empty paragraph, but an empty paragraph can have style
index b6f3de8..d5ddeab 100644 (file)
@@ -501,7 +501,7 @@ static bool executeInsertHorizontalRule(Frame& frame, Event*, EditorCommandSourc
 
 static bool executeInsertHTML(Frame& frame, Event*, EditorCommandSource, const String& value)
 {
-    return executeInsertFragment(frame, createFragmentFromMarkup(frame.document(), value, ""));
+    return executeInsertFragment(frame, createFragmentFromMarkup(*frame.document(), value, ""));
 }
 
 static bool executeInsertImage(Frame& frame, Event*, EditorCommandSource, const String& value)
index 5e8abd4..7f32ba5 100644 (file)
@@ -113,25 +113,20 @@ MarkupAccumulator::~MarkupAccumulator()
 {
 }
 
-String MarkupAccumulator::serializeNodes(Node* targetNode, Node* nodeToSkip, EChildrenOnly childrenOnly)
-{
-    return serializeNodes(targetNode, nodeToSkip, childrenOnly, 0);
-}
-
-String MarkupAccumulator::serializeNodes(Node* targetNode, Node* nodeToSkip, EChildrenOnly childrenOnly, Vector<QualifiedName>* tagNamesToSkip)
+String MarkupAccumulator::serializeNodes(Node& targetNode, Node* nodeToSkip, EChildrenOnly childrenOnly, Vector<QualifiedName>* tagNamesToSkip)
 {
     serializeNodesWithNamespaces(targetNode, nodeToSkip, childrenOnly, 0, tagNamesToSkip);
     return m_markup.toString();
 }
 
-void MarkupAccumulator::serializeNodesWithNamespaces(Node* targetNode, Node* nodeToSkip, EChildrenOnly childrenOnly, const Namespaces* namespaces, Vector<QualifiedName>* tagNamesToSkip)
+void MarkupAccumulator::serializeNodesWithNamespaces(Node& targetNode, Node* nodeToSkip, EChildrenOnly childrenOnly, const Namespaces* namespaces, Vector<QualifiedName>* tagNamesToSkip)
 {
-    if (targetNode == nodeToSkip)
+    if (&targetNode == nodeToSkip)
         return;
     
-    if (tagNamesToSkip) {
+    if (tagNamesToSkip && targetNode.isElementNode()) {
         for (size_t i = 0; i < tagNamesToSkip->size(); ++i) {
-            if (targetNode->hasTagName(tagNamesToSkip->at(i)))
+            if (targetNode.hasTagName(tagNamesToSkip->at(i)))
                 return;
         }
     }
@@ -148,29 +143,29 @@ void MarkupAccumulator::serializeNodesWithNamespaces(Node* targetNode, Node* nod
     if (!childrenOnly)
         appendStartTag(targetNode, &namespaceHash);
 
-    if (!(targetNode->document().isHTMLDocument() && elementCannotHaveEndTag(targetNode))) {
+    if (!(targetNode.document().isHTMLDocument() && elementCannotHaveEndTag(targetNode))) {
 #if ENABLE(TEMPLATE_ELEMENT)
-        Node* current = targetNode->hasTagName(templateTag) ? toHTMLTemplateElement(targetNode)->content()->firstChild() : targetNode->firstChild();
+        Node* current = targetNode.hasTagName(templateTag) ? toHTMLTemplateElement(targetNode).content()->firstChild() : targetNode.firstChild();
 #else
-        Node* current = targetNode->firstChild();
+        Node* current = targetNode.firstChild();
 #endif
         for ( ; current; current = current->nextSibling())
-            serializeNodesWithNamespaces(current, nodeToSkip, IncludeNode, &namespaceHash, tagNamesToSkip);
+            serializeNodesWithNamespaces(*current, nodeToSkip, IncludeNode, &namespaceHash, tagNamesToSkip);
     }
 
     if (!childrenOnly)
         appendEndTag(targetNode);
 }
 
-String MarkupAccumulator::resolveURLIfNeeded(const Element* element, const String& urlString) const
+String MarkupAccumulator::resolveURLIfNeeded(const Element& element, const String& urlString) const
 {
     switch (m_resolveURLsMethod) {
     case ResolveAllURLs:
-        return element->document().completeURL(urlString).string();
+        return element.document().completeURL(urlString).string();
 
     case ResolveNonLocalURLs:
-        if (!element->document().url().isLocalFile())
-            return element->document().completeURL(urlString).string();
+        if (!element.document().url().isLocalFile())
+            return element.document().completeURL(urlString).string();
         break;
 
     case DoNotResolveURLs:
@@ -184,14 +179,14 @@ void MarkupAccumulator::appendString(const String& string)
     m_markup.append(string);
 }
 
-void MarkupAccumulator::appendStartTag(Node* node, Namespaces* namespaces)
+void MarkupAccumulator::appendStartTag(const Node& node, Namespaces* namespaces)
 {
     appendStartMarkup(m_markup, node, namespaces);
     if (m_nodes)
-        m_nodes->append(node);
+        m_nodes->append(const_cast<Node*>(&node));
 }
 
-void MarkupAccumulator::appendEndTag(Node* node)
+void MarkupAccumulator::appendEndTag(const Node& node)
 {
     appendEndMarkup(m_markup, node);
 }
@@ -215,13 +210,13 @@ void MarkupAccumulator::appendAttributeValue(StringBuilder& result, const String
         documentIsHTML ? EntityMaskInHTMLAttributeValue : EntityMaskInAttributeValue);
 }
 
-void MarkupAccumulator::appendCustomAttributes(StringBuilder&, Element*, Namespaces*)
+void MarkupAccumulator::appendCustomAttributes(StringBuilder&, const Element&, Namespaces*)
 {
 }
 
-void MarkupAccumulator::appendQuotedURLAttributeValue(StringBuilder& result, const Element* element, const Attribute& attribute)
+void MarkupAccumulator::appendQuotedURLAttributeValue(StringBuilder& result, const Element& element, const Attribute& attribute)
 {
-    ASSERT(element->isURLAttribute(attribute));
+    ASSERT(element.isURLAttribute(attribute));
     const String resolvedURLString = resolveURLIfNeeded(element, attribute.value());
     UChar quoteChar = '"';
     String strippedURLString = resolvedURLString.stripWhiteSpace();
@@ -245,16 +240,16 @@ void MarkupAccumulator::appendQuotedURLAttributeValue(StringBuilder& result, con
     result.append(quoteChar);
 }
 
-void MarkupAccumulator::appendNodeValue(StringBuilder& result, const Node* node, const Range* range, EntityMask entityMask)
+void MarkupAccumulator::appendNodeValue(StringBuilder& result, const Node& node, const Range* range, EntityMask entityMask)
 {
-    const String str = node->nodeValue();
+    const String str = node.nodeValue();
     unsigned length = str.length();
     unsigned start = 0;
 
     if (range) {
-        if (node == range->endContainer())
+        if (&node == range->endContainer())
             length = range->endOffset();
-        if (node == range->startContainer()) {
+        if (&node == range->startContainer()) {
             start = range->startOffset();
             length -= start;
         }
@@ -263,15 +258,15 @@ void MarkupAccumulator::appendNodeValue(StringBuilder& result, const Node* node,
     appendCharactersReplacingEntities(result, str, start, length, entityMask);
 }
 
-bool MarkupAccumulator::shouldAddNamespaceElement(const Element* element)
+bool MarkupAccumulator::shouldAddNamespaceElement(const Element& element)
 {
     // Don't add namespace attribute if it is already defined for this elem.
-    const AtomicString& prefix = element->prefix();
+    const AtomicString& prefix = element.prefix();
     if (prefix.isEmpty())
-        return !element->hasAttribute(xmlnsAtom);
+        return !element.hasAttribute(xmlnsAtom);
 
     DEFINE_STATIC_LOCAL(String, xmlnsWithColon, (ASCIILiteral("xmlns:")));
-    return !element->hasAttribute(xmlnsWithColon + prefix);
+    return !element.hasAttribute(xmlnsWithColon + prefix);
 }
 
 bool MarkupAccumulator::shouldAddNamespaceAttribute(const Attribute& attribute, Namespaces& namespaces)
@@ -333,24 +328,24 @@ void MarkupAccumulator::appendNamespace(StringBuilder& result, const AtomicStrin
     }
 }
 
-EntityMask MarkupAccumulator::entityMaskForText(Text* text) const
+EntityMask MarkupAccumulator::entityMaskForText(const Text& text) const
 {
     const QualifiedName* parentName = 0;
-    if (text->parentElement())
-        parentName = &(text->parentElement())->tagQName();
+    if (text.parentElement())
+        parentName = &text.parentElement()->tagQName();
 
     if (parentName && (*parentName == scriptTag || *parentName == styleTag || *parentName == xmpTag))
         return EntityMaskInCDATA;
 
-    return text->document().isHTMLDocument() ? EntityMaskInHTMLPCDATA : EntityMaskInPCDATA;
+    return text.document().isHTMLDocument() ? EntityMaskInHTMLPCDATA : EntityMaskInPCDATA;
 }
 
-void MarkupAccumulator::appendText(StringBuilder& result, Text* text)
+void MarkupAccumulator::appendText(StringBuilder& result, const Text& text)
 {
     appendNodeValue(result, text, m_range, entityMaskForText(text));
 }
 
-void MarkupAccumulator::appendComment(StringBuilder& result, const String& comment)
+static void appendComment(StringBuilder& result, const String& comment)
 {
     // FIXME: Comment content is not escaped, but XMLSerializer (and possibly other callers) should raise an exception if it includes "-->".
     result.appendLiteral("<!--");
@@ -358,21 +353,21 @@ void MarkupAccumulator::appendComment(StringBuilder& result, const String& comme
     result.appendLiteral("-->");
 }
 
-void MarkupAccumulator::appendXMLDeclaration(StringBuilder& result, const Document* document)
+void MarkupAccumulator::appendXMLDeclaration(StringBuilder& result, const Document& document)
 {
-    if (!document->hasXMLDeclaration())
+    if (!document.hasXMLDeclaration())
         return;
 
     result.appendLiteral("<?xml version=\"");
-    result.append(document->xmlVersion());
-    const String& encoding = document->xmlEncoding();
+    result.append(document.xmlVersion());
+    const String& encoding = document.xmlEncoding();
     if (!encoding.isEmpty()) {
         result.appendLiteral("\" encoding=\"");
         result.append(encoding);
     }
-    if (document->xmlStandaloneStatus() != Document::StandaloneUnspecified) {
+    if (document.xmlStandaloneStatus() != Document::StandaloneUnspecified) {
         result.appendLiteral("\" standalone=\"");
-        if (document->xmlStandalone())
+        if (document.xmlStandalone())
             result.appendLiteral("yes");
         else
             result.appendLiteral("no");
@@ -381,32 +376,32 @@ void MarkupAccumulator::appendXMLDeclaration(StringBuilder& result, const Docume
     result.appendLiteral("\"?>");
 }
 
-void MarkupAccumulator::appendDocumentType(StringBuilder& result, const DocumentType* n)
+void MarkupAccumulator::appendDocumentType(StringBuilder& result, const DocumentType& documentType)
 {
-    if (n->name().isEmpty())
+    if (documentType.name().isEmpty())
         return;
 
     result.appendLiteral("<!DOCTYPE ");
-    result.append(n->name());
-    if (!n->publicId().isEmpty()) {
+    result.append(documentType.name());
+    if (!documentType.publicId().isEmpty()) {
         result.appendLiteral(" PUBLIC \"");
-        result.append(n->publicId());
+        result.append(documentType.publicId());
         result.append('"');
-        if (!n->systemId().isEmpty()) {
+        if (!documentType.systemId().isEmpty()) {
             result.append(' ');
             result.append('"');
-            result.append(n->systemId());
+            result.append(documentType.systemId());
             result.append('"');
         }
-    } else if (!n->systemId().isEmpty()) {
+    } else if (!documentType.systemId().isEmpty()) {
         result.appendLiteral(" SYSTEM \"");
-        result.append(n->systemId());
+        result.append(documentType.systemId());
         result.append('"');
     }
-    if (!n->internalSubset().isEmpty()) {
+    if (!documentType.internalSubset().isEmpty()) {
         result.append(' ');
         result.append('[');
-        result.append(n->internalSubset());
+        result.append(documentType.internalSubset());
         result.append(']');
     }
     result.append('>');
@@ -424,14 +419,14 @@ void MarkupAccumulator::appendProcessingInstruction(StringBuilder& result, const
     result.append('>');
 }
 
-void MarkupAccumulator::appendElement(StringBuilder& result, Element* element, Namespaces* namespaces)
+void MarkupAccumulator::appendElement(StringBuilder& result, const Element& element, Namespaces* namespaces)
 {
     appendOpenTag(result, element, namespaces);
 
-    if (element->hasAttributes()) {
-        unsigned length = element->attributeCount();
+    if (element.hasAttributes()) {
+        unsigned length = element.attributeCount();
         for (unsigned int i = 0; i < length; i++)
-            appendAttribute(result, element, element->attributeAt(i), namespaces);
+            appendAttribute(result, element, element.attributeAt(i), namespaces);
     }
 
     // Give an opportunity to subclasses to add their own attributes.
@@ -440,27 +435,27 @@ void MarkupAccumulator::appendElement(StringBuilder& result, Element* element, N
     appendCloseTag(result, element);
 }
 
-void MarkupAccumulator::appendOpenTag(StringBuilder& result, Element* element, Namespaces* namespaces)
+void MarkupAccumulator::appendOpenTag(StringBuilder& result, const Element& element, Namespaces* namespaces)
 {
     result.append('<');
-    if (inXMLFragmentSerialization() && namespaces && element->prefix().isEmpty()) {
+    if (inXMLFragmentSerialization() && namespaces && element.prefix().isEmpty()) {
         // According to http://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#normalizeDocumentAlgo we now should create
         // a default namespace declaration to make this namespace well-formed. However, http://www.w3.org/TR/xml-names11/#xmlReserved states
         // "The prefix xml MUST NOT be declared as the default namespace.", so use the xml prefix explicitly.
-        if (element->namespaceURI() == XMLNames::xmlNamespaceURI) {
+        if (element.namespaceURI() == XMLNames::xmlNamespaceURI) {
             result.append(xmlAtom);
             result.append(':');
         }
     }
-    result.append(element->nodeNamePreservingCase());
-    if ((inXMLFragmentSerialization() || !element->document().isHTMLDocument()) && namespaces && shouldAddNamespaceElement(element))
-        appendNamespace(result, element->prefix(), element->namespaceURI(), *namespaces, inXMLFragmentSerialization());
+    result.append(element.nodeNamePreservingCase());
+    if ((inXMLFragmentSerialization() || !element.document().isHTMLDocument()) && namespaces && shouldAddNamespaceElement(element))
+        appendNamespace(result, element.prefix(), element.namespaceURI(), *namespaces, inXMLFragmentSerialization());
 }
 
-void MarkupAccumulator::appendCloseTag(StringBuilder& result, Element* element)
+void MarkupAccumulator::appendCloseTag(StringBuilder& result, const Element& element)
 {
     if (shouldSelfClose(element)) {
-        if (element->isHTMLElement())
+        if (element.isHTMLElement())
             result.append(' '); // XHTML 1.0 <-> HTML compatibility.
         result.append('/');
     }
@@ -492,9 +487,9 @@ void MarkupAccumulator::generateUniquePrefix(QualifiedName& prefixedName, const
     } while (true);
 }
 
-void MarkupAccumulator::appendAttribute(StringBuilder& result, Element* element, const Attribute& attribute, Namespaces* namespaces)
+void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
 {
-    bool documentIsHTML = element->document().isHTMLDocument();
+    bool documentIsHTML = element.document().isHTMLDocument();
 
     result.append(' ');
 
@@ -520,7 +515,7 @@ void MarkupAccumulator::appendAttribute(StringBuilder& result, Element* element,
 
     result.append('=');
 
-    if (element->isURLAttribute(attribute))
+    if (element.isURLAttribute(attribute))
         appendQuotedURLAttributeValue(result, element, attribute);
     else {
         result.append('"');
@@ -540,17 +535,17 @@ void MarkupAccumulator::appendCDATASection(StringBuilder& result, const String&
     result.appendLiteral("]]>");
 }
 
-void MarkupAccumulator::appendStartMarkup(StringBuilder& result, const Node* node, Namespaces* namespaces)
+void MarkupAccumulator::appendStartMarkup(StringBuilder& result, const Node& node, Namespaces* namespaces)
 {
     if (namespaces)
         namespaces->checkConsistency();
 
-    switch (node->nodeType()) {
+    switch (node.nodeType()) {
     case Node::TEXT_NODE:
-        appendText(result, toText(const_cast<Node*>(node)));
+        appendText(result, toText(node));
         break;
     case Node::COMMENT_NODE:
-        appendComment(result, static_cast<const Comment*>(node)->data());
+        appendComment(result, toComment(node).data());
         break;
     case Node::DOCUMENT_NODE:
         appendXMLDeclaration(result, toDocument(node));
@@ -558,16 +553,16 @@ void MarkupAccumulator::appendStartMarkup(StringBuilder& result, const Node* nod
     case Node::DOCUMENT_FRAGMENT_NODE:
         break;
     case Node::DOCUMENT_TYPE_NODE:
-        appendDocumentType(result, static_cast<const DocumentType*>(node));
+        appendDocumentType(result, toDocumentType(node));
         break;
     case Node::PROCESSING_INSTRUCTION_NODE:
-        appendProcessingInstruction(result, static_cast<const ProcessingInstruction*>(node)->target(), static_cast<const ProcessingInstruction*>(node)->data());
+        appendProcessingInstruction(result, toProcessingInstruction(node).target(), toProcessingInstruction(node).data());
         break;
     case Node::ELEMENT_NODE:
-        appendElement(result, toElement(const_cast<Node*>(node)), namespaces);
+        appendElement(result, toElement(node), namespaces);
         break;
     case Node::CDATA_SECTION_NODE:
-        appendCDATASection(result, static_cast<const CDATASection*>(node)->data());
+        appendCDATASection(result, toCDATASection(node).data());
         break;
     case Node::ATTRIBUTE_NODE:
     case Node::ENTITY_NODE:
@@ -584,37 +579,37 @@ void MarkupAccumulator::appendStartMarkup(StringBuilder& result, const Node* nod
 // 2. Elements w/ children never self-close because they use a separate end tag.
 // 3. HTML elements which do not have a "forbidden" end tag will close with a separate end tag.
 // 4. Other elements self-close.
-bool MarkupAccumulator::shouldSelfClose(const Node* node)
+bool MarkupAccumulator::shouldSelfClose(const Node& node)
 {
-    if (!inXMLFragmentSerialization() && node->document().isHTMLDocument())
+    if (!inXMLFragmentSerialization() && node.document().isHTMLDocument())
         return false;
-    if (node->hasChildNodes())
+    if (node.hasChildNodes())
         return false;
-    if (node->isHTMLElement() && !elementCannotHaveEndTag(node))
+    if (node.isHTMLElement() && !elementCannotHaveEndTag(node))
         return false;
     return true;
 }
 
-bool MarkupAccumulator::elementCannotHaveEndTag(const Node* node)
+bool MarkupAccumulator::elementCannotHaveEndTag(const Node& node)
 {
-    if (!node->isHTMLElement())
+    if (!node.isHTMLElement())
         return false;
 
     // FIXME: ieForbidsInsertHTML may not be the right function to call here
     // ieForbidsInsertHTML is used to disallow setting innerHTML/outerHTML
     // or createContextualFragment.  It does not necessarily align with
     // which elements should be serialized w/o end tags.
-    return static_cast<const HTMLElement*>(node)->ieForbidsInsertHTML();
+    return toHTMLElement(node).ieForbidsInsertHTML();
 }
 
-void MarkupAccumulator::appendEndMarkup(StringBuilder& result, const Node* node)
+void MarkupAccumulator::appendEndMarkup(StringBuilder& result, const Node& node)
 {
-    if (!node->isElementNode() || shouldSelfClose(node) || (!node->hasChildNodes() && elementCannotHaveEndTag(node)))
+    if (!node.isElementNode() || shouldSelfClose(node) || (!node.hasChildNodes() && elementCannotHaveEndTag(node)))
         return;
 
     result.append('<');
     result.append('/');
-    result.append(toElement(node)->nodeNamePreservingCase());
+    result.append(toElement(node).nodeNamePreservingCase());
     result.append('>');
 }
 
index 142559a..8d49f9f 100644 (file)
@@ -69,48 +69,52 @@ public:
     MarkupAccumulator(Vector<Node*>*, EAbsoluteURLs, const Range* = 0, EFragmentSerialization = HTMLFragmentSerialization);
     virtual ~MarkupAccumulator();
 
-    String serializeNodes(Node* targetNode, Node* nodeToSkip, EChildrenOnly);
-    String serializeNodes(Node* targetNode, Node* nodeToSkip, EChildrenOnly, Vector<QualifiedName>* tagNamesToSkip);
-
-    static void appendComment(StringBuilder&, const String&);
+    String serializeNodes(Node& targetNode, Node* nodeToSkip, EChildrenOnly, Vector<QualifiedName>* tagNamesToSkip = nullptr);
 
     static void appendCharactersReplacingEntities(StringBuilder&, const String&, unsigned, unsigned, EntityMask);
 
 protected:
-    virtual void appendString(const String&);
-    void appendStartTag(Node*, Namespaces* = 0);
-    virtual void appendEndTag(Node*);
     static size_t totalLength(const Vector<String>&);
     size_t length() const { return m_markup.length(); }
+
     void concatenateMarkup(StringBuilder&);
+
+    virtual void appendString(const String&);
+    virtual void appendEndTag(const Node&);
+    virtual void appendCustomAttributes(StringBuilder&, const Element&, Namespaces*);
+    virtual void appendText(StringBuilder&, const Text&);
+    virtual void appendElement(StringBuilder&, const Element&, Namespaces*);
+
+    void appendStartTag(const Node&, Namespaces* = 0);
+
+    void appendOpenTag(StringBuilder&, const Element&, Namespaces*);
+    void appendCloseTag(StringBuilder&, const Element&);
+
+    void appendStartMarkup(StringBuilder&, const Node&, Namespaces*);
+    void appendEndMarkup(StringBuilder&, const Node&);
+
     void appendAttributeValue(StringBuilder&, const String&, bool);
-    virtual void appendCustomAttributes(StringBuilder&, Element*, Namespaces*);
-    void appendNodeValue(StringBuilder&, const Node*, const Range*, EntityMask);
-    bool shouldAddNamespaceElement(const Element*);
-    bool shouldAddNamespaceAttribute(const Attribute&, Namespaces&);
+    void appendNodeValue(StringBuilder&, const Node&, const Range*, EntityMask);
     void appendNamespace(StringBuilder&, const AtomicString& prefix, const AtomicString& namespaceURI, Namespaces&, bool allowEmptyDefaultNS = false);
-    EntityMask entityMaskForText(Text*) const;
-    virtual void appendText(StringBuilder&, Text*);
-    void appendXMLDeclaration(StringBuilder&, const Document*);
-    void appendDocumentType(StringBuilder&, const DocumentType*);
+    void appendXMLDeclaration(StringBuilder&, const Document&);
+    void appendDocumentType(StringBuilder&, const DocumentType&);
     void appendProcessingInstruction(StringBuilder&, const String& target, const String& data);
-    virtual void appendElement(StringBuilder&, Element*, Namespaces*);
-    void appendOpenTag(StringBuilder&, Element*, Namespaces*);
-    void appendCloseTag(StringBuilder&, Element*);
-    void appendAttribute(StringBuilder&, Element*, const Attribute&, Namespaces*);
+    void appendAttribute(StringBuilder&, const Element&, const Attribute&, Namespaces*);
     void appendCDATASection(StringBuilder&, const String&);
-    void appendStartMarkup(StringBuilder&, const Node*, Namespaces*);
-    bool shouldSelfClose(const Node*);
-    bool elementCannotHaveEndTag(const Node*);
-    void appendEndMarkup(StringBuilder&, const Node*);
+
+    bool shouldAddNamespaceElement(const Element&);
+    bool shouldAddNamespaceAttribute(const Attribute&, Namespaces&);
+    bool shouldSelfClose(const Node&);
+    bool elementCannotHaveEndTag(const Node&);
+    EntityMask entityMaskForText(const Text&) const;
 
     Vector<Node*>* const m_nodes;
     const Range* const m_range;
 
 private:
-    String resolveURLIfNeeded(const Element*, const String&) const;
-    void appendQuotedURLAttributeValue(StringBuilder&, const Element*, const Attribute&);
-    void serializeNodesWithNamespaces(Node* targetNode, Node* nodeToSkip, EChildrenOnly, const Namespaces*, Vector<QualifiedName>* tagNamesToSkip);
+    String resolveURLIfNeeded(const Element&, const String&) const;
+    void appendQuotedURLAttributeValue(StringBuilder&, const Element&, const Attribute&);
+    void serializeNodesWithNamespaces(Node& targetNode, Node* nodeToSkip, EChildrenOnly, const Namespaces*, Vector<QualifiedName>* tagNamesToSkip);
     bool inXMLFragmentSerialization() const { return m_fragmentSerialization == XMLFragmentSerialization; }
     void generateUniquePrefix(QualifiedName&, const Namespaces&);
 
index b95e0db..fe670b9 100644 (file)
@@ -439,7 +439,7 @@ bool Editor::WebContentReader::readWebArchive(PassRefPtr<SharedBuffer> buffer)
             loader->addAllArchiveResources(archive.get());
 
         String markupString = String::fromUTF8(mainResource->data()->data(), mainResource->data()->size());
-        addFragment(createFragmentFromMarkup(frame.document(), markupString, mainResource->url(), DisallowScriptingAndPluginContent));
+        addFragment(createFragmentFromMarkup(*frame.document(), markupString, mainResource->url(), DisallowScriptingAndPluginContent));
         return true;
     }
 
index 5214251..cd9039f 100644 (file)
@@ -462,7 +462,7 @@ bool Editor::WebContentReader::readWebArchive(PassRefPtr<SharedBuffer> buffer)
             loader->addAllArchiveResources(archive.get());
 
         String markupString = String::fromUTF8(mainResource->data()->data(), mainResource->data()->size());
-        fragment = createFragmentFromMarkup(frame.document(), markupString, mainResource->url(), DisallowScriptingAndPluginContent);
+        fragment = createFragmentFromMarkup(*frame.document(), markupString, mainResource->url(), DisallowScriptingAndPluginContent);
         return true;
     }
 
@@ -514,7 +514,11 @@ bool Editor::WebContentReader::readHTML(const String& string)
     if (stringOmittingMicrosoftPrefix.isEmpty())
         return false;
 
-    fragment = createFragmentFromMarkup(frame.document(), stringOmittingMicrosoftPrefix, emptyString(), DisallowScriptingAndPluginContent);
+    if (!frame.document())
+        return false;
+    Document& document = *frame.document();
+
+    fragment = createFragmentFromMarkup(document, stringOmittingMicrosoftPrefix, emptyString(), DisallowScriptingAndPluginContent);
     return fragment;
 }
 
index 767f7e0..b226c25 100644 (file)
@@ -117,34 +117,45 @@ static void completeURLs(DocumentFragment* fragment, const String& baseURL)
         changes[i].apply();
 }
     
-class StyledMarkupAccumulator : public MarkupAccumulator {
+class StyledMarkupAccumulator final : public MarkupAccumulator {
 public:
     enum RangeFullySelectsNode { DoesFullySelectNode, DoesNotFullySelectNode };
 
     StyledMarkupAccumulator(Vector<Node*>* nodes, EAbsoluteURLs, EAnnotateForInterchange, const Range*, Node* highestNodeToBeSerialized = 0);
+
     Node* serializeNodes(Node* startNode, Node* pastEnd);
-    virtual void appendString(const String& s) { return MarkupAccumulator::appendString(s); }
-    void wrapWithNode(Node*, bool convertBlocksToInlines = false, RangeFullySelectsNode = DoesFullySelectNode);
-    void wrapWithStyleNode(StylePropertySet*, Document*, bool isBlock = false);
+    void wrapWithNode(Node&, bool convertBlocksToInlines = false, RangeFullySelectsNode = DoesFullySelectNode);
+    void wrapWithStyleNode(StylePropertySet*, Document&, bool isBlock = false);
     String takeResults();
 
+    using MarkupAccumulator::appendString;
+
 private:
-    void appendStyleNodeOpenTag(StringBuilder&, StylePropertySet*, Document*, bool isBlock = false);
+    void appendStyleNodeOpenTag(StringBuilder&, StylePropertySet*, Document&, bool isBlock = false);
     const String& styleNodeCloseTag(bool isBlock = false);
-    virtual void appendText(StringBuilder& out, Text*);
-    String renderedText(const Node*, const Range*);
-    String stringValueForRange(const Node*, const Range*);
-    void appendElement(StringBuilder& out, Element*, bool addDisplayInline, RangeFullySelectsNode);
-    void appendElement(StringBuilder& out, Element* element, Namespaces*) { appendElement(out, element, false, DoesFullySelectNode); }
+
+    String renderedText(const Node&, const Range*);
+    String stringValueForRange(const Node&, const Range*);
+
+    void appendElement(StringBuilder& out, const Element&, bool addDisplayInline, RangeFullySelectsNode);
+
+    virtual void appendText(StringBuilder& out, const Text&) override;
+    virtual void appendElement(StringBuilder& out, const Element& element, Namespaces*) override
+    {
+        appendElement(out, element, false, DoesFullySelectNode);
+    }
 
     enum NodeTraversalMode { EmitString, DoNotEmitString };
     Node* traverseNodesForSerialization(Node* startNode, Node* pastEnd, NodeTraversalMode);
 
-    bool shouldAnnotate() { return m_shouldAnnotate == AnnotateForInterchange; }
-    bool shouldApplyWrappingStyle(Node* node) const
+    bool shouldAnnotate()
     {
-        return m_highestNodeToBeSerialized && m_highestNodeToBeSerialized->parentNode() == node->parentNode()
-            && m_wrappingStyle && m_wrappingStyle->style();
+        return m_shouldAnnotate == AnnotateForInterchange;
+    }
+
+    bool shouldApplyWrappingStyle(const Node& node) const
+    {
+        return m_highestNodeToBeSerialized && m_highestNodeToBeSerialized->parentNode() == node.parentNode() && m_wrappingStyle && m_wrappingStyle->style();
     }
 
     Vector<String> m_reversedPrecedingMarkup;
@@ -161,20 +172,20 @@ inline StyledMarkupAccumulator::StyledMarkupAccumulator(Vector<Node*>* nodes, EA
 {
 }
 
-void StyledMarkupAccumulator::wrapWithNode(Node* node, bool convertBlocksToInlines, RangeFullySelectsNode rangeFullySelectsNode)
+void StyledMarkupAccumulator::wrapWithNode(Node& node, bool convertBlocksToInlines, RangeFullySelectsNode rangeFullySelectsNode)
 {
     StringBuilder markup;
-    if (node->isElementNode())
-        appendElement(markup, toElement(node), convertBlocksToInlines && isBlock(const_cast<Node*>(node)), rangeFullySelectsNode);
+    if (node.isElementNode())
+        appendElement(markup, toElement(node), convertBlocksToInlines && isBlock(&node), rangeFullySelectsNode);
     else
         appendStartMarkup(markup, node, 0);
     m_reversedPrecedingMarkup.append(markup.toString());
     appendEndTag(node);
     if (m_nodes)
-        m_nodes->append(node);
+        m_nodes->append(&node);
 }
 
-void StyledMarkupAccumulator::wrapWithStyleNode(StylePropertySet* style, Document* document, bool isBlock)
+void StyledMarkupAccumulator::wrapWithStyleNode(StylePropertySet* style, Document& document, bool isBlock)
 {
     StringBuilder openTag;
     appendStyleNodeOpenTag(openTag, style, document, isBlock);
@@ -182,7 +193,7 @@ void StyledMarkupAccumulator::wrapWithStyleNode(StylePropertySet* style, Documen
     appendString(styleNodeCloseTag(isBlock));
 }
 
-void StyledMarkupAccumulator::appendStyleNodeOpenTag(StringBuilder& out, StylePropertySet* style, Document* document, bool isBlock)
+void StyledMarkupAccumulator::appendStyleNodeOpenTag(StringBuilder& out, StylePropertySet* style, Document& document, bool isBlock)
 {
     // wrappingStyleForSerialization should have removed -webkit-text-decorations-in-effect
     ASSERT(propertyMissingOrEqualToNone(style, CSSPropertyWebkitTextDecorationsInEffect));
@@ -190,7 +201,7 @@ void StyledMarkupAccumulator::appendStyleNodeOpenTag(StringBuilder& out, StylePr
         out.appendLiteral("<div style=\"");
     else
         out.appendLiteral("<span style=\"");
-    appendAttributeValue(out, style->asText(), document->isHTMLDocument());
+    appendAttributeValue(out, style->asText(), document.isHTMLDocument());
     out.appendLiteral("\">");
 }
 
@@ -215,9 +226,9 @@ String StyledMarkupAccumulator::takeResults()
     return result.toString().replaceWithLiteral('\0', "");
 }
 
-void StyledMarkupAccumulator::appendText(StringBuilder& out, Text* text)
+void StyledMarkupAccumulator::appendText(StringBuilder& out, const Text& text)
 {    
-    const bool parentIsTextarea = text->parentElement() && isHTMLTextAreaElement(text->parentElement());
+    const bool parentIsTextarea = text.parentElement() && isHTMLTextAreaElement(text.parentElement());
     const bool wrappingSpan = shouldApplyWrappingStyle(text) && !parentIsTextarea;
     if (wrappingSpan) {
         RefPtr<EditingStyle> wrappingStyle = m_wrappingStyle->copy();
@@ -227,65 +238,65 @@ void StyledMarkupAccumulator::appendText(StringBuilder& out, Text* text)
         // FIXME: Should this be included in forceInline?
         wrappingStyle->style()->setProperty(CSSPropertyFloat, CSSValueNone);
 
-        appendStyleNodeOpenTag(out, wrappingStyle->style(), &text->document());
+        appendStyleNodeOpenTag(out, wrappingStyle->style(), text.document());
     }
 
     if (!shouldAnnotate() || parentIsTextarea)
         MarkupAccumulator::appendText(out, text);
     else {
-        const bool useRenderedText = !enclosingNodeWithTag(firstPositionInNode(text), selectTag);
+        const bool useRenderedText = !enclosingNodeWithTag(firstPositionInNode(const_cast<Text*>(&text)), selectTag);
         String content = useRenderedText ? renderedText(text, m_range) : stringValueForRange(text, m_range);
         StringBuilder buffer;
         appendCharactersReplacingEntities(buffer, content, 0, content.length(), EntityMaskInPCDATA);
-        out.append(convertHTMLTextToInterchangeFormat(buffer.toString(), text));
+        out.append(convertHTMLTextToInterchangeFormat(buffer.toString(), &text));
     }
 
     if (wrappingSpan)
         out.append(styleNodeCloseTag());
 }
     
-String StyledMarkupAccumulator::renderedText(const Node* node, const Range* range)
+String StyledMarkupAccumulator::renderedText(const Node& node, const Range* range)
 {
-    if (!node->isTextNode())
+    if (!node.isTextNode())
         return String();
 
-    const Text* textNode = static_cast<const Text*>(node);
+    const Text& textNode = toText(node);
     unsigned startOffset = 0;
-    unsigned endOffset = textNode->length();
+    unsigned endOffset = textNode.length();
 
-    if (range && node == range->startContainer())
+    if (range && &node == range->startContainer())
         startOffset = range->startOffset();
-    if (range && node == range->endContainer())
+    if (range && &node == range->endContainer())
         endOffset = range->endOffset();
 
-    Position start = createLegacyEditingPosition(const_cast<Node*>(node), startOffset);
-    Position end = createLegacyEditingPosition(const_cast<Node*>(node), endOffset);
-    return plainText(Range::create(&node->document(), start, end).get());
+    Position start = createLegacyEditingPosition(const_cast<Node*>(&node), startOffset);
+    Position end = createLegacyEditingPosition(const_cast<Node*>(&node), endOffset);
+    return plainText(Range::create(&node.document(), start, end).get());
 }
 
-String StyledMarkupAccumulator::stringValueForRange(const Node* node, const Range* range)
+String StyledMarkupAccumulator::stringValueForRange(const Node& node, const Range* range)
 {
     if (!range)
-        return node->nodeValue();
-
-    String str = node->nodeValue();
-    if (node == range->endContainer())
-        str.truncate(range->endOffset());
-    if (node == range->startContainer())
-        str.remove(0, range->startOffset());
-    return str;
+        return node.nodeValue();
+
+    String nodeValue = node.nodeValue();
+    if (&node == range->endContainer())
+        nodeValue.truncate(range->endOffset());
+    if (&node == range->startContainer())
+        nodeValue.remove(0, range->startOffset());
+    return nodeValue;
 }
 
-void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element* element, bool addDisplayInline, RangeFullySelectsNode rangeFullySelectsNode)
+void StyledMarkupAccumulator::appendElement(StringBuilder& out, const Element& element, bool addDisplayInline, RangeFullySelectsNode rangeFullySelectsNode)
 {
-    const bool documentIsHTML = element->document().isHTMLDocument();
+    const bool documentIsHTML = element.document().isHTMLDocument();
     appendOpenTag(out, element, 0);
 
-    const unsigned length = element->hasAttributes() ? element->attributeCount() : 0;
-    const bool shouldAnnotateOrForceInline = element->isHTMLElement() && (shouldAnnotate() || addDisplayInline);
+    const unsigned length = element.hasAttributes() ? element.attributeCount() : 0;
+    const bool shouldAnnotateOrForceInline = element.isHTMLElement() && (shouldAnnotate() || addDisplayInline);
     const bool shouldOverrideStyleAttr = shouldAnnotateOrForceInline || shouldApplyWrappingStyle(element);
     for (unsigned i = 0; i < length; ++i) {
-        const Attribute& attribute = element->attributeAt(i);
+        const Attribute& attribute = element.attributeAt(i);
         // We'll handle the style attribute separately, below.
         if (attribute.name() == styleAttr && shouldOverrideStyleAttr)
             continue;
@@ -297,17 +308,17 @@ void StyledMarkupAccumulator::appendElement(StringBuilder& out, Element* element
 
         if (shouldApplyWrappingStyle(element)) {
             newInlineStyle = m_wrappingStyle->copy();
-            newInlineStyle->removePropertiesInElementDefaultStyle(element);
-            newInlineStyle->removeStyleConflictingWithStyleOfNode(element);
+            newInlineStyle->removePropertiesInElementDefaultStyle(const_cast<Element*>(&element));
+            newInlineStyle->removeStyleConflictingWithStyleOfNode(const_cast<Element*>(&element));
         } else
             newInlineStyle = EditingStyle::create();
 
-        if (element->isStyledElement() && static_cast<StyledElement*>(element)->inlineStyle())
-            newInlineStyle->overrideWithStyle(static_cast<StyledElement*>(element)->inlineStyle());
+        if (element.isStyledElement() && toStyledElement(element).inlineStyle())
+            newInlineStyle->overrideWithStyle(toStyledElement(element).inlineStyle());
 
         if (shouldAnnotateOrForceInline) {
             if (shouldAnnotate())
-                newInlineStyle->mergeStyleFromRulesForSerialization(toHTMLElement(element));
+                newInlineStyle->mergeStyleFromRulesForSerialization(toHTMLElement(const_cast<Element*>(&element)));
 
             if (addDisplayInline)
                 newInlineStyle->forceInline();
@@ -371,12 +382,12 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
         } else {
             // Add the node to the markup if we're not skipping the descendants
             if (shouldEmit)
-                appendStartTag(n);
+                appendStartTag(*n);
 
             // If node has no children, close the tag now.
             if (!n->childNodeCount()) {
                 if (shouldEmit)
-                    appendEndTag(n);
+                    appendEndTag(*n);
                 lastClosed = n;
             } else {
                 openedTag = true;
@@ -394,7 +405,7 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
                     break;
                 // Not at the end of the range, close ancestors up to sibling of next node.
                 if (shouldEmit)
-                    appendEndTag(ancestor);
+                    appendEndTag(*ancestor);
                 lastClosed = ancestor;
                 ancestorsToClose.removeLast();
             }
@@ -410,7 +421,7 @@ Node* StyledMarkupAccumulator::traverseNodesForSerialization(Node* startNode, No
                     // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
                     ASSERT(startNode->isDescendantOf(parent));
                     if (shouldEmit)
-                        wrapWithNode(parent);
+                        wrapWithNode(*parent);
                     lastClosed = parent;
                 }
             }
@@ -544,35 +555,33 @@ static Node* highestAncestorToWrapMarkup(const Range* range, EAnnotateForInterch
 
 // FIXME: Shouldn't we omit style info when annotate == DoNotAnnotateForInterchange? 
 // FIXME: At least, annotation and style info should probably not be included in range.markupString()
-static String createMarkupInternal(Document* document, const Range* range, const Range* updatedRange, Vector<Node*>* nodes,
+static String createMarkupInternal(Document& document, const Range& range, const Range& updatedRange, Vector<Node*>* nodes,
     EAnnotateForInterchange shouldAnnotate, bool convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs)
 {
-    ASSERT(document);
-    ASSERT(range);
-    ASSERT(updatedRange);
     DEFINE_STATIC_LOCAL(const String, interchangeNewlineString, (ASCIILiteral("<br class=\"" AppleInterchangeNewline "\">")));
 
-    bool collapsed = updatedRange->collapsed(ASSERT_NO_EXCEPTION);
+    bool collapsed = updatedRange.collapsed(ASSERT_NO_EXCEPTION);
     if (collapsed)
         return emptyString();
-    Node* commonAncestor = updatedRange->commonAncestorContainer(ASSERT_NO_EXCEPTION);
+    Node* commonAncestor = updatedRange.commonAncestorContainer(ASSERT_NO_EXCEPTION);
     if (!commonAncestor)
         return emptyString();
 
-    document->updateLayoutIgnorePendingStylesheets();
+    document.updateLayoutIgnorePendingStylesheets();
 
     Node* body = enclosingNodeWithTag(firstPositionInNode(commonAncestor), bodyTag);
     Node* fullySelectedRoot = 0;
     // FIXME: Do this for all fully selected blocks, not just the body.
-    if (body && areRangesEqual(VisibleSelection::selectionFromContentsOfNode(body).toNormalizedRange().get(), range))
+    if (body && areRangesEqual(VisibleSelection::selectionFromContentsOfNode(body).toNormalizedRange().get(), &range))
         fullySelectedRoot = body;
-    Node* specialCommonAncestor = highestAncestorToWrapMarkup(updatedRange, shouldAnnotate);
-    StyledMarkupAccumulator accumulator(nodes, shouldResolveURLs, shouldAnnotate, updatedRange, specialCommonAncestor);
-    Node* pastEnd = updatedRange->pastLastNode();
+    Node* specialCommonAncestor = highestAncestorToWrapMarkup(&updatedRange, shouldAnnotate);
 
-    Node* startNode = updatedRange->firstNode();
-    VisiblePosition visibleStart(updatedRange->startPosition(), VP_DEFAULT_AFFINITY);
-    VisiblePosition visibleEnd(updatedRange->endPosition(), VP_DEFAULT_AFFINITY);
+    StyledMarkupAccumulator accumulator(nodes, shouldResolveURLs, shouldAnnotate, &updatedRange, specialCommonAncestor);
+    Node* pastEnd = updatedRange.pastLastNode();
+
+    Node* startNode = updatedRange.firstNode();
+    VisiblePosition visibleStart(updatedRange.startPosition(), VP_DEFAULT_AFFINITY);
+    VisiblePosition visibleEnd(updatedRange.endPosition(), VP_DEFAULT_AFFINITY);
     if (shouldAnnotate == AnnotateForInterchange && needInterchangeNewlineAfter(visibleStart)) {
         if (visibleStart == visibleEnd.previous())
             return interchangeNewlineString;
@@ -611,7 +620,7 @@ static String createMarkupInternal(Document* document, const Range* range, const
             } else {
                 // Since this node and all the other ancestors are not in the selection we want to set RangeFullySelectsNode to DoesNotFullySelectNode
                 // so that styles that affect the exterior of the node are not included.
-                accumulator.wrapWithNode(ancestor, convertBlocksToInlines, StyledMarkupAccumulator::DoesNotFullySelectNode);
+                accumulator.wrapWithNode(*ancestor, convertBlocksToInlines, StyledMarkupAccumulator::DoesNotFullySelectNode);
             }
             if (nodes)
                 nodes->append(ancestor);
@@ -630,13 +639,10 @@ static String createMarkupInternal(Document* document, const Range* range, const
     return accumulator.takeResults();
 }
 
-String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterchange shouldAnnotate, bool convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs)
+String createMarkup(const Range& range, Vector<Node*>* nodes, EAnnotateForInterchange shouldAnnotate, bool convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs)
 {
-    if (!range)
-        return emptyString();
-
-    Document& document = range->ownerDocument();
-    const Range* updatedRange = range;
+    Document& document = range.ownerDocument();
+    const Range* updatedRange = &range;
 
 #if ENABLE(DELETION_UI)
     // Disable the delete button so it's elements are not serialized into the markup,
@@ -646,126 +652,43 @@ String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterc
 
     RefPtr<Range> updatedRangeRef;
     if (frame) {
-        updatedRangeRef = frame->editor().avoidIntersectionWithDeleteButtonController(range);
+        updatedRangeRef = frame->editor().avoidIntersectionWithDeleteButtonController(&range);
         updatedRange = updatedRangeRef.get();
         if (!updatedRange)
             return emptyString();
     }
 #endif
 
-    return createMarkupInternal(&document, range, updatedRange, nodes, shouldAnnotate, convertBlocksToInlines, shouldResolveURLs);
+    return createMarkupInternal(document, range, *updatedRange, nodes, shouldAnnotate, convertBlocksToInlines, shouldResolveURLs);
 }
 
-PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document* document, const String& markup, const String& baseURL, ParserContentPolicy parserContentPolicy)
+PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document& document, const String& markup, const String& baseURL, ParserContentPolicy parserContentPolicy)
 {
     // We use a fake body element here to trick the HTML parser to using the InBody insertion mode.
-    RefPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(*document);
-    RefPtr<DocumentFragment> fragment = DocumentFragment::create(*document);
+    RefPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(document);
+    RefPtr<DocumentFragment> fragment = DocumentFragment::create(document);
 
     fragment->parseHTML(markup, fakeBody.get(), parserContentPolicy);
 
-    if (!baseURL.isEmpty() && baseURL != blankURL() && baseURL != document->baseURL())
+    if (!baseURL.isEmpty() && baseURL != blankURL() && baseURL != document.baseURL())
         completeURLs(fragment.get(), baseURL);
 
     return fragment.release();
 }
 
-static const char fragmentMarkerTag[] = "webkit-fragment-marker";
-
-static bool findNodesSurroundingContext(Document* document, RefPtr<Node>& nodeBeforeContext, RefPtr<Node>& nodeAfterContext)
-{
-    for (Node* node = document->firstChild(); node; node = NodeTraversal::next(node)) {
-        if (node->nodeType() == Node::COMMENT_NODE && static_cast<CharacterData*>(node)->data() == fragmentMarkerTag) {
-            if (!nodeBeforeContext)
-                nodeBeforeContext = node;
-            else {
-                nodeAfterContext = node;
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-static void trimFragment(DocumentFragment* fragment, Node* nodeBeforeContext, Node* nodeAfterContext)
+String createMarkup(const Node& node, EChildrenOnly childrenOnly, Vector<Node*>* nodes, EAbsoluteURLs shouldResolveURLs, Vector<QualifiedName>* tagNamesToSkip, EFragmentSerialization fragmentSerialization)
 {
-    RefPtr<Node> next;
-    for (RefPtr<Node> node = fragment->firstChild(); node; node = next) {
-        if (nodeBeforeContext->isDescendantOf(node.get())) {
-            next = NodeTraversal::next(node.get());
-            continue;
-        }
-        next = NodeTraversal::nextSkippingChildren(node.get());
-        ASSERT(!node->contains(nodeAfterContext));
-        node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
-        if (nodeBeforeContext == node)
-            break;
-    }
-
-    ASSERT(nodeAfterContext->parentNode());
-    for (RefPtr<Node> node = nodeAfterContext; node; node = next) {
-        next = NodeTraversal::nextSkippingChildren(node.get());
-        node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
-    }
-}
-
-PassRefPtr<DocumentFragment> createFragmentFromMarkupWithContext(Document* document, const String& markup, unsigned fragmentStart, unsigned fragmentEnd,
-    const String& baseURL, ParserContentPolicy parserContentPolicy)
-{
-    // FIXME: Need to handle the case where the markup already contains these markers.
-
-    StringBuilder taggedMarkup;
-    taggedMarkup.append(markup.left(fragmentStart));
-    MarkupAccumulator::appendComment(taggedMarkup, fragmentMarkerTag);
-    taggedMarkup.append(markup.substring(fragmentStart, fragmentEnd - fragmentStart));
-    MarkupAccumulator::appendComment(taggedMarkup, fragmentMarkerTag);
-    taggedMarkup.append(markup.substring(fragmentEnd));
-
-    RefPtr<DocumentFragment> taggedFragment = createFragmentFromMarkup(document, taggedMarkup.toString(), baseURL, parserContentPolicy);
-    RefPtr<Document> taggedDocument = Document::create(0, URL());
-    taggedDocument->takeAllChildrenFrom(taggedFragment.get());
-
-    RefPtr<Node> nodeBeforeContext;
-    RefPtr<Node> nodeAfterContext;
-    if (!findNodesSurroundingContext(taggedDocument.get(), nodeBeforeContext, nodeAfterContext))
-        return 0;
-
-    RefPtr<Range> range = Range::create(taggedDocument.get(),
-        positionAfterNode(nodeBeforeContext.get()).parentAnchoredEquivalent(),
-        positionBeforeNode(nodeAfterContext.get()).parentAnchoredEquivalent());
-
-    Node* commonAncestor = range->commonAncestorContainer(ASSERT_NO_EXCEPTION);
-    Node* specialCommonAncestor = ancestorToRetainStructureAndAppearanceWithNoRenderer(commonAncestor);
-
-    // When there's a special common ancestor outside of the fragment, we must include it as well to
-    // preserve the structure and appearance of the fragment. For example, if the fragment contains
-    // TD, we need to include the enclosing TABLE tag as well.
-    RefPtr<DocumentFragment> fragment = DocumentFragment::create(*document);
-    if (specialCommonAncestor)
-        fragment->appendChild(specialCommonAncestor, ASSERT_NO_EXCEPTION);
-    else
-        fragment->takeAllChildrenFrom(toContainerNode(commonAncestor));
-
-    trimFragment(fragment.get(), nodeBeforeContext.get(), nodeAfterContext.get());
-
-    return fragment;
-}
-
-String createMarkup(const Node* node, EChildrenOnly childrenOnly, Vector<Node*>* nodes, EAbsoluteURLs shouldResolveURLs, Vector<QualifiedName>* tagNamesToSkip, EFragmentSerialization fragmentSerialization)
-{
-    if (!node)
-        return emptyString();
-
     HTMLElement* deleteButtonContainerElement = 0;
 #if ENABLE(DELETION_UI)
-    if (Frame* frame = node->document().frame()) {
+    if (Frame* frame = node.document().frame()) {
         deleteButtonContainerElement = frame->editor().deleteButtonController().containerElement();
-        if (node->isDescendantOf(deleteButtonContainerElement))
+        if (node.isDescendantOf(deleteButtonContainerElement))
             return emptyString();
     }
 #endif
+
     MarkupAccumulator accumulator(nodes, shouldResolveURLs, 0, fragmentSerialization);
-    return accumulator.serializeNodes(const_cast<Node*>(node), deleteButtonContainerElement, childrenOnly, tagNamesToSkip);
+    return accumulator.serializeNodes(const_cast<Node&>(node), deleteButtonContainerElement, childrenOnly, tagNamesToSkip);
 }
 
 static void fillContainerFromString(ContainerNode* paragraph, const String& string)
@@ -896,54 +819,29 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String
     return fragment.release();
 }
 
-PassRefPtr<DocumentFragment> createFragmentFromNodes(Document* document, const Vector<Node*>& nodes)
-{
-    if (!document)
-        return 0;
-
-#if ENABLE(DELETION_UI)
-    // disable the delete button so it's elements are not serialized into the markup
-    DeleteButtonControllerDisableScope(document->frame());
-#endif
-
-    RefPtr<DocumentFragment> fragment = document->createDocumentFragment();
-
-    size_t size = nodes.size();
-    for (size_t i = 0; i < size; ++i) {
-        RefPtr<Element> element = createDefaultParagraphElement(*document);
-        element->appendChild(nodes[i], ASSERT_NO_EXCEPTION);
-        fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
-    }
-
-    return fragment.release();
-}
-
 String documentTypeString(const Document& document)
 {
-    return createMarkup(document.doctype());
+    DocumentType* documentType = document.doctype();
+    if (!documentType)
+        return emptyString();
+    return createMarkup(*documentType);
 }
 
-String createFullMarkup(const Node* node)
+String createFullMarkup(const Node& node)
 {
-    if (!node)
-        return String();
-
     // FIXME: This is never "for interchange". Is that right?
     String markupString = createMarkup(node, IncludeNode, 0);
 
-    Node::NodeType nodeType = node->nodeType();
+    Node::NodeType nodeType = node.nodeType();
     if (nodeType != Node::DOCUMENT_NODE && nodeType != Node::DOCUMENT_TYPE_NODE)
-        markupString = documentTypeString(node->document()) + markupString;
+        markupString = documentTypeString(node.document()) + markupString;
 
     return markupString;
 }
 
-String createFullMarkup(const Range* range)
+String createFullMarkup(const Range& range)
 {
-    if (!range)
-        return String();
-
-    Node* node = range->startContainer();
+    Node* node = range.startContainer();
     if (!node)
         return String();
 
index 1565ba1..8a68be1 100644 (file)
@@ -50,9 +50,7 @@ enum EAbsoluteURLs { DoNotResolveURLs, ResolveAllURLs, ResolveNonLocalURLs };
 enum EFragmentSerialization { HTMLFragmentSerialization, XMLFragmentSerialization };
 
 PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String& text);
-PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document*, const String& markup, const String& baseURL, ParserContentPolicy = AllowScriptingContent);
-PassRefPtr<DocumentFragment> createFragmentFromMarkupWithContext(Document*, const String& markup, unsigned fragmentStart, unsigned fragmentEnd, const String& baseURL, ParserContentPolicy);
-PassRefPtr<DocumentFragment> createFragmentFromNodes(Document*, const Vector<Node*>&);
+PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document&, const String& markup, const String& baseURL, ParserContentPolicy = AllowScriptingContent);
 PassRefPtr<DocumentFragment> createFragmentForInnerOuterHTML(const String&, Element*, ParserContentPolicy, ExceptionCode&);
 PassRefPtr<DocumentFragment> createFragmentForTransformToFragment(const String&, const String& sourceMIMEType, Document* outputDoc);
 PassRefPtr<DocumentFragment> createContextualFragment(const String&, HTMLElement*, ParserContentPolicy, ExceptionCode&);
@@ -64,11 +62,11 @@ bool isPlainTextMarkup(Node*);
 void replaceChildrenWithFragment(ContainerNode&, PassRefPtr<DocumentFragment>, ExceptionCode&);
 void replaceChildrenWithText(ContainerNode&, const String&, ExceptionCode&);
 
-String createMarkup(const Range*, Vector<Node*>* = 0, EAnnotateForInterchange = DoNotAnnotateForInterchange, bool convertBlocksToInlines = false, EAbsoluteURLs = DoNotResolveURLs);
-String createMarkup(const Node*, EChildrenOnly = IncludeNode, Vector<Node*>* = 0, EAbsoluteURLs = DoNotResolveURLs, Vector<QualifiedName>* tagNamesToSkip = 0, EFragmentSerialization = HTMLFragmentSerialization);
+String createMarkup(const Range&, Vector<Node*>* = 0, EAnnotateForInterchange = DoNotAnnotateForInterchange, bool convertBlocksToInlines = false, EAbsoluteURLs = DoNotResolveURLs);
+String createMarkup(const Node&, EChildrenOnly = IncludeNode, Vector<Node*>* = 0, EAbsoluteURLs = DoNotResolveURLs, Vector<QualifiedName>* tagNamesToSkip = 0, EFragmentSerialization = HTMLFragmentSerialization);
 
-String createFullMarkup(const Node*);
-String createFullMarkup(const Range*);
+String createFullMarkup(const Node&);
+String createFullMarkup(const Range&);
 
 String urlToMarkup(const URL&, const String& title);
 
index 887ebe4..10b386d 100644 (file)
@@ -345,12 +345,12 @@ void HTMLElement::parseAttribute(const QualifiedName& name, const AtomicString&
 
 String HTMLElement::innerHTML() const
 {
-    return createMarkup(this, ChildrenOnly);
+    return createMarkup(*this, ChildrenOnly);
 }
 
 String HTMLElement::outerHTML() const
 {
-    return createMarkup(this);
+    return createMarkup(*this);
 }
 
 void HTMLElement::setInnerHTML(const String& html, ExceptionCode& ec)
index 950594c..d0cbd2c 100644 (file)
@@ -77,12 +77,27 @@ inline HTMLFrameOwnerElement& toFrameOwnerElement(Node& node)
     return static_cast<HTMLFrameOwnerElement&>(node);
 }
 
+inline const HTMLFrameOwnerElement& toFrameOwnerElement(const Node& node)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(node.isFrameOwnerElement());
+    return static_cast<const HTMLFrameOwnerElement&>(node);
+}
+
 inline HTMLFrameOwnerElement* toFrameOwnerElement(Node* node)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isFrameOwnerElement());
     return static_cast<HTMLFrameOwnerElement*>(node);
 }
 
+inline const HTMLFrameOwnerElement* toFrameOwnerElement(const Node* node)
+{
+    ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isFrameOwnerElement());
+    return static_cast<const HTMLFrameOwnerElement*>(node);
+}
+
+void toFrameOwnerElement(const HTMLFrameOwnerElement&);
+void toFrameOwnerElement(const HTMLFrameOwnerElement*);
+
 class SubframeLoadingDisabler {
 public:
     explicit SubframeLoadingDisabler(ContainerNode& root)
index 926c6a4..6d21cad 100644 (file)
@@ -85,14 +85,6 @@ void HTMLTemplateElement::didMoveToNewDocument(Document* oldDocument)
     document().ensureTemplateDocument()->adoptIfNeeded(m_content.get());
 }
 
-#ifndef NDEBUG
-const HTMLTemplateElement* toHTMLTemplateElement(const Node* node)
-{
-    ASSERT_WITH_SECURITY_IMPLICATION(!node || (node->isHTMLElement() && node->hasTagName(templateTag)));
-    return static_cast<const HTMLTemplateElement*>(node);
-}
-#endif
-
 } // namespace WebCore
 
 #endif // ENABLE(TEMPLATE_ELEMENT)
index 57108cf..ffa2914 100644 (file)
@@ -54,21 +54,7 @@ private:
     mutable RefPtr<DocumentFragment> m_content;
 };
 
-const HTMLTemplateElement* toHTMLTemplateElement(const Node*);
-
-inline HTMLTemplateElement* toHTMLTemplateElement(Node* node)
-{
-    return const_cast<HTMLTemplateElement*>(toHTMLTemplateElement(static_cast<const Node*>(node)));
-}
-
-#ifdef NDEBUG
-
-// The debug version of this, with assertions, is not inlined.
-inline const HTMLTemplateElement* toHTMLTemplateElement(const Node* node)
-{
-    return static_cast<const HTMLTemplateElement*>(node);
-}
-#endif // NDEBUG
+ELEMENT_TYPE_CASTS(HTMLTemplateElement)
 
 } // namespace WebCore
 
index 94649ca..51aa8e4 100644 (file)
@@ -206,10 +206,10 @@ private:
 class DOMEditor::SetOuterHTMLAction : public InspectorHistory::Action {
     WTF_MAKE_NONCOPYABLE(SetOuterHTMLAction);
 public:
-    SetOuterHTMLAction(Node* node, const String& html)
+    SetOuterHTMLAction(Node& node, const String& html)
         : InspectorHistory::Action("SetOuterHTML")
         , m_node(node)
-        , m_nextSibling(node->nextSibling())
+        , m_nextSibling(node.nextSibling())
         , m_html(html)
         , m_newNode(0)
         , m_history(adoptPtr(new InspectorHistory()))
@@ -241,7 +241,7 @@ public:
     }
 
 private:
-    RefPtr<Node> m_node;
+    Ref<Node> m_node;
     RefPtr<Node> m_nextSibling;
     String m_html;
     String m_oldHTML;
@@ -374,7 +374,7 @@ bool DOMEditor::removeAttribute(Element* element, const String& name, ExceptionC
     return m_history->perform(adoptPtr(new RemoveAttributeAction(element, name)), ec);
 }
 
-bool DOMEditor::setOuterHTML(Node* node, const String& html, Node** newNode, ExceptionCode& ec)
+bool DOMEditor::setOuterHTML(Node& node, const String& html, Node** newNode, ExceptionCode& ec)
 {
     OwnPtr<SetOuterHTMLAction> action = adoptPtr(new SetOuterHTMLAction(node, html));
     SetOuterHTMLAction* rawAction = action.get();
@@ -439,7 +439,7 @@ bool DOMEditor::removeAttribute(Element* element, const String& name, ErrorStrin
     return result;
 }
 
-bool DOMEditor::setOuterHTML(Node* node, const String& html, Node** newNode, ErrorString* errorString)
+bool DOMEditor::setOuterHTML(Node& node, const String& html, Node** newNode, ErrorString* errorString)
 {
     ExceptionCode ec = 0;
     bool result = setOuterHTML(node, html, newNode, ec);
index 9a0d991..8cc441f 100644 (file)
@@ -56,7 +56,7 @@ public:
     bool removeChild(Node* parentNode, Node*, ExceptionCode&);
     bool setAttribute(Element*, const String& name, const String& value, ExceptionCode&);
     bool removeAttribute(Element*, const String& name, ExceptionCode&);
-    bool setOuterHTML(Node*, const String& html, Node** newNode, ExceptionCode&);
+    bool setOuterHTML(Node&, const String& html, Node** newNode, ExceptionCode&);
     bool replaceWholeText(Text*, const String& text, ExceptionCode&);
     bool replaceChild(Node* parentNode, PassRefPtr<Node> newNode, Node* oldNode, ExceptionCode&);
     bool setNodeValue(Node* parentNode, const String& value, ExceptionCode&);
@@ -65,7 +65,7 @@ public:
     bool removeChild(Node* parentNode, Node*, ErrorString*);
     bool setAttribute(Element*, const String& name, const String& value, ErrorString*);
     bool removeAttribute(Element*, const String& name, ErrorString*);
-    bool setOuterHTML(Node*, const String& html, Node** newNode, ErrorString*);
+    bool setOuterHTML(Node&, const String& html, Node** newNode, ErrorString*);
     bool replaceWholeText(Text*, const String& text, ErrorString*);
 
 private:
index 4c1777c..3ce234f 100644 (file)
@@ -119,32 +119,32 @@ void DOMPatchSupport::patchDocument(const String& markup)
     }
 }
 
-Node* DOMPatchSupport::patchNode(Node* node, const String& markup, ExceptionCode& ec)
+Node* DOMPatchSupport::patchNode(Node& node, const String& markup, ExceptionCode& ec)
 {
     // Don't parse <html> as a fragment.
-    if (node->isDocumentNode() || (node->parentNode() && node->parentNode()->isDocumentNode())) {
+    if (node.isDocumentNode() || (node.parentNode() && node.parentNode()->isDocumentNode())) {
         patchDocument(markup);
         return 0;
     }
 
-    Node* previousSibling = node->previousSibling();
+    Node* previousSibling = node.previousSibling();
     // FIXME: This code should use one of createFragment* in markup.h
     RefPtr<DocumentFragment> fragment = DocumentFragment::create(*m_document);
     if (m_document->isHTMLDocument())
-        fragment->parseHTML(markup, node->parentElement() ? node->parentElement() : m_document->documentElement());
+        fragment->parseHTML(markup, node.parentElement() ? node.parentElement() : m_document->documentElement());
     else
-        fragment->parseXML(markup, node->parentElement() ? node->parentElement() : m_document->documentElement());
+        fragment->parseXML(markup, node.parentElement() ? node.parentElement() : m_document->documentElement());
 
     // Compose the old list.
-    ContainerNode* parentNode = node->parentNode();
-    Vector<OwnPtr<Digest> > oldList;
+    ContainerNode* parentNode = node.parentNode();
+    Vector<OwnPtr<Digest>> oldList;
     for (Node* child = parentNode->firstChild(); child; child = child->nextSibling())
         oldList.append(createDigest(child, 0));
 
     // Compose the new list.
     String markupCopy = markup.lower();
     Vector<OwnPtr<Digest> > newList;
-    for (Node* child = parentNode->firstChild(); child != node; child = child->nextSibling())
+    for (Node* child = parentNode->firstChild(); child != &node; child = child->nextSibling())
         newList.append(createDigest(child, 0));
     for (Node* child = fragment->firstChild(); child; child = child->nextSibling()) {
         if (child->hasTagName(headTag) && !child->firstChild() && markupCopy.find("</head>") == notFound)
@@ -153,13 +153,13 @@ Node* DOMPatchSupport::patchNode(Node* node, const String& markup, ExceptionCode
             continue; // HTML5 parser inserts empty <body> tag whenever it parses </head>
         newList.append(createDigest(child, &m_unusedNodesMap));
     }
-    for (Node* child = node->nextSibling(); child; child = child->nextSibling())
+    for (Node* child = node.nextSibling(); child; child = child->nextSibling())
         newList.append(createDigest(child, 0));
 
     if (!innerPatchChildren(parentNode, oldList, newList, ec)) {
         // Fall back to total replace.
         ec = 0;
-        if (!m_domEditor->replaceChild(parentNode, fragment.release(), node, ec))
+        if (!m_domEditor->replaceChild(parentNode, fragment.release(), &node, ec))
             return 0;
     }
     return previousSibling ? previousSibling->nextSibling() : parentNode->firstChild();
index dd67a63..7a822dd 100644 (file)
@@ -57,7 +57,7 @@ public:
     virtual ~DOMPatchSupport();
 
     void patchDocument(const String& markup);
-    Node* patchNode(Node*, const String& markup, ExceptionCode&);
+    Node* patchNode(Node&, const String& markup, ExceptionCode&);
 
 private:
     struct Digest;
index 1c663a1..c065c52 100644 (file)
@@ -768,7 +768,7 @@ void InspectorDOMAgent::getOuterHTML(ErrorString* errorString, int nodeId, WTF::
     if (!node)
         return;
 
-    *outerHTML = createMarkup(node);
+    *outerHTML = createMarkup(*node);
 }
 
 void InspectorDOMAgent::setOuterHTML(ErrorString* errorString, int nodeId, const String& outerHTML)
@@ -794,7 +794,7 @@ void InspectorDOMAgent::setOuterHTML(ErrorString* errorString, int nodeId, const
     }
 
     Node* newNode = 0;
-    if (!m_domEditor->setOuterHTML(node, outerHTML, &newNode, errorString))
+    if (!m_domEditor->setOuterHTML(*node, outerHTML, &newNode, errorString))
         return;
 
     if (!newNode) {
index fbe9e30..7df29ad 100644 (file)
@@ -50,6 +50,7 @@
 #include "markup.h"
 #include <wtf/ListHashSet.h>
 #include <wtf/RetainPtr.h>
+#include <wtf/text/StringBuilder.h>
 
 namespace WebCore {
 
@@ -441,7 +442,7 @@ PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(Node* node, FrameFilter* f
     }
         
     Vector<Node*> nodeList;
-    String markupString = createMarkup(node, IncludeNode, &nodeList, DoNotResolveURLs, tagNamesToFilter.get());
+    String markupString = createMarkup(*node, IncludeNode, &nodeList, DoNotResolveURLs, tagNamesToFilter.get());
     Node::NodeType nodeType = node->nodeType();
     if (nodeType != Node::DOCUMENT_NODE && nodeType != Node::DOCUMENT_TYPE_NODE)
         markupString = documentTypeString(node->document()) + markupString;
@@ -476,22 +477,21 @@ PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(Frame* frame)
 PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(Range* range)
 {
     if (!range)
-        return 0;
+        return nullptr;
     
     Node* startContainer = range->startContainer();
     if (!startContainer)
-        return 0;
+        return nullptr;
         
     Document& document = startContainer->document();
 
     Frame* frame = document.frame();
     if (!frame)
-        return 0;
-    
-    Vector<Node*> nodeList;
+        return nullptr;
     
     // FIXME: This is always "for interchange". Is that right? See the previous method.
-    String markupString = documentTypeString(document) + createMarkup(range, &nodeList, AnnotateForInterchange);
+    Vector<Node*> nodeList;
+    String markupString = documentTypeString(document) + createMarkup(*range, &nodeList, AnnotateForInterchange);
 
     return create(markupString, frame, nodeList, 0);
 }
@@ -585,16 +585,21 @@ PassRefPtr<LegacyWebArchive> LegacyWebArchive::create(const String& markupString
 PassRefPtr<LegacyWebArchive> LegacyWebArchive::createFromSelection(Frame* frame)
 {
     if (!frame)
-        return 0;
+        return nullptr;
 
     Document* document = frame->document();
     if (!document)
-        return 0;
+        return nullptr;
+
+    StringBuilder builder;
+    builder.append(documentTypeString(*document));
 
-    RefPtr<Range> selectionRange = frame->selection().toNormalizedRange();
     Vector<Node*> nodeList;
-    String markupString = documentTypeString(*document) + createMarkup(selectionRange.get(), &nodeList, AnnotateForInterchange);
+    RefPtr<Range> selectionRange = frame->selection().toNormalizedRange();
+    if (selectionRange)
+        builder.append(createMarkup(*selectionRange, &nodeList, AnnotateForInterchange));
 
+    String markupString = builder.toString();
     RefPtr<LegacyWebArchive> archive = create(markupString, frame, nodeList, 0);
     
     if (!document->isFrameSet())
index 2d27606..f7d7e68 100644 (file)
@@ -360,7 +360,7 @@ void ContextMenuController::contextMenuItemSelected(ContextMenuItem* item)
 
             Document* document = frame->document();
             ASSERT(document);
-            RefPtr<ReplaceSelectionCommand> command = ReplaceSelectionCommand::create(*document, createFragmentFromMarkup(document, item->title(), ""), replaceOptions);
+            RefPtr<ReplaceSelectionCommand> command = ReplaceSelectionCommand::create(*document, createFragmentFromMarkup(*document, item->title(), ""), replaceOptions);
             applyCommand(command);
             frameSelection.revealSelection(ScrollAlignment::alignToEdgeIfNeeded);
         }
index 6b1d9cb..9d2bc05 100644 (file)
 
 namespace WebCore {
 
-static bool isCharsetSpecifyingNode(Node* node)
+static bool isCharsetSpecifyingNode(const Node& node)
 {
-    if (!node->isHTMLElement())
+    if (!node.isHTMLElement())
         return false;
 
-    HTMLElement* element = toHTMLElement(node);
-    if (!element->hasTagName(HTMLNames::metaTag))
+    const HTMLElement& element = toHTMLElement(node);
+    if (!element.hasTagName(HTMLNames::metaTag))
         return false;
     HTMLMetaCharsetParser::AttributeList attributes;
-    if (element->hasAttributes()) {
-        for (unsigned i = 0; i < element->attributeCount(); ++i) {
-            const Attribute& attribute = element->attributeAt(i);
+    if (element.hasAttributes()) {
+        for (unsigned i = 0; i < element.attributeCount(); ++i) {
+            const Attribute& attribute = element.attributeAt(i);
             // FIXME: We should deal appropriately with the attribute if they have a namespace.
             attributes.append(std::make_pair(attribute.name().toString(), attribute.value().string()));
         }
@@ -84,9 +84,9 @@ static bool isCharsetSpecifyingNode(Node* node)
     return textEncoding.isValid();
 }
 
-static bool shouldIgnoreElement(Element* element)
+static bool shouldIgnoreElement(const Element& element)
 {
-    return element->hasTagName(HTMLNames::scriptTag) || element->hasTagName(HTMLNames::noscriptTag) || isCharsetSpecifyingNode(element);
+    return element.hasTagName(HTMLNames::scriptTag) || element.hasTagName(HTMLNames::noscriptTag) || isCharsetSpecifyingNode(element);
 }
 
 static const QualifiedName& frameOwnerURLAttributeName(const HTMLFrameOwnerElement& frameOwner)
@@ -95,64 +95,63 @@ static const QualifiedName& frameOwnerURLAttributeName(const HTMLFrameOwnerEleme
     return isHTMLObjectElement(frameOwner) ? HTMLNames::dataAttr : HTMLNames::srcAttr;
 }
 
-class SerializerMarkupAccumulator : public WebCore::MarkupAccumulator {
+class SerializerMarkupAccumulator final : public WebCore::MarkupAccumulator {
 public:
-    SerializerMarkupAccumulator(PageSerializer*, Document*, Vector<Node*>*);
+    SerializerMarkupAccumulator(PageSerializer&, Document&, Vector<Node*>*);
     virtual ~SerializerMarkupAccumulator();
 
-protected:
-    virtual void appendText(StringBuilder& out, Text*);
-    virtual void appendElement(StringBuilder& out, Element*, Namespaces*);
-    virtual void appendCustomAttributes(StringBuilder& out, Element*, Namespaces*);
-    virtual void appendEndTag(Node*);
-
 private:
-    PageSerializer* m_serializer;
-    Document* m_document;
+    PageSerializer& m_serializer;
+    Document& m_document;
+
+    virtual void appendText(StringBuilder&, const Text&) override;
+    virtual void appendElement(StringBuilder&, const Element&, Namespaces*) override;
+    virtual void appendCustomAttributes(StringBuilder&, const Element&, Namespaces*) override;
+    virtual void appendEndTag(const Node&) override;
 };
 
-SerializerMarkupAccumulator::SerializerMarkupAccumulator(PageSerializer* serializer, Document* document, Vector<Node*>* nodes)
+SerializerMarkupAccumulator::SerializerMarkupAccumulator(PageSerializer& serializer, Document& document, Vector<Node*>* nodes)
     : MarkupAccumulator(nodes, ResolveAllURLs)
     , m_serializer(serializer)
     , m_document(document)
 {
     // MarkupAccumulator does not serialize the <?xml ... line, so we add it explicitely to ensure the right encoding is specified.
-    if (m_document->isXHTMLDocument() || m_document->xmlStandalone() || m_document->isSVGDocument())
-        appendString("<?xml version=\"" + m_document->xmlVersion() + "\" encoding=\"" + m_document->charset() + "\"?>");
+    if (m_document.isXHTMLDocument() || m_document.xmlStandalone() || m_document.isSVGDocument())
+        appendString("<?xml version=\"" + m_document.xmlVersion() + "\" encoding=\"" + m_document.charset() + "\"?>");
 }
 
 SerializerMarkupAccumulator::~SerializerMarkupAccumulator()
 {
 }
 
-void SerializerMarkupAccumulator::appendText(StringBuilder& out, Text* text)
+void SerializerMarkupAccumulator::appendText(StringBuilder& out, const Text& text)
 {
-    Element* parent = text->parentElement();
-    if (parent && !shouldIgnoreElement(parent))
+    Element* parent = text.parentElement();
+    if (parent && !shouldIgnoreElement(*parent))
         MarkupAccumulator::appendText(out, text);
 }
 
-void SerializerMarkupAccumulator::appendElement(StringBuilder& out, Element* element, Namespaces* namespaces)
+void SerializerMarkupAccumulator::appendElement(StringBuilder& out, const Element& element, Namespaces* namespaces)
 {
     if (!shouldIgnoreElement(element))
         MarkupAccumulator::appendElement(out, element, namespaces);
 
-    if (element->hasTagName(HTMLNames::headTag)) {
+    if (element.hasTagName(HTMLNames::headTag)) {
         out.append("<meta charset=\"");
-        out.append(m_document->charset());
+        out.append(m_document.charset());
         out.append("\">");
     }
 
     // FIXME: For object (plugins) tags and video tag we could replace them by an image of their current contents.
 }
 
-void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, Element* element, Namespaces* namespaces)
+void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, const Element& element, Namespaces* namespaces)
 {
-    if (!element->isFrameOwnerElement())
+    if (!element.isFrameOwnerElement())
         return;
 
-    HTMLFrameOwnerElement* frameOwner = toFrameOwnerElement(element);
-    Frame* frame = frameOwner->contentFrame();
+    const HTMLFrameOwnerElement& frameOwner = toFrameOwnerElement(element);
+    Frame* frame = frameOwner.contentFrame();
     if (!frame)
         return;
 
@@ -161,13 +160,13 @@ void SerializerMarkupAccumulator::appendCustomAttributes(StringBuilder& out, Ele
         return;
 
     // We need to give a fake location to blank frames so they can be referenced by the serialized frame.
-    url = m_serializer->urlForBlankFrame(frame);
-    appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(*frameOwner), url.string()), namespaces);
+    url = m_serializer.urlForBlankFrame(frame);
+    appendAttribute(out, element, Attribute(frameOwnerURLAttributeName(frameOwner), url.string()), namespaces);
 }
 
-void SerializerMarkupAccumulator::appendEndTag(Node* node)
+void SerializerMarkupAccumulator::appendEndTag(const Node& node)
 {
-    if (node->isElementNode() && !shouldIgnoreElement(toElement(node)))
+    if (node.isElementNode() && !shouldIgnoreElement(toElement(node)))
         MarkupAccumulator::appendEndTag(node);
 }
 
@@ -210,14 +209,14 @@ void PageSerializer::serializeFrame(Frame* frame)
     }
 
     Vector<Node*> nodes;
-    SerializerMarkupAccumulator accumulator(this, document, &nodes);
+    SerializerMarkupAccumulator accumulator(*this, *document, &nodes);
     TextEncoding textEncoding(document->charset());
     CString data;
     if (!textEncoding.isValid()) {
         // FIXME: iframes used as images trigger this. We should deal with them correctly.
         return;
     }
-    String text = accumulator.serializeNodes(document->documentElement(), 0, IncludeNode);
+    String text = accumulator.serializeNodes(*document->documentElement(), 0, IncludeNode);
     CString frameHTML = textEncoding.encode(text.characters(), text.length(), EntitiesForUnencodables);
     m_resources->append(Resource(url, document->suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
     m_resourceURLs.add(url);
index 179010d..05d307a 100644 (file)
@@ -46,7 +46,7 @@ String DataObjectGtk::text() const
 String DataObjectGtk::markup() const
 {
     if (m_range)
-        return createMarkup(m_range.get(), 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
+        return createMarkup(*m_range, 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
     return m_markup;
 }
 
index 3f9dea3..45abd2d 100644 (file)
@@ -95,9 +95,12 @@ String DragData::asURL(Frame*, FilenameConversionPolicy filenamePolicy, String*
 PassRefPtr<DocumentFragment> DragData::asFragment(Frame* frame, PassRefPtr<Range>, bool, bool&) const
 {
     if (!m_platformDragData->hasMarkup())
-        return 0;
+        return nullptr;
 
-    return createFragmentFromMarkup(frame->document(), m_platformDragData->markup(), "");
+    if (!frame->document())
+        return nullptr;
+
+    return createFragmentFromMarkup(*frame->document(), m_platformDragData->markup(), "");
 }
 
 }
index c392e05..0a6a8c7 100644 (file)
@@ -161,7 +161,7 @@ void Pasteboard::writeSelection(Range* selectedRange, bool canSmartCopyOrDelete,
 {
     m_dataObject->clearAll();
     m_dataObject->setText(shouldSerializeSelectedTextForClipboard == IncludeImageAltTextForClipboard ? frame->editor().selectedTextForClipboard() : frame->editor().selectedText());
-    m_dataObject->setMarkup(createMarkup(selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
+    m_dataObject->setMarkup(createMarkup(*selectedRange, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
 
     if (m_gtkClipboard)
         PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(m_gtkClipboard, canSmartCopyOrDelete ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
@@ -224,7 +224,7 @@ void Pasteboard::writeImage(Node* node, const URL&, const String& title)
     if (!url.isEmpty()) {
         m_dataObject->setURL(url, title);
 
-        m_dataObject->setMarkup(createMarkup(toElement(node), IncludeNode, 0, ResolveAllURLs));
+        m_dataObject->setMarkup(createMarkup(*toElement(node), IncludeNode, 0, ResolveAllURLs));
     }
 
     GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
@@ -311,9 +311,11 @@ PassRefPtr<DocumentFragment> Pasteboard::documentFragment(Frame* frame, PassRefP
     chosePlainText = false;
 
     if (m_dataObject->hasMarkup()) {
-        RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(frame->document(), m_dataObject->markup(), emptyString(), DisallowScriptingAndPluginContent);
-        if (fragment)
-            return fragment.release();
+        if (frame->document()) {
+            RefPtr<DocumentFragment> fragment = createFragmentFromMarkup(*frame->document(), m_dataObject->markup(), emptyString(), DisallowScriptingAndPluginContent);
+            if (fragment)
+                return fragment.release();
+        }
     }
 
     if (!allowPlainText)
index ad98a20..ece087b 100644 (file)
@@ -361,7 +361,7 @@ PassRefPtr<DocumentFragment> Pasteboard::documentFragmentForPasteboardItemAtInde
                         if (DocumentLoader* loader = frame->loader().documentLoader())
                             loader->addAllArchiveResources(coreArchive.get());
 
-                        fragment = createFragmentFromMarkup(frame->document(), markupString.get(), mainResource->url(), DisallowScriptingContent);
+                        fragment = createFragmentFromMarkup(*frame->document(), markupString.get(), mainResource->url(), DisallowScriptingContent);
                     }
                 }
                 if (fragment)
index 1cee0ea..f0c7946 100644 (file)
@@ -613,7 +613,7 @@ void XMLHttpRequest::send(Document* document, ExceptionCode& ec)
 
         // FIXME: According to XMLHttpRequest Level 2, this should use the Document.innerHTML algorithm
         // from the HTML5 specification to serialize the document.
-        String body = createMarkup(document);
+        String body = createMarkup(*document);
 
         // FIXME: this should use value of document.inputEncoding to determine the encoding to use.
         TextEncoding encoding = UTF8Encoding();
index e077229..9a9f9a3 100644 (file)
@@ -33,7 +33,7 @@ String XMLSerializer::serializeToString(Node* node, ExceptionCode& ec)
         ec = TypeError;
         return String();
     }
-    return createMarkup(node, IncludeNode, 0, DoNotResolveURLs, 0, XMLFragmentSerialization);
+    return createMarkup(*node, IncludeNode, 0, DoNotResolveURLs, 0, XMLFragmentSerialization);
 }
 
 } // namespace WebCore
index dbba172..cf0c15a 100644 (file)
@@ -116,7 +116,7 @@ PassRefPtr<Document> XSLTProcessor::transformToDocument(Node* sourceNode)
     String resultMIMEType;
     String resultString;
     String resultEncoding;
-    if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
+    if (!transformToString(*sourceNode, resultMIMEType, resultString, resultEncoding))
         return 0;
     return createDocumentFromSource(resultString, resultEncoding, resultMIMEType, sourceNode, 0);
 }
@@ -134,7 +134,7 @@ PassRefPtr<DocumentFragment> XSLTProcessor::transformToFragment(Node* sourceNode
     if (outputDoc->isHTMLDocument())
         resultMIMEType = "text/html";
 
-    if (!transformToString(sourceNode, resultMIMEType, resultString, resultEncoding))
+    if (!transformToString(*sourceNode, resultMIMEType, resultString, resultEncoding))
         return 0;
     return createFragmentForTransformToFragment(resultString, resultMIMEType, outputDoc);
 }
index 8f72634..518e1e2 100644 (file)
@@ -45,7 +45,7 @@ public:
     ~XSLTProcessor();
 
     void setXSLStyleSheet(PassRefPtr<XSLStyleSheet> styleSheet) { m_stylesheet = styleSheet; }
-    bool transformToString(Node* source, String& resultMIMEType, String& resultString, String& resultEncoding);
+    bool transformToString(Node& source, String& resultMIMEType, String& resultString, String& resultEncoding);
     PassRefPtr<Document> createDocumentFromSource(const String& source, const String& sourceEncoding, const String& sourceMIMEType, Node* sourceNode, Frame* frame);
     
     // DOM methods
index 6b1b2e9..608be38 100644 (file)
@@ -256,7 +256,7 @@ static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStyl
 
         // According to Mozilla documentation, the node must be a Document node, an xsl:stylesheet or xsl:transform element.
         // But we just use text content regardless of node type.
-        cachedStylesheet->parseString(createMarkup(stylesheetRootNode));
+        cachedStylesheet->parseString(createMarkup(*stylesheetRootNode));
     }
 
     if (!cachedStylesheet || !cachedStylesheet->document())
@@ -265,10 +265,10 @@ static xsltStylesheetPtr xsltStylesheetPointer(RefPtr<XSLStyleSheet>& cachedStyl
     return cachedStylesheet->compileStyleSheet();
 }
 
-static inline xmlDocPtr xmlDocPtrFromNode(Node* sourceNode, bool& shouldDelete)
+static inline xmlDocPtr xmlDocPtrFromNode(Node& sourceNode, bool& shouldDelete)
 {
-    Ref<Document> ownerDocument(sourceNode->document());
-    bool sourceIsDocument = (sourceNode == &ownerDocument.get());
+    Ref<Document> ownerDocument(sourceNode.document());
+    bool sourceIsDocument = (&sourceNode == &ownerDocument.get());
 
     xmlDocPtr sourceDoc = 0;
     if (sourceIsDocument && ownerDocument->transformSource())
@@ -300,9 +300,9 @@ static inline String resultMIMEType(xmlDocPtr resultDoc, xsltStylesheetPtr sheet
     return "application/xml";
 }
 
-bool XSLTProcessor::transformToString(Node* sourceNode, String& mimeType, String& resultString, String& resultEncoding)
+bool XSLTProcessor::transformToString(Node& sourceNode, String& mimeType, String& resultString, String& resultEncoding)
 {
-    Ref<Document> ownerDocument(sourceNode->document());
+    Ref<Document> ownerDocument(sourceNode.document());
 
     setXSLTLoadCallBack(docLoaderFunc, this, ownerDocument->cachedResourceLoader());
     xsltStylesheetPtr sheet = xsltStylesheetPointer(m_stylesheet, m_stylesheetRootNode.get());
index 3ceb45d..4bd57d1 100644 (file)
@@ -1,5 +1,19 @@
 2013-10-05  Sam Weinig  <sam@webkit.org>
 
+        CTTE: Thread references through markup.h
+        https://bugs.webkit.org/show_bug.cgi?id=122403
+
+        Reviewed by Darin Adler and Andreas Kling.
+
+        * DOM/WebDOMOperations.mm:
+        (-[DOMNode markupString]):
+        (-[DOMRange markupString]):
+        * WebView/WebFrame.mm:
+        (-[WebFrame _documentFragmentWithMarkupString:baseURLString:]):
+        (-[WebFrame _documentFragmentWithNodesAsParagraphs:]):
+
+2013-10-05  Sam Weinig  <sam@webkit.org>
+
         CTTE: Pass DocumentWriter around as a reference
         https://bugs.webkit.org/show_bug.cgi?id=122396
 
index 4e70b21..74c8d99 100644 (file)
@@ -122,7 +122,7 @@ bool WebFrameFilter::shouldIncludeSubframe(Frame* frame) const
 
 - (NSString *)markupString
 {
-    return createFullMarkup(core(self));
+    return createFullMarkup(*core(self));
 }
 
 - (NSRect)_renderRect:(bool *)isReplaced
@@ -172,7 +172,7 @@ bool WebFrameFilter::shouldIncludeSubframe(Frame* frame) const
 
 - (NSString *)markupString
 {
-    return createFullMarkup(core(self));
+    return createFullMarkup(*core(self));
 }
 
 @end
index 46b376a..9a39c29 100644 (file)
@@ -721,24 +721,42 @@ static inline WebDataSource *dataSource(DocumentLoader* loader)
 
 - (DOMDocumentFragment *)_documentFragmentWithMarkupString:(NSString *)markupString baseURLString:(NSString *)baseURLString 
 {
-    if (!_private->coreFrame || !_private->coreFrame->document())
+    Frame* frame = _private->coreFrame;
+    if (!frame)
+        return nil;
+
+    Document* document = frame->document();
+    if (!document)
         return nil;
 
-    return kit(createFragmentFromMarkup(_private->coreFrame->document(), markupString, baseURLString, DisallowScriptingContent).get());
+    return kit(createFragmentFromMarkup(*document, markupString, baseURLString, DisallowScriptingContent).get());
 }
 
 - (DOMDocumentFragment *)_documentFragmentWithNodesAsParagraphs:(NSArray *)nodes
 {
-    if (!_private->coreFrame || !_private->coreFrame->document())
+    Frame* frame = _private->coreFrame;
+    if (!frame)
         return nil;
-    
+
+    Document* document = frame->document();
+    if (!document)
+        return nil;
+
     NSEnumerator *nodeEnum = [nodes objectEnumerator];
     Vector<Node*> nodesVector;
     DOMNode *node;
     while ((node = [nodeEnum nextObject]))
         nodesVector.append(core(node));
-    
-    return kit(createFragmentFromNodes(_private->coreFrame->document(), nodesVector).get());
+
+    RefPtr<DocumentFragment> fragment = document->createDocumentFragment();
+
+    for (auto node : nodesVector) {
+        RefPtr<Element> element = createDefaultParagraphElement(*document);
+        element->appendChild(node, ASSERT_NO_EXCEPTION);
+        fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
+    }
+
+    return kit(fragment.release().get());
 }
 
 - (void)_replaceSelectionWithNode:(DOMNode *)node selectReplacement:(BOOL)selectReplacement smartReplace:(BOOL)smartReplace matchStyle:(BOOL)matchStyle