Node.appendChild(null) / replaceChild(null, null) / removeChild(null) / insertBefore...
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 10 Sep 2015 18:02:15 +0000 (18:02 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 10 Sep 2015 18:02:15 +0000 (18:02 +0000)
https://bugs.webkit.org/show_bug.cgi?id=148971
<rdar://problem/22560883>
<rdar://problem/22559225>

Reviewed by Ryosuke Niwa.

LayoutTests/imported/w3c:

Rebaseline W3C tests now that more checks are passing.

* web-platform-tests/dom/interfaces-expected.txt:
* web-platform-tests/dom/nodes/Node-appendChild-expected.txt:
* web-platform-tests/dom/nodes/Node-insertBefore-expected.txt:
* web-platform-tests/dom/nodes/Node-removeChild-expected.txt:
* web-platform-tests/dom/nodes/Node-replaceChild-expected.txt:
* web-platform-tests/html/dom/interfaces-expected.txt:

Source/WebCore:

Node.appendChild(null) / replaceChild(null, null) / removeChild(null)
and insertBefore(null, ref) should throw a TypeError instead of a
NotFoundError, as per the specification:
https://dom.spec.whatwg.org/#node

The parameters are not nullable so the Web IDL specification says
we should throw a TypeError in this case.

This patch moves the null-checking from ContainerNode to the methods
on Node. The null-checking is supposed to be done by the bindings code
but our generator currently does not support this so we do the null
checking as close to the bindings as possible. The bindings code is
calling the methods on Node. This also makes sure we throw a TypeError
for null-argument when the Node is not a ContainerNode. For e.g.
Text.appendChild(null) should throw a TypeError too.

The methods on ContainerNode now take references insteaad of pointer
parameters now that the null-checking is done at the call site in
Node. This lead to a lot of code update as those methods are used
a lot throughout the code base.

No new tests, already covered by pre-existing layout tests.

Source/WebKit/mac:

ContainerNode::appendChild() now takes a Ref<Node>&& parameter so we
need to update the call site.

* WebView/WebFrame.mm:
(-[WebFrame _documentFragmentWithNodesAsParagraphs:]):

Source/WebKit2:

ContainerNode::appendChild() now takes a Ref<Node>&& parameter so we
need to update the call sites.

* WebProcess/Plugins/PDF/PDFPlugin.mm:
(WebKit::PDFPlugin::PDFPlugin):
* WebProcess/Plugins/PDF/PDFPluginAnnotation.mm:
(WebKit::PDFPluginAnnotation::attach):
(WebKit::PDFPluginAnnotation::~PDFPluginAnnotation):
* WebProcess/Plugins/PDF/PDFPluginChoiceAnnotation.mm:
(WebKit::PDFPluginChoiceAnnotation::createAnnotationElement):

LayoutTests:

Update / rebaseline tests now that we throw a different exception type.

* fast/dom/Document/replaceChild-null-oldChild-expected.txt:
* fast/dom/Document/script-tests/replaceChild-null-oldChild.js:
* fast/dom/Node/fragment-mutation-expected.txt:
* fast/dom/Node/fragment-mutation.html:
* fast/dom/incompatible-operations-expected.txt:
* fast/dom/incompatible-operations.html:
* fast/dom/move-nodes-across-documents.html:
* fast/dom/processing-instruction-appendChild-exceptions-expected.txt:
* fast/dom/processing-instruction-appendChild-exceptions.xhtml:
* fast/dom/setter-type-enforcement-expected.txt:
* fast/dom/timer-clear-interval-in-handler-and-generate-error-expected.txt:
* fast/inspector-support/uncaught-dom8-exception.html:

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

131 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/dom/Document/replaceChild-null-oldChild-expected.txt
LayoutTests/fast/dom/Document/script-tests/replaceChild-null-oldChild.js
LayoutTests/fast/dom/Node/fragment-mutation-expected.txt
LayoutTests/fast/dom/Node/fragment-mutation.html
LayoutTests/fast/dom/incompatible-operations-expected.txt
LayoutTests/fast/dom/incompatible-operations.html
LayoutTests/fast/dom/move-nodes-across-documents.html
LayoutTests/fast/dom/processing-instruction-appendChild-exceptions-expected.txt
LayoutTests/fast/dom/processing-instruction-appendChild-exceptions.xhtml
LayoutTests/fast/dom/timer-clear-interval-in-handler-and-generate-error-expected.txt
LayoutTests/fast/events/remove-target-with-shadow-in-drag-expected.txt
LayoutTests/fast/inspector-support/uncaught-dom8-exception.html
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/dom/interfaces-expected.txt
LayoutTests/imported/w3c/web-platform-tests/dom/nodes/Node-appendChild-expected.txt
LayoutTests/imported/w3c/web-platform-tests/dom/nodes/Node-insertBefore-expected.txt
LayoutTests/imported/w3c/web-platform-tests/dom/nodes/Node-removeChild-expected.txt
LayoutTests/imported/w3c/web-platform-tests/dom/nodes/Node-replaceChild-expected.txt
LayoutTests/imported/w3c/web-platform-tests/html/dom/interfaces-expected.txt
LayoutTests/js/dom/dot-node-base-exception-expected.txt
LayoutTests/js/dom/script-tests/dot-node-base-exception.js
Source/WebCore/ChangeLog
Source/WebCore/Modules/plugins/YouTubePluginReplacement.cpp
Source/WebCore/bindings/objc/DOMHTML.mm
Source/WebCore/dom/Attr.cpp
Source/WebCore/dom/Attr.h
Source/WebCore/dom/CDATASection.cpp
Source/WebCore/dom/CDATASection.h
Source/WebCore/dom/Comment.cpp
Source/WebCore/dom/Comment.h
Source/WebCore/dom/ContainerNode.cpp
Source/WebCore/dom/ContainerNode.h
Source/WebCore/dom/DOMImplementation.cpp
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/Document.h
Source/WebCore/dom/DocumentFragment.cpp
Source/WebCore/dom/DocumentFragment.h
Source/WebCore/dom/DocumentType.cpp
Source/WebCore/dom/DocumentType.h
Source/WebCore/dom/Element.cpp
Source/WebCore/dom/Element.h
Source/WebCore/dom/EntityReference.cpp
Source/WebCore/dom/EntityReference.h
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/Node.h
Source/WebCore/dom/ProcessingInstruction.cpp
Source/WebCore/dom/ProcessingInstruction.h
Source/WebCore/dom/Range.cpp
Source/WebCore/dom/ShadowRoot.cpp
Source/WebCore/dom/ShadowRoot.h
Source/WebCore/dom/Text.cpp
Source/WebCore/dom/Text.h
Source/WebCore/editing/AppendNodeCommand.cpp
Source/WebCore/editing/AppendNodeCommand.h
Source/WebCore/editing/CompositeEditCommand.cpp
Source/WebCore/editing/DeleteSelectionCommand.cpp
Source/WebCore/editing/Editor.cpp
Source/WebCore/editing/EditorCommand.cpp
Source/WebCore/editing/InsertLineBreakCommand.cpp
Source/WebCore/editing/InsertNodeBeforeCommand.cpp
Source/WebCore/editing/InsertParagraphSeparatorCommand.cpp
Source/WebCore/editing/MergeIdenticalElementsCommand.cpp
Source/WebCore/editing/RemoveNodeCommand.cpp
Source/WebCore/editing/RemoveNodeCommand.h
Source/WebCore/editing/ReplaceNodeWithSpanCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.cpp
Source/WebCore/editing/SplitElementCommand.cpp
Source/WebCore/editing/SplitTextNodeCommand.cpp
Source/WebCore/editing/WrapContentsInDummySpanCommand.cpp
Source/WebCore/editing/cocoa/EditorCocoa.mm
Source/WebCore/editing/htmlediting.cpp
Source/WebCore/editing/htmlediting.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/BaseChooserOnlyDateAndTimeInputType.cpp
Source/WebCore/html/ColorInputType.cpp
Source/WebCore/html/FTPDirectoryDocument.cpp
Source/WebCore/html/HTMLDetailsElement.cpp
Source/WebCore/html/HTMLElement.cpp
Source/WebCore/html/HTMLElement.h
Source/WebCore/html/HTMLImageElement.cpp
Source/WebCore/html/HTMLKeygenElement.cpp
Source/WebCore/html/HTMLMeterElement.cpp
Source/WebCore/html/HTMLOptionElement.cpp
Source/WebCore/html/HTMLProgressElement.cpp
Source/WebCore/html/HTMLScriptElement.cpp
Source/WebCore/html/HTMLScriptElement.h
Source/WebCore/html/HTMLSelectElement.cpp
Source/WebCore/html/HTMLTableElement.cpp
Source/WebCore/html/HTMLTableElement.h
Source/WebCore/html/HTMLTableRowElement.cpp
Source/WebCore/html/HTMLTableRowElement.h
Source/WebCore/html/HTMLTableSectionElement.cpp
Source/WebCore/html/HTMLTemplateElement.cpp
Source/WebCore/html/HTMLTemplateElement.h
Source/WebCore/html/HTMLTextAreaElement.cpp
Source/WebCore/html/ImageDocument.cpp
Source/WebCore/html/MediaDocument.cpp
Source/WebCore/html/PluginDocument.cpp
Source/WebCore/html/RangeInputType.cpp
Source/WebCore/html/SearchInputType.cpp
Source/WebCore/html/TextFieldInputType.cpp
Source/WebCore/html/ValidationMessage.cpp
Source/WebCore/html/shadow/MediaControlElements.cpp
Source/WebCore/html/shadow/MediaControls.cpp
Source/WebCore/html/shadow/MediaControlsApple.cpp
Source/WebCore/html/shadow/SliderThumbElement.cpp
Source/WebCore/html/shadow/SliderThumbElement.h
Source/WebCore/html/shadow/mac/ImageControlsRootElementMac.cpp
Source/WebCore/html/track/VTTCue.cpp
Source/WebCore/html/track/VTTRegion.cpp
Source/WebCore/html/track/VTTRegion.h
Source/WebCore/html/track/WebVTTElement.cpp
Source/WebCore/html/track/WebVTTElement.h
Source/WebCore/inspector/InspectorCSSAgent.cpp
Source/WebCore/page/DragController.cpp
Source/WebCore/page/ios/FrameIOS.mm
Source/WebCore/svg/SVGScriptElement.cpp
Source/WebCore/svg/SVGScriptElement.h
Source/WebCore/svg/SVGUseElement.cpp
Source/WebCore/xml/XMLTreeViewer.cpp
Source/WebKit/mac/ChangeLog
Source/WebKit/mac/WebView/WebFrame.mm
Source/WebKit/mac/WebView/WebHTMLView.mm
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/Plugins/PDF/PDFPlugin.mm
Source/WebKit2/WebProcess/Plugins/PDF/PDFPluginAnnotation.mm
Source/WebKit2/WebProcess/Plugins/PDF/PDFPluginChoiceAnnotation.mm

index 5bd40a5..4240e17 100644 (file)
@@ -1,3 +1,27 @@
+2015-09-10  Chris Dumez  <cdumez@apple.com>
+
+        Node.appendChild(null) / replaceChild(null, null) / removeChild(null) / insertBefore(null, ref) should throw a TypeError
+        https://bugs.webkit.org/show_bug.cgi?id=148971
+        <rdar://problem/22560883>
+        <rdar://problem/22559225>
+
+        Reviewed by Ryosuke Niwa.
+
+        Update / rebaseline tests now that we throw a different exception type.
+
+        * fast/dom/Document/replaceChild-null-oldChild-expected.txt:
+        * fast/dom/Document/script-tests/replaceChild-null-oldChild.js:
+        * fast/dom/Node/fragment-mutation-expected.txt:
+        * fast/dom/Node/fragment-mutation.html:
+        * fast/dom/incompatible-operations-expected.txt:
+        * fast/dom/incompatible-operations.html:
+        * fast/dom/move-nodes-across-documents.html:
+        * fast/dom/processing-instruction-appendChild-exceptions-expected.txt:
+        * fast/dom/processing-instruction-appendChild-exceptions.xhtml:
+        * fast/dom/setter-type-enforcement-expected.txt:
+        * fast/dom/timer-clear-interval-in-handler-and-generate-error-expected.txt:
+        * fast/inspector-support/uncaught-dom8-exception.html:
+
 2015-09-10  Brady Eidson  <beidson@apple.com>
 
         Mark some more W3C IDB tests as flaky.
 2015-09-10  Brady Eidson  <beidson@apple.com>
 
         Mark some more W3C IDB tests as flaky.
index bbb166b..af5a469 100644 (file)
@@ -3,7 +3,7 @@ Test behavior of Document.replaceChild() when oldChild is null.
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS document.replaceChild(document.firstChild, null) threw exception Error: NotFoundError: DOM Exception 8.
+PASS document.replaceChild(document.firstChild, null) threw exception TypeError: Type error.
 PASS successfullyParsed is true
 
 TEST COMPLETE
 PASS successfullyParsed is true
 
 TEST COMPLETE
index da92528..c09bf1b 100644 (file)
@@ -1,3 +1,3 @@
 description('Test behavior of Document.replaceChild() when oldChild is null.');
 
 description('Test behavior of Document.replaceChild() when oldChild is null.');
 
-shouldThrow('document.replaceChild(document.firstChild, null)', '"Error: NotFoundError: DOM Exception 8"');
+shouldThrow('document.replaceChild(document.firstChild, null)', '"TypeError: Type error"');
index 0f04e66..4ba9524 100644 (file)
@@ -2,12 +2,12 @@ This test creates a fragment containing three elements: "B", "U", and "P", attem
 
 Inserting an element in front of the next item in fragment should not affect the result: PASS
 Appending an element at the end of the fragment should not affect the result: PASS
 
 Inserting an element in front of the next item in fragment should not affect the result: PASS
 Appending an element at the end of the fragment should not affect the result: PASS
-Continually re-appending removed element to the fragment should eventually throw NOT_FOUND_ERR: PASS
+Continually re-appending removed element to the fragment should eventually throw a TypeError: PASS
 
 This test creates a fragment containing three elements: "B", "U", and "P", attempts to insertBefore this fragment and studies effects of mutation events on the fragment.
 
 Inserting an element in front of the next item in fragment should not affect the result: PASS
 Appending an element at the end of the fragment should not affect the result: PASS
 
 This test creates a fragment containing three elements: "B", "U", and "P", attempts to insertBefore this fragment and studies effects of mutation events on the fragment.
 
 Inserting an element in front of the next item in fragment should not affect the result: PASS
 Appending an element at the end of the fragment should not affect the result: PASS
-Continually re-appending removed element to the fragment should eventually throw NOT_FOUND_ERR: PASS
+Continually re-appending removed element to the fragment should eventually throw a TypeError: PASS
 
 
 
 
index 84e67f6..489497f 100644 (file)
@@ -36,15 +36,15 @@ function produceNodeNameString(nodes)
     return result;
 }
 
     return result;
 }
 
-function expectException(code)
+function expectTypeError()
 {
     return function(stash, exception) {
         if (!exception)
 {
     return function(stash, exception) {
         if (!exception)
-            return "FAIL, expected exception with code " + code + ". The resulting fragment was: \"" + produceNodeNameString(stash) + "\".";
+            return "FAIL, expected TypeError. The resulting fragment was: \"" + produceNodeNameString(stash) + "\".";
 
 
-        if (code == exception.code)
+        if (exception.name = "TypeError")
             return "PASS";
             return "PASS";
-        return "FAIL, expected exception code: " + code + ", was: " + exception + ".";
+        return "FAIL, expected TypeError, was: " + exception.name + ".";
     }
 }
 
     }
 }
 
@@ -119,10 +119,10 @@ function runTest(methodName, method)
         frag.appendChild(extra);
     }, expectNodes("BUP"));
 
         frag.appendChild(extra);
     }, expectNodes("BUP"));
 
-    testFragment(method, "Continually re-appending removed element to the fragment should eventually throw NOT_FOUND_ERR", function(evt, frag, stash)
+    testFragment(method, "Continually re-appending removed element to the fragment should eventually throw a TypeError", function(evt, frag, stash)
     {
         stash.insertBefore(frag.lastChild, stash.firstChild);
     {
         stash.insertBefore(frag.lastChild, stash.firstChild);
-    }, expectException(8), true);
+    }, expectTypeError(), true);
     printLog(methodName);
 }
 function runTests()
     printLog(methodName);
 }
 function runTests()
index d5764c1..85ccd54 100644 (file)
@@ -3,9 +3,9 @@ This test checks the behavior of DOM operations when called on non-DOM or incomp
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS aNode.appendChild(aDOMImplementation) threw exception Error: NotFoundError: DOM Exception 8.
-PASS aNode.appendChild('knort') threw exception Error: NotFoundError: DOM Exception 8.
-PASS aNode.appendChild(void 0) threw exception Error: NotFoundError: DOM Exception 8.
+PASS aNode.appendChild(aDOMImplementation) threw exception TypeError: Type error.
+PASS aNode.appendChild('knort') threw exception TypeError: Type error.
+PASS aNode.appendChild(void 0) threw exception TypeError: Type error.
 PASS aNode.isSameNode(aDOMImplementation) is false
 PASS aNode.isSameNode('foo') is false
 PASS aNode.isSameNode(void 0) is false
 PASS aNode.isSameNode(aDOMImplementation) is false
 PASS aNode.isSameNode('foo') is false
 PASS aNode.isSameNode(void 0) is false
index 21aa71a..2f0e4af 100644 (file)
@@ -28,11 +28,11 @@ var aNode = document.createElement("div");
 var aSecondNode = document.createElement("div");
 aNode.appendChild(aSecondNode);
 
 var aSecondNode = document.createElement("div");
 aNode.appendChild(aSecondNode);
 
-shouldThrow("aNode.appendChild(aDOMImplementation)", "'Error: NotFoundError: DOM Exception 8'");
+shouldThrow("aNode.appendChild(aDOMImplementation)", "'TypeError: Type error'");
 
 
-shouldThrow("aNode.appendChild('knort')", "'Error: NotFoundError: DOM Exception 8'");
+shouldThrow("aNode.appendChild('knort')", "'TypeError: Type error'");
 
 
-shouldThrow("aNode.appendChild(void 0)", "'Error: NotFoundError: DOM Exception 8'");
+shouldThrow("aNode.appendChild(void 0)", "'TypeError: Type error'");
 
 shouldBeFalse("aNode.isSameNode(aDOMImplementation)");
 shouldBeFalse("aNode.isSameNode('foo')");
 
 shouldBeFalse("aNode.isSameNode(aDOMImplementation)");
 shouldBeFalse("aNode.isSameNode('foo')");
index d3501a1..3881f04 100644 (file)
@@ -179,7 +179,7 @@ function run()
     runTest(function() {
         iframeDoc.appendChild(document.doctype);
         console.log(document.doctype);
     runTest(function() {
         iframeDoc.appendChild(document.doctype);
         console.log(document.doctype);
-    }, 'NotFoundError');
+    }, 'TypeError');
 
     // When setting a boundary of the range in a different
     // document, the call should succeed and the range should be collapsed.
 
     // When setting a boundary of the range in a different
     // document, the call should succeed and the range should be collapsed.
index 7a13868..0e3bdf2 100644 (file)
@@ -3,7 +3,7 @@ Test that appropriate exceptions are thrown when adding children to a Processing
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS pi.appendChild(null) threw exception Error: HierarchyRequestError: DOM Exception 3.
+PASS pi.appendChild(null) threw exception TypeError: Type error.
 PASS pi.appendChild(div) threw exception Error: HierarchyRequestError: DOM Exception 3.
 PASS pi.appendChild(textNode) threw exception Error: HierarchyRequestError: DOM Exception 3.
 PASS successfullyParsed is true
 PASS pi.appendChild(div) threw exception Error: HierarchyRequestError: DOM Exception 3.
 PASS pi.appendChild(textNode) threw exception Error: HierarchyRequestError: DOM Exception 3.
 PASS successfullyParsed is true
index b002899..c902ba4 100644 (file)
@@ -5,7 +5,7 @@
 <![CDATA[
 description("Test that appropriate exceptions are thrown when adding children to a ProcessingInstruction.");
 var pi = document.createProcessingInstruction('target', 'data');
 <![CDATA[
 description("Test that appropriate exceptions are thrown when adding children to a ProcessingInstruction.");
 var pi = document.createProcessingInstruction('target', 'data');
-shouldThrow("pi.appendChild(null)", "'Error: HierarchyRequestError: DOM Exception 3'");
+shouldThrow("pi.appendChild(null)", "'TypeError: Type error'");
 var div = document.createElement('div');
 shouldThrow("pi.appendChild(div)", "'Error: HierarchyRequestError: DOM Exception 3'");
 var textNode = document.createTextNode('sometext');
 var div = document.createElement('div');
 shouldThrow("pi.appendChild(div)", "'Error: HierarchyRequestError: DOM Exception 3'");
 var textNode = document.createTextNode('sometext');
index 99aac6a..5f2fd51 100644 (file)
@@ -1,2 +1,2 @@
-CONSOLE MESSAGE: line 10: NotFoundError: DOM Exception 8: An attempt was made to reference a Node in a context where it does not exist.
+CONSOLE MESSAGE: line 10: TypeError: Type error
 
 
index 45c119f..128964f 100644 (file)
@@ -1,3 +1,3 @@
-CONSOLE MESSAGE: line 34: NotFoundError: DOM Exception 8: An attempt was made to reference a Node in a context where it does not exist.
-CONSOLE MESSAGE: line 34: NotFoundError: DOM Exception 8: An attempt was made to reference a Node in a context where it does not exist.
+CONSOLE MESSAGE: line 34: TypeError: Type error
+CONSOLE MESSAGE: line 34: TypeError: Type error
 PASS. DRT didn't crash.
 PASS. DRT didn't crash.
index bc608f4..5fa4e5b 100644 (file)
@@ -6,7 +6,7 @@ function onload()
 {
     if (window.testRunner)
         testRunner.dumpAsText();
 {
     if (window.testRunner)
         testRunner.dumpAsText();
-    document.appendChild();
+    document.body.removeAttributeNode(document.createAttribute("doesNotExist"));
 }
 
 </script>
 }
 
 </script>
index f1e1626..44cc7b1 100644 (file)
@@ -1,3 +1,21 @@
+2015-09-10  Chris Dumez  <cdumez@apple.com>
+
+        Node.appendChild(null) / replaceChild(null, null) / removeChild(null) / insertBefore(null, ref) should throw a TypeError
+        https://bugs.webkit.org/show_bug.cgi?id=148971
+        <rdar://problem/22560883>
+        <rdar://problem/22559225>
+
+        Reviewed by Ryosuke Niwa.
+
+        Rebaseline W3C tests now that more checks are passing.
+
+        * web-platform-tests/dom/interfaces-expected.txt:
+        * web-platform-tests/dom/nodes/Node-appendChild-expected.txt:
+        * web-platform-tests/dom/nodes/Node-insertBefore-expected.txt:
+        * web-platform-tests/dom/nodes/Node-removeChild-expected.txt:
+        * web-platform-tests/dom/nodes/Node-replaceChild-expected.txt:
+        * web-platform-tests/html/dom/interfaces-expected.txt:
+
 2015-09-09  Dewei Zhu  <dewei_zhu@apple.com>
 
         Document.characterSet should return "UTF-8" by default.
 2015-09-09  Dewei Zhu  <dewei_zhu@apple.com>
 
         Document.characterSet should return "UTF-8" by default.
index 64951b4..aaf8d42 100644 (file)
@@ -634,21 +634,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on xmlDoc with too fe
     [native code]
 }" did not throw
 PASS Node interface: xmlDoc must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: xmlDoc must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: xmlDoc must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: xmlDoc must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on xmlDoc with too few arguments must throw TypeError 
 PASS Node interface: xmlDoc must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: xmlDoc must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on xmlDoc with too few arguments must throw TypeError 
 PASS Node interface: xmlDoc must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: xmlDoc must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on xmlDoc with too few arguments must throw TypeError 
 PASS EventTarget interface: xmlDoc must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: xmlDoc must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on xmlDoc with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -793,21 +787,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.createDoc
     [native code]
 }" did not throw
 PASS Node interface: document.createDocumentFragment() must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.createDocumentFragment() must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" did not throw
 PASS Node interface: document.createDocumentFragment() must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: document.createDocumentFragment() must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.createDocumentFragment() with too few arguments must throw TypeError 
 PASS Node interface: document.createDocumentFragment() must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.createDocumentFragment() must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on document.createDocumentFragment() with too few arguments must throw TypeError 
 PASS Node interface: document.createDocumentFragment() must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.createDocumentFragment() must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.createDocumentFragment() with too few arguments must throw TypeError 
 PASS EventTarget interface: document.createDocumentFragment() must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.createDocumentFragment() must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createDocumentFragment() with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -915,21 +903,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.doctype w
     [native code]
 }" did not throw
 PASS Node interface: document.doctype must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.doctype must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.doctype must inherit property "appendChild" with the proper type (41) 
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.doctype must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.doctype with too few arguments must throw TypeError 
 PASS Node interface: document.doctype must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.doctype must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling replaceChild(Node,Node) on document.doctype with too few arguments must throw TypeError 
 PASS Node interface: document.doctype must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.doctype must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.doctype with too few arguments must throw TypeError 
 PASS EventTarget interface: document.doctype must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.doctype must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.doctype with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -1187,21 +1169,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on element with too f
     [native code]
 }" did not throw
 PASS Node interface: element must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: element must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on element with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" did not throw
 PASS Node interface: element must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: element must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on element with too few arguments must throw TypeError 
 PASS Node interface: element must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: element must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on element with too few arguments must throw TypeError 
 PASS Node interface: element must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: element must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on element with too few arguments must throw TypeError 
 PASS EventTarget interface: element must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: element must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on element with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -1409,21 +1385,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.createTex
     [native code]
 }" did not throw
 PASS Node interface: document.createTextNode("abc") must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.createTextNode("abc") must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.createTextNode("abc") must inherit property "appendChild" with the proper type (41) 
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.createTextNode("abc") must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.createTextNode("abc") with too few arguments must throw TypeError 
 PASS Node interface: document.createTextNode("abc") must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.createTextNode("abc") must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling replaceChild(Node,Node) on document.createTextNode("abc") with too few arguments must throw TypeError 
 PASS Node interface: document.createTextNode("abc") must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.createTextNode("abc") must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.createTextNode("abc") with too few arguments must throw TypeError 
 PASS EventTarget interface: document.createTextNode("abc") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.createTextNode("abc") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createTextNode("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -1543,21 +1513,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on xmlDoc.createProce
     [native code]
 }" did not throw
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "appendChild" with the proper type (41) 
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError 
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling replaceChild(Node,Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError 
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError 
 PASS EventTarget interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: xmlDoc.createProcessingInstruction("abc", "def") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on xmlDoc.createProcessingInstruction("abc", "def") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -1673,21 +1637,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.createCom
     [native code]
 }" did not throw
 PASS Node interface: document.createComment("abc") must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.createComment("abc") must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.createComment("abc") must inherit property "appendChild" with the proper type (41) 
     [native code]
 }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.createComment("abc") must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.createComment("abc") with too few arguments must throw TypeError 
 PASS Node interface: document.createComment("abc") must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.createComment("abc") must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling replaceChild(Node,Node) on document.createComment("abc") with too few arguments must throw TypeError 
 PASS Node interface: document.createComment("abc") must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.createComment("abc") must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.createComment("abc") with too few arguments must throw TypeError 
 PASS EventTarget interface: document.createComment("abc") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.createComment("abc") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createComment("abc") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
index 3a289e8..b130caf 100644 (file)
@@ -1,12 +1,12 @@
 
 
 
 
-FAIL WebIDL tests assert_throws: function "function () { document.body.appendChild(null) }" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS WebIDL tests 
 PASS Appending to a leaf node. 
 PASS Appending to a leaf node. 
-FAIL Appending null to a text node assert_throws: function "function () { node.appendChild(null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Appending null to a text node 
 PASS Appending to a text node 
 PASS Appending to a text node 
-FAIL Appending null to a comment assert_throws: function "function () { node.appendChild(null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Appending null to a comment 
 PASS Appending to a comment 
 PASS Appending to a comment 
-FAIL Appending null to a doctype assert_throws: function "function () { node.appendChild(null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Appending null to a doctype 
 PASS Appending to a doctype 
 PASS Appending a document 
 PASS Adopting an orphan 
 PASS Appending to a doctype 
 PASS Appending a document 
 PASS Adopting an orphan 
index 56bcd2a..c662233 100644 (file)
@@ -1,12 +1,12 @@
 
 
-FAIL Calling insertBefore with a non-Node first argument must throw TypeError. assert_throws: function "function () { document.body.insertBefore(null, null) }" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
-FAIL Calling insertBefore with a non-Node first argument on a leaf node DocumentType must throw TypeError. assert_throws: function "function () { node.insertBefore(null, null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Calling insertBefore with a non-Node first argument must throw TypeError. 
+PASS Calling insertBefore with a non-Node first argument on a leaf node DocumentType must throw TypeError. 
 PASS Calling insertBefore an a leaf node DocumentType must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore an a leaf node DocumentType must throw HIERARCHY_REQUEST_ERR. 
-FAIL Calling insertBefore with a non-Node first argument on a leaf node Text must throw TypeError. assert_throws: function "function () { node.insertBefore(null, null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Calling insertBefore with a non-Node first argument on a leaf node Text must throw TypeError. 
 PASS Calling insertBefore an a leaf node Text must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore an a leaf node Text must throw HIERARCHY_REQUEST_ERR. 
-FAIL Calling insertBefore with a non-Node first argument on a leaf node Comment must throw TypeError. assert_throws: function "function () { node.insertBefore(null, null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Calling insertBefore with a non-Node first argument on a leaf node Comment must throw TypeError. 
 PASS Calling insertBefore an a leaf node Comment must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore an a leaf node Comment must throw HIERARCHY_REQUEST_ERR. 
-FAIL Calling insertBefore with a non-Node first argument on a leaf node ProcessingInstruction must throw TypeError. assert_throws: function "function () { node.insertBefore(null, null) }" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
+PASS Calling insertBefore with a non-Node first argument on a leaf node ProcessingInstruction must throw TypeError. 
 PASS Calling insertBefore an a leaf node ProcessingInstruction must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore with an inclusive ancestor of the context object must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore with a reference child whose parent is not the context node must throw a NotFoundError. 
 PASS Calling insertBefore an a leaf node ProcessingInstruction must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore with an inclusive ancestor of the context object must throw HIERARCHY_REQUEST_ERR. 
 PASS Calling insertBefore with a reference child whose parent is not the context node must throw a NotFoundError. 
index 02910bf..1397c4e 100644 (file)
@@ -27,5 +27,5 @@ PASS Calling removeChild on a text from a synthetic document with no children sh
 PASS Passing a detached comment from a synthetic document to removeChild should not affect it. 
 PASS Passing a non-detached comment from a synthetic document to removeChild should not affect it. 
 PASS Calling removeChild on a comment from a synthetic document with no children should throw NOT_FOUND_ERR. 
 PASS Passing a detached comment from a synthetic document to removeChild should not affect it. 
 PASS Passing a non-detached comment from a synthetic document to removeChild should not affect it. 
 PASS Calling removeChild on a comment from a synthetic document with no children should throw NOT_FOUND_ERR. 
-FAIL Passing a value that is not a Node reference to removeChild should throw TypeError. assert_throws: function "function () { document.body.removeChild(null) }" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Passing a value that is not a Node reference to removeChild should throw TypeError. 
 b
 b
index e7f70fa..d17c8b5 100644 (file)
@@ -1,7 +1,5 @@
 
 
-FAIL Passing null to replaceChild should throw a TypeError. assert_throws: function "function () {
-    a.replaceChild(null, null);
-  }" did not throw
+PASS Passing null to replaceChild should throw a TypeError. 
 FAIL If child's parent is not the context node, a NotFoundError exception should be thrown assert_throws: function "function () {
     a.replaceChild(a, c);
   }" threw object "Error: HierarchyRequestError: DOM Exception 3" that is not a DOMException NotFoundError: property "code" is equal to 3, expected 8
 FAIL If child's parent is not the context node, a NotFoundError exception should be thrown assert_throws: function "function () {
     a.replaceChild(a, c);
   }" threw object "Error: HierarchyRequestError: DOM Exception 3" that is not a DOMException NotFoundError: property "code" is equal to 3, expected 8
index f2cc403..1159d74 100644 (file)
@@ -1225,21 +1225,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on iframe.contentDocu
     [native code]
 }" did not throw
 PASS Node interface: iframe.contentDocument must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: iframe.contentDocument must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: iframe.contentDocument must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: iframe.contentDocument must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on iframe.contentDocument with too few arguments must throw TypeError 
 PASS Node interface: iframe.contentDocument must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: iframe.contentDocument must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on iframe.contentDocument with too few arguments must throw TypeError 
 PASS Node interface: iframe.contentDocument must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: iframe.contentDocument must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on iframe.contentDocument with too few arguments must throw TypeError 
 PASS EventTarget interface: iframe.contentDocument must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: iframe.contentDocument must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on iframe.contentDocument with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -1551,21 +1545,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.implement
     [native code]
 }" did not throw
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" threw object "Error: HierarchyRequestError: DOM Exception 3" ("HierarchyRequestError") expected object "TypeError" ("TypeError")
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError 
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError 
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.implementation.createDocument(null, "", null) must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError 
 PASS EventTarget interface: document.implementation.createDocument(null, "", null) must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.implementation.createDocument(null, "", null) must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.implementation.createDocument(null, "", null) with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
@@ -2171,21 +2159,15 @@ FAIL Node interface: calling isDefaultNamespace(DOMString) on document.createEle
     [native code]
 }" did not throw
 PASS Node interface: document.createElement("noscript") must inherit property "insertBefore" with the proper type (40) 
     [native code]
 }" did not throw
 PASS Node interface: document.createElement("noscript") must inherit property "insertBefore" with the proper type (40) 
-FAIL Node interface: calling insertBefore(Node,Node) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
+FAIL Node interface: calling insertBefore(Node,Node) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 1 arguments function "function () {
     [native code]
     [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+}" did not throw
 PASS Node interface: document.createElement("noscript") must inherit property "appendChild" with the proper type (41) 
 PASS Node interface: document.createElement("noscript") must inherit property "appendChild" with the proper type (41) 
-FAIL Node interface: calling appendChild(Node) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling appendChild(Node) on document.createElement("noscript") with too few arguments must throw TypeError 
 PASS Node interface: document.createElement("noscript") must inherit property "replaceChild" with the proper type (42) 
 PASS Node interface: document.createElement("noscript") must inherit property "replaceChild" with the proper type (42) 
-FAIL Node interface: calling replaceChild(Node,Node) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" did not throw
+PASS Node interface: calling replaceChild(Node,Node) on document.createElement("noscript") with too few arguments must throw TypeError 
 PASS Node interface: document.createElement("noscript") must inherit property "removeChild" with the proper type (43) 
 PASS Node interface: document.createElement("noscript") must inherit property "removeChild" with the proper type (43) 
-FAIL Node interface: calling removeChild(Node) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
-    [native code]
-}" threw object "Error: NotFoundError: DOM Exception 8" ("NotFoundError") expected object "TypeError" ("TypeError")
+PASS Node interface: calling removeChild(Node) on document.createElement("noscript") with too few arguments must throw TypeError 
 PASS EventTarget interface: document.createElement("noscript") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
 PASS EventTarget interface: document.createElement("noscript") must inherit property "addEventListener" with the proper type (0) 
 FAIL EventTarget interface: calling addEventListener(DOMString,EventListener,boolean) on document.createElement("noscript") with too few arguments must throw TypeError assert_throws: Called with 0 arguments function "function () {
     [native code]
index f4406cb..36d53b4 100644 (file)
@@ -3,7 +3,7 @@ This test checks that a correct exception is raised when calculating the base va
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS (document.appendChild()).foobar() threw exception Error: NotFoundError: DOM Exception 8.
+PASS (document.appendChild()).foobar() threw exception TypeError: Type error.
 PASS successfullyParsed is true
 
 TEST COMPLETE
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 9f362a7..71d4719 100644 (file)
@@ -3,4 +3,4 @@ description(
 );
 
 // Should be a DOM exception, not just some "TypeError: Null value".
 );
 
 // Should be a DOM exception, not just some "TypeError: Null value".
-shouldThrow('(document.appendChild()).foobar()', '"Error: NotFoundError: DOM Exception 8"');
+shouldThrow('(document.appendChild()).foobar()', '"TypeError: Type error"');
index 577c840..15d4325 100644 (file)
@@ -1,3 +1,35 @@
+2015-09-10  Chris Dumez  <cdumez@apple.com>
+
+        Node.appendChild(null) / replaceChild(null, null) / removeChild(null) / insertBefore(null, ref) should throw a TypeError
+        https://bugs.webkit.org/show_bug.cgi?id=148971
+        <rdar://problem/22560883>
+        <rdar://problem/22559225>
+
+        Reviewed by Ryosuke Niwa.
+
+        Node.appendChild(null) / replaceChild(null, null) / removeChild(null)
+        and insertBefore(null, ref) should throw a TypeError instead of a
+        NotFoundError, as per the specification:
+        https://dom.spec.whatwg.org/#node
+
+        The parameters are not nullable so the Web IDL specification says
+        we should throw a TypeError in this case.
+
+        This patch moves the null-checking from ContainerNode to the methods
+        on Node. The null-checking is supposed to be done by the bindings code
+        but our generator currently does not support this so we do the null
+        checking as close to the bindings as possible. The bindings code is
+        calling the methods on Node. This also makes sure we throw a TypeError
+        for null-argument when the Node is not a ContainerNode. For e.g.
+        Text.appendChild(null) should throw a TypeError too.
+
+        The methods on ContainerNode now take references insteaad of pointer
+        parameters now that the null-checking is done at the call site in
+        Node. This lead to a lot of code update as those methods are used
+        a lot throughout the code base.
+
+        No new tests, already covered by pre-existing layout tests.
+
 2015-09-10  Daniel Bates  <dabates@apple.com>
 
         Write a test to ensure we don't regress processing of tasks when page defers loading
 2015-09-10  Daniel Bates  <dabates@apple.com>
 
         Write a test to ensure we don't regress processing of tasks when page defers loading
index 8f96c9f..b44cfd2 100644 (file)
@@ -81,9 +81,9 @@ bool YouTubePluginReplacement::installReplacement(ShadowRoot* root)
 {
     m_embedShadowElement = YouTubeEmbedShadowElement::create(m_parentElement->document());
 
 {
     m_embedShadowElement = YouTubeEmbedShadowElement::create(m_parentElement->document());
 
-    root->appendChild(m_embedShadowElement.get());
+    root->appendChild(*m_embedShadowElement);
 
 
-    RefPtr<HTMLIFrameElement> iframeElement = HTMLIFrameElement::create(HTMLNames::iframeTag, m_parentElement->document());
+    Ref<HTMLIFrameElement> iframeElement = HTMLIFrameElement::create(HTMLNames::iframeTag, m_parentElement->document());
     if (m_attributes.contains("width"))
         iframeElement->setAttribute(HTMLNames::widthAttr, AtomicString("100%", AtomicString::ConstructFromLiteral));
     
     if (m_attributes.contains("width"))
         iframeElement->setAttribute(HTMLNames::widthAttr, AtomicString("100%", AtomicString::ConstructFromLiteral));
     
@@ -98,7 +98,7 @@ bool YouTubePluginReplacement::installReplacement(ShadowRoot* root)
     
     // Disable frame flattening for this iframe.
     iframeElement->setAttribute(HTMLNames::scrollingAttr, AtomicString("no", AtomicString::ConstructFromLiteral));
     
     // Disable frame flattening for this iframe.
     iframeElement->setAttribute(HTMLNames::scrollingAttr, AtomicString("no", AtomicString::ConstructFromLiteral));
-    m_embedShadowElement->appendChild(iframeElement);
+    m_embedShadowElement->appendChild(WTF::move(iframeElement));
 
     return true;
 }
 
     return true;
 }
index 0de22ce..027595e 100644 (file)
@@ -152,7 +152,7 @@ using namespace WebCore;
 - (DOMDocumentFragment *)createDocumentFragmentWithText:(NSString *)text
 {
     // FIXME: Since this is not a contextual fragment, it won't handle whitespace properly.
 - (DOMDocumentFragment *)createDocumentFragmentWithText:(NSString *)text
 {
     // FIXME: Since this is not a contextual fragment, it won't handle whitespace properly.
-    return kit(createFragmentFromText(core(self)->createRange(), text).get());
+    return kit(createFragmentFromText(core(self)->createRange(), text).ptr());
 }
 
 @end
 }
 
 @end
index 18570f1..ac7b66f 100644 (file)
@@ -138,11 +138,11 @@ void Attr::setNodeValue(const String& v, ExceptionCode& ec)
     setValue(v, ec);
 }
 
     setValue(v, ec);
 }
 
-RefPtr<Node> Attr::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> Attr::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
 {
-    RefPtr<Attr> clone = adoptRef(new Attr(targetDocument, qualifiedName(), value()));
-    cloneChildNodes(clone.get());
-    return clone.release();
+    Ref<Attr> clone = adoptRef(*new Attr(targetDocument, qualifiedName(), value()));
+    cloneChildNodes(clone);
+    return WTF::move(clone);
 }
 
 // DOM Section 1.1.1
 }
 
 // DOM Section 1.1.1
index c7a94f9..124c6d7 100644 (file)
@@ -80,7 +80,7 @@ private:
 
     virtual String nodeValue() const override { return value(); }
     virtual void setNodeValue(const String&, ExceptionCode&) override;
 
     virtual String nodeValue() const override { return value(); }
     virtual void setNodeValue(const String&, ExceptionCode&) override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
 
     virtual bool isAttributeNode() const override { return true; }
     virtual bool childTypeAllowed(NodeType) const override;
 
     virtual bool isAttributeNode() const override { return true; }
     virtual bool childTypeAllowed(NodeType) const override;
index c59bf1e..afd7322 100644 (file)
@@ -46,7 +46,7 @@ Node::NodeType CDATASection::nodeType() const
     return CDATA_SECTION_NODE;
 }
 
     return CDATA_SECTION_NODE;
 }
 
-RefPtr<Node> CDATASection::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> CDATASection::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
     return create(targetDocument, data());
 }
 {
     return create(targetDocument, data());
 }
index bf5a61c..d6b9937 100644 (file)
@@ -36,7 +36,7 @@ private:
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
     virtual bool childTypeAllowed(NodeType) const override;
     virtual Ref<Text> virtualCreate(const String&) override;
 };
     virtual bool childTypeAllowed(NodeType) const override;
     virtual Ref<Text> virtualCreate(const String&) override;
 };
index 4c74aaf..4125a6e 100644 (file)
@@ -46,7 +46,7 @@ Node::NodeType Comment::nodeType() const
     return COMMENT_NODE;
 }
 
     return COMMENT_NODE;
 }
 
-RefPtr<Node> Comment::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> Comment::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
     return create(targetDocument, data());
 }
 {
     return create(targetDocument, data());
 }
index fcac60a..1566323 100644 (file)
@@ -36,7 +36,7 @@ private:
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
     virtual bool childTypeAllowed(NodeType) const override;
 };
 
     virtual bool childTypeAllowed(NodeType) const override;
 };
 
index f0631b6..6314175 100644 (file)
@@ -76,7 +76,7 @@ static void collectChildrenAndRemoveFromOldParent(Node& node, NodeVector& nodes,
     if (!is<DocumentFragment>(node)) {
         nodes.append(node);
         if (ContainerNode* oldParent = node.parentNode())
     if (!is<DocumentFragment>(node)) {
         nodes.append(node);
         if (ContainerNode* oldParent = node.parentNode())
-            oldParent->removeChild(&node, ec);
+            oldParent->removeChild(node, ec);
         return;
     }
 
         return;
     }
 
@@ -146,13 +146,13 @@ ContainerNode::~ContainerNode()
     removeDetachedChildren();
 }
 
     removeDetachedChildren();
 }
 
-static inline bool isChildTypeAllowed(ContainerNode* newParent, Node* child)
+static inline bool isChildTypeAllowed(ContainerNode& newParent, Node& child)
 {
 {
-    if (!child->isDocumentFragment())
-        return newParent->childTypeAllowed(child->nodeType());
+    if (!child.isDocumentFragment())
+        return newParent.childTypeAllowed(child.nodeType());
 
 
-    for (Node* node = child->firstChild(); node; node = node->nextSibling()) {
-        if (!newParent->childTypeAllowed(node->nodeType()))
+    for (Node* node = child.firstChild(); node; node = node->nextSibling()) {
+        if (!newParent.childTypeAllowed(node->nodeType()))
             return false;
     }
     return true;
             return false;
     }
     return true;
@@ -169,23 +169,19 @@ static inline bool isInTemplateContent(const Node* node)
 #endif
 }
 
 #endif
 }
 
-static inline bool containsConsideringHostElements(const Node* newChild, const Node* newParent)
+static inline bool containsConsideringHostElements(const Node& newChild, const Node& newParent)
 {
 {
-    return (newParent->isInShadowTree() || isInTemplateContent(newParent))
-        ? newChild->containsIncludingHostElements(newParent)
-        : newChild->contains(newParent);
+    return (newParent.isInShadowTree() || isInTemplateContent(&newParent))
+        ? newChild.containsIncludingHostElements(&newParent)
+        : newChild.contains(&newParent);
 }
 
 }
 
-static inline ExceptionCode checkAcceptChild(ContainerNode* newParent, Node* newChild, Node* oldChild)
+static inline ExceptionCode checkAcceptChild(ContainerNode& newParent, Node& newChild, Node* oldChild)
 {
 {
-    // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
-    if (!newChild)
-        return NOT_FOUND_ERR;
-
     // Use common case fast path if possible.
     // Use common case fast path if possible.
-    if ((newChild->isElementNode() || newChild->isTextNode()) && newParent->isElementNode()) {
-        ASSERT(!newParent->isReadOnlyNode());
-        ASSERT(!newParent->isDocumentTypeNode());
+    if ((newChild.isElementNode() || newChild.isTextNode()) && newParent.isElementNode()) {
+        ASSERT(!newParent.isReadOnlyNode());
+        ASSERT(!newParent.isDocumentTypeNode());
         ASSERT(isChildTypeAllowed(newParent, newChild));
         if (containsConsideringHostElements(newChild, newParent))
             return HIERARCHY_REQUEST_ERR;
         ASSERT(isChildTypeAllowed(newParent, newChild));
         if (containsConsideringHostElements(newChild, newParent))
             return HIERARCHY_REQUEST_ERR;
@@ -193,17 +189,17 @@ static inline ExceptionCode checkAcceptChild(ContainerNode* newParent, Node* new
     }
 
     // This should never happen, but also protect release builds from tree corruption.
     }
 
     // This should never happen, but also protect release builds from tree corruption.
-    ASSERT(!newChild->isPseudoElement());
-    if (newChild->isPseudoElement())
+    ASSERT(!newChild.isPseudoElement());
+    if (newChild.isPseudoElement())
         return HIERARCHY_REQUEST_ERR;
 
         return HIERARCHY_REQUEST_ERR;
 
-    if (newParent->isReadOnlyNode())
+    if (newParent.isReadOnlyNode())
         return NO_MODIFICATION_ALLOWED_ERR;
     if (containsConsideringHostElements(newChild, newParent))
         return HIERARCHY_REQUEST_ERR;
 
         return NO_MODIFICATION_ALLOWED_ERR;
     if (containsConsideringHostElements(newChild, newParent))
         return HIERARCHY_REQUEST_ERR;
 
-    if (oldChild && is<Document>(*newParent)) {
-        if (!downcast<Document>(*newParent).canReplaceChild(newChild, oldChild))
+    if (oldChild && is<Document>(newParent)) {
+        if (!downcast<Document>(newParent).canReplaceChild(newChild, *oldChild))
             return HIERARCHY_REQUEST_ERR;
     } else if (!isChildTypeAllowed(newParent, newChild))
         return HIERARCHY_REQUEST_ERR;
             return HIERARCHY_REQUEST_ERR;
     } else if (!isChildTypeAllowed(newParent, newChild))
         return HIERARCHY_REQUEST_ERR;
@@ -211,12 +207,12 @@ static inline ExceptionCode checkAcceptChild(ContainerNode* newParent, Node* new
     return 0;
 }
 
     return 0;
 }
 
-static inline bool checkAcceptChildGuaranteedNodeTypes(ContainerNode* newParent, Node* newChild, ExceptionCode& ec)
+static inline bool checkAcceptChildGuaranteedNodeTypes(ContainerNode& newParent, Node& newChild, ExceptionCode& ec)
 {
 {
-    ASSERT(!newParent->isReadOnlyNode());
-    ASSERT(!newParent->isDocumentTypeNode());
+    ASSERT(!newParent.isReadOnlyNode());
+    ASSERT(!newParent.isDocumentTypeNode());
     ASSERT(isChildTypeAllowed(newParent, newChild));
     ASSERT(isChildTypeAllowed(newParent, newChild));
-    if (newChild->contains(newParent)) {
+    if (newChild.contains(&newParent)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
@@ -224,25 +220,19 @@ static inline bool checkAcceptChildGuaranteedNodeTypes(ContainerNode* newParent,
     return true;
 }
 
     return true;
 }
 
-static inline bool checkAddChild(ContainerNode* newParent, Node* newChild, ExceptionCode& ec)
+static inline bool checkAddChild(ContainerNode& newParent, Node& newChild, ExceptionCode& ec)
 {
 {
-    ec = checkAcceptChild(newParent, newChild, 0);
-    if (ec)
-        return false;
-
-    return true;
+    ec = checkAcceptChild(newParent, newChild, nullptr);
+    return !ec;
 }
 
 }
 
-static inline bool checkReplaceChild(ContainerNode* newParent, Node* newChild, Node* oldChild, ExceptionCode& ec)
+static inline bool checkReplaceChild(ContainerNode& newParent, Node& newChild, Node& oldChild, ExceptionCode& ec)
 {
 {
-    ec = checkAcceptChild(newParent, newChild, oldChild);
-    if (ec)
-        return false;
-
-    return true;
+    ec = checkAcceptChild(newParent, newChild, &oldChild);
+    return !ec;
 }
 
 }
 
-bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)
+bool ContainerNode::insertBefore(Ref<Node>&& newChild, Node* refChild, ExceptionCode& ec)
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
@@ -254,10 +244,10 @@ bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, Exce
 
     // insertBefore(node, 0) is equivalent to appendChild(node)
     if (!refChild)
 
     // insertBefore(node, 0) is equivalent to appendChild(node)
     if (!refChild)
-        return appendChild(newChild, ec);
+        return appendChild(WTF::move(newChild), ec);
 
     // Make sure adding the new child is OK.
 
     // Make sure adding the new child is OK.
-    if (!checkAddChild(this, newChild.get(), ec))
+    if (!checkAddChild(*this, newChild, ec))
         return false;
 
     // NOT_FOUND_ERR: Raised if refChild is not a child of this node
         return false;
 
     // NOT_FOUND_ERR: Raised if refChild is not a child of this node
@@ -266,20 +256,20 @@ bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, Exce
         return false;
     }
 
         return false;
     }
 
-    if (refChild->previousSibling() == newChild || refChild == newChild) // nothing to do
+    if (refChild->previousSibling() == newChild.ptr() || refChild == newChild.ptr()) // nothing to do
         return true;
 
     Ref<Node> next(*refChild);
 
     NodeVector targets;
         return true;
 
     Ref<Node> next(*refChild);
 
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParent(*newChild.get(), targets, ec);
+    collectChildrenAndRemoveFromOldParent(newChild, targets, ec);
     if (ec)
         return false;
     if (targets.isEmpty())
         return true;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
     if (ec)
         return false;
     if (targets.isEmpty())
         return true;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
-    if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
+    if (!checkAcceptChildGuaranteedNodeTypes(*this, newChild, ec))
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
@@ -390,7 +380,7 @@ void ContainerNode::parserInsertBefore(PassRefPtr<Node> newChild, Node* nextChil
     newChild->setNeedsStyleRecalc(ReconstructRenderTree);
 }
 
     newChild->setNeedsStyleRecalc(ReconstructRenderTree);
 }
 
-bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec)
+bool ContainerNode::replaceChild(Ref<Node>&& newChild, Node& oldChild, ExceptionCode& ec)
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
@@ -400,48 +390,43 @@ bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, Exce
 
     ec = 0;
 
 
     ec = 0;
 
-    if (oldChild == newChild) // nothing to do
+    if (&oldChild == newChild.ptr()) // nothing to do
         return true;
 
         return true;
 
-    if (!oldChild) {
-        ec = NOT_FOUND_ERR;
-        return false;
-    }
-
     // Make sure replacing the old child with the new is ok
     // Make sure replacing the old child with the new is ok
-    if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
+    if (!checkReplaceChild(*this, newChild, oldChild, ec))
         return false;
 
     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
         return false;
 
     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
-    if (oldChild->parentNode() != this) {
+    if (oldChild.parentNode() != this) {
         ec = NOT_FOUND_ERR;
         return false;
     }
 
     ChildListMutationScope mutation(*this);
 
         ec = NOT_FOUND_ERR;
         return false;
     }
 
     ChildListMutationScope mutation(*this);
 
-    RefPtr<Node> next = oldChild->nextSibling();
+    RefPtr<Node> next = oldChild.nextSibling();
 
     // Remove the node we're replacing
 
     // Remove the node we're replacing
-    Ref<Node> removedChild(*oldChild);
+    Ref<Node> removedChild(oldChild);
     removeChild(oldChild, ec);
     if (ec)
         return false;
 
     removeChild(oldChild, ec);
     if (ec)
         return false;
 
-    if (next && (next->previousSibling() == newChild || next == newChild)) // nothing to do
+    if (next && (next->previousSibling() == newChild.ptr() || next == newChild.ptr())) // nothing to do
         return true;
 
     // Does this one more time because removeChild() fires a MutationEvent.
         return true;
 
     // Does this one more time because removeChild() fires a MutationEvent.
-    if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
+    if (!checkReplaceChild(*this, newChild, oldChild, ec))
         return false;
 
     NodeVector targets;
         return false;
 
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParent(*newChild.get(), targets, ec);
+    collectChildrenAndRemoveFromOldParent(newChild, targets, ec);
     if (ec)
         return false;
 
     // Does this yet another check because collectChildrenAndRemoveFromOldParent() fires a MutationEvent.
     if (ec)
         return false;
 
     // Does this yet another check because collectChildrenAndRemoveFromOldParent() fires a MutationEvent.
-    if (!checkReplaceChild(this, newChild.get(), oldChild, ec))
+    if (!checkReplaceChild(*this, newChild, oldChild, ec))
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
@@ -515,7 +500,7 @@ void ContainerNode::disconnectDescendantFrames()
     disconnectSubframesIfNeeded(*this, RootAndDescendants);
 }
 
     disconnectSubframesIfNeeded(*this, RootAndDescendants);
 }
 
-bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec)
+bool ContainerNode::removeChild(Node& oldChild, ExceptionCode& ec)
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
 {
     // Check that this node is not "floating".
     // If it is, it can be deleted as a side effect of sending mutation events.
@@ -532,12 +517,12 @@ bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec)
     }
 
     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
     }
 
     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
-    if (!oldChild || oldChild->parentNode() != this) {
+    if (oldChild.parentNode() != this) {
         ec = NOT_FOUND_ERR;
         return false;
     }
 
         ec = NOT_FOUND_ERR;
         return false;
     }
 
-    Ref<Node> child(*oldChild);
+    Ref<Node> child(oldChild);
 
     document().removeFocusedNodeOfSubtree(child.ptr());
 
 
     document().removeFocusedNodeOfSubtree(child.ptr());
 
@@ -670,7 +655,7 @@ void ContainerNode::removeChildren()
     dispatchSubtreeModifiedEvent();
 }
 
     dispatchSubtreeModifiedEvent();
 }
 
-bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
+bool ContainerNode::appendChild(Ref<Node>&& newChild, ExceptionCode& ec)
 {
     Ref<ContainerNode> protect(*this);
 
 {
     Ref<ContainerNode> protect(*this);
 
@@ -681,14 +666,14 @@ bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
     ec = 0;
 
     // Make sure adding the new child is ok
     ec = 0;
 
     // Make sure adding the new child is ok
-    if (!checkAddChild(this, newChild.get(), ec))
+    if (!checkAddChild(*this, newChild, ec))
         return false;
 
         return false;
 
-    if (newChild == m_lastChild) // nothing to do
-        return newChild;
+    if (newChild.ptr() == m_lastChild) // nothing to do
+        return true;
 
     NodeVector targets;
 
     NodeVector targets;
-    collectChildrenAndRemoveFromOldParent(*newChild.get(), targets, ec);
+    collectChildrenAndRemoveFromOldParent(newChild, targets, ec);
     if (ec)
         return false;
 
     if (ec)
         return false;
 
@@ -696,7 +681,7 @@ bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
         return true;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
         return true;
 
     // We need this extra check because collectChildrenAndRemoveFromOldParent() can fire mutation events.
-    if (!checkAcceptChildGuaranteedNodeTypes(this, newChild.get(), ec))
+    if (!checkAcceptChildGuaranteedNodeTypes(*this, newChild, ec))
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
         return false;
 
     InspectorInstrumentation::willInsertDOMNode(document(), *this);
@@ -759,16 +744,16 @@ void ContainerNode::childrenChanged(const ChildChange& change)
     invalidateNodeListAndCollectionCachesInAncestors();
 }
 
     invalidateNodeListAndCollectionCachesInAncestors();
 }
 
-void ContainerNode::cloneChildNodes(ContainerNode* clone)
+void ContainerNode::cloneChildNodes(ContainerNode& clone)
 {
     ExceptionCode ec = 0;
 {
     ExceptionCode ec = 0;
-    Document& targetDocument = clone->document();
+    Document& targetDocument = clone.document();
     for (Node* child = firstChild(); child && !ec; child = child->nextSibling()) {
     for (Node* child = firstChild(); child && !ec; child = child->nextSibling()) {
-        RefPtr<Node> clonedChild = child->cloneNodeInternal(targetDocument, CloningOperation::SelfWithTemplateContent);
-        clone->appendChild(clonedChild, ec);
+        Ref<Node> clonedChild = child->cloneNodeInternal(targetDocument, CloningOperation::SelfWithTemplateContent);
+        clone.appendChild(clonedChild.copyRef(), ec);
 
 
-        if (!ec && is<ContainerNode>(child))
-            downcast<ContainerNode>(child)->cloneChildNodes(downcast<ContainerNode>(clonedChild.get()));
+        if (!ec && is<ContainerNode>(*child))
+            downcast<ContainerNode>(*child).cloneChildNodes(downcast<ContainerNode>(clonedChild.get()));
     }
 }
 
     }
 }
 
@@ -947,7 +932,7 @@ void ContainerNode::append(Vector<NodeOrString>&& nodeOrStringVector, ExceptionC
     if (ec || !node)
         return;
 
     if (ec || !node)
         return;
 
-    appendChild(node.release(), ec);
+    appendChild(node.releaseNonNull(), ec);
 }
 
 void ContainerNode::prepend(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
 }
 
 void ContainerNode::prepend(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
@@ -956,7 +941,7 @@ void ContainerNode::prepend(Vector<NodeOrString>&& nodeOrStringVector, Exception
     if (ec || !node)
         return;
 
     if (ec || !node)
         return;
 
-    insertBefore(node.release(), firstChild(), ec);
+    insertBefore(node.releaseNonNull(), firstChild(), ec);
 }
 
 HTMLCollection* ContainerNode::cachedHTMLCollection(CollectionType type)
 }
 
 HTMLCollection* ContainerNode::cachedHTMLCollection(CollectionType type)
index 0452400..a6b10a7 100644 (file)
@@ -102,10 +102,10 @@ public:
     WEBCORE_EXPORT unsigned countChildNodes() const;
     WEBCORE_EXPORT Node* traverseToChildAt(unsigned) const;
 
     WEBCORE_EXPORT unsigned countChildNodes() const;
     WEBCORE_EXPORT Node* traverseToChildAt(unsigned) const;
 
-    bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
-    bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
-    WEBCORE_EXPORT bool removeChild(Node* child, ExceptionCode& = ASSERT_NO_EXCEPTION);
-    WEBCORE_EXPORT bool appendChild(PassRefPtr<Node> newChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
+    bool insertBefore(Ref<Node>&& newChild, Node* refChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
+    bool replaceChild(Ref<Node>&& newChild, Node& oldChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
+    WEBCORE_EXPORT bool removeChild(Node& child, ExceptionCode& = ASSERT_NO_EXCEPTION);
+    WEBCORE_EXPORT bool appendChild(Ref<Node>&& newChild, ExceptionCode& = ASSERT_NO_EXCEPTION);
 
     // These methods are only used during parsing.
     // They don't send DOM mutation events or handle reparenting.
 
     // These methods are only used during parsing.
     // They don't send DOM mutation events or handle reparenting.
@@ -117,7 +117,7 @@ public:
     void removeChildren();
     void takeAllChildrenFrom(ContainerNode*);
 
     void removeChildren();
     void takeAllChildrenFrom(ContainerNode*);
 
-    void cloneChildNodes(ContainerNode* clone);
+    void cloneChildNodes(ContainerNode& clone);
 
     enum ChildChangeType { ElementInserted, ElementRemoved, TextInserted, TextRemoved, TextChanged, AllChildrenRemoved, NonContentsChildChanged };
     enum ChildChangeSource { ChildChangeSourceParser, ChildChangeSourceAPI };
 
     enum ChildChangeType { ElementInserted, ElementRemoved, TextInserted, TextRemoved, TextChanged, AllChildrenRemoved, NonContentsChildChanged };
     enum ChildChangeSource { ChildChangeSourceParser, ChildChangeSourceAPI };
index a4a3f8d..633d291 100644 (file)
@@ -231,9 +231,9 @@ RefPtr<Document> DOMImplementation::createDocument(const String& namespaceURI,
     }
 
     if (doctype)
     }
 
     if (doctype)
-        doc->appendChild(doctype);
+        doc->appendChild(*doctype);
     if (documentElement)
     if (documentElement)
-        doc->appendChild(documentElement.release());
+        doc->appendChild(documentElement.releaseNonNull());
 
     return doc;
 }
 
     return doc;
 }
index d0cdc57..676bdd8 100644 (file)
@@ -1009,7 +1009,7 @@ RefPtr<Node> Document::adoptNode(PassRefPtr<Node> source, ExceptionCode& ec)
             }
         }
         if (source->parentNode()) {
             }
         }
         if (source->parentNode()) {
-            source->parentNode()->removeChild(source.get(), ec);
+            source->parentNode()->removeChild(*source, ec);
             if (ec)
                 return nullptr;
         }
             if (ec)
                 return nullptr;
         }
@@ -1547,7 +1547,7 @@ void Document::setTitle(const String& title)
         if (!headElement)
             return;
         m_titleElement = createElement(titleTag, false);
         if (!headElement)
             return;
         m_titleElement = createElement(titleTag, false);
-        headElement->appendChild(m_titleElement, ASSERT_NO_EXCEPTION);
+        headElement->appendChild(*m_titleElement, ASSERT_NO_EXCEPTION);
     }
 
     // The DOM API has no method of specifying direction, so assume LTR.
     }
 
     // The DOM API has no method of specifying direction, so assume LTR.
@@ -2518,11 +2518,10 @@ void Document::setBodyOrFrameset(PassRefPtr<HTMLElement> prpNewBody, ExceptionCo
         newBody = downcast<HTMLElement>(node.get());
     }
 
         newBody = downcast<HTMLElement>(node.get());
     }
 
-    HTMLElement* b = bodyOrFrameset();
-    if (!b)
-        documentElement()->appendChild(newBody.release(), ec);
+    if (auto* body = bodyOrFrameset())
+        documentElement()->replaceChild(newBody.releaseNonNull(), *body, ec);
     else
     else
-        documentElement()->replaceChild(newBody.release(), b, ec);
+        documentElement()->appendChild(newBody.releaseNonNull(), ec);
 }
 
 HTMLHeadElement* Document::head()
 }
 
 HTMLHeadElement* Document::head()
@@ -3326,13 +3325,9 @@ bool Document::childTypeAllowed(NodeType type) const
     return false;
 }
 
     return false;
 }
 
-bool Document::canReplaceChild(Node* newChild, Node* oldChild)
+bool Document::canReplaceChild(Node& newChild, Node& oldChild)
 {
 {
-    if (!oldChild)
-        // ContainerNode::replaceChild will raise a NOT_FOUND_ERR.
-        return true;
-
-    if (oldChild->nodeType() == newChild->nodeType())
+    if (oldChild.nodeType() == newChild.nodeType())
         return true;
 
     int numDoctypes = 0;
         return true;
 
     int numDoctypes = 0;
@@ -3341,7 +3336,7 @@ bool Document::canReplaceChild(Node* newChild, Node* oldChild)
     // First, check how many doctypes and elements we have, not counting
     // the child we're about to remove.
     for (Node* c = firstChild(); c; c = c->nextSibling()) {
     // First, check how many doctypes and elements we have, not counting
     // the child we're about to remove.
     for (Node* c = firstChild(); c; c = c->nextSibling()) {
-        if (c == oldChild)
+        if (c == &oldChild)
             continue;
         
         switch (c->nodeType()) {
             continue;
         
         switch (c->nodeType()) {
@@ -3357,8 +3352,8 @@ bool Document::canReplaceChild(Node* newChild, Node* oldChild)
     }
     
     // Then, see how many doctypes and elements might be added by the new child.
     }
     
     // Then, see how many doctypes and elements might be added by the new child.
-    if (newChild->isDocumentFragment()) {
-        for (Node* c = newChild->firstChild(); c; c = c->nextSibling()) {
+    if (newChild.isDocumentFragment()) {
+        for (Node* c = newChild.firstChild(); c; c = c->nextSibling()) {
             switch (c->nodeType()) {
             case ATTRIBUTE_NODE:
             case CDATA_SECTION_NODE:
             switch (c->nodeType()) {
             case ATTRIBUTE_NODE:
             case CDATA_SECTION_NODE:
@@ -3381,7 +3376,7 @@ bool Document::canReplaceChild(Node* newChild, Node* oldChild)
             }
         }
     } else {
             }
         }
     } else {
-        switch (newChild->nodeType()) {
+        switch (newChild.nodeType()) {
         case ATTRIBUTE_NODE:
         case CDATA_SECTION_NODE:
         case DOCUMENT_FRAGMENT_NODE:
         case ATTRIBUTE_NODE:
         case CDATA_SECTION_NODE:
         case DOCUMENT_FRAGMENT_NODE:
@@ -3409,7 +3404,7 @@ bool Document::canReplaceChild(Node* newChild, Node* oldChild)
     return true;
 }
 
     return true;
 }
 
-RefPtr<Node> Document::cloneNodeInternal(Document&, CloningOperation type)
+Ref<Node> Document::cloneNodeInternal(Document&, CloningOperation type)
 {
     Ref<Document> clone = cloneDocumentWithoutChildren();
     clone->cloneDataFromDocument(*this);
 {
     Ref<Document> clone = cloneDocumentWithoutChildren();
     clone->cloneDataFromDocument(*this);
@@ -3418,7 +3413,7 @@ RefPtr<Node> Document::cloneNodeInternal(Document&, CloningOperation type)
     case CloningOperation::SelfWithTemplateContent:
         break;
     case CloningOperation::Everything:
     case CloningOperation::SelfWithTemplateContent:
         break;
     case CloningOperation::Everything:
-        cloneChildNodes(clone.ptr());
+        cloneChildNodes(clone);
         break;
     }
     return WTF::move(clone);
         break;
     }
     return WTF::move(clone);
index 4f09b7c..e0ad1bc 100644 (file)
@@ -746,7 +746,7 @@ public:
     void nodeChildrenWillBeRemoved(ContainerNode&);
     // nodeWillBeRemoved is only safe when removing one node at a time.
     void nodeWillBeRemoved(Node&);
     void nodeChildrenWillBeRemoved(ContainerNode&);
     // nodeWillBeRemoved is only safe when removing one node at a time.
     void nodeWillBeRemoved(Node&);
-    bool canReplaceChild(Node* newChild, Node* oldChild);
+    bool canReplaceChild(Node& newChild, Node& oldChild);
 
     void textInserted(Node*, unsigned offset, unsigned length);
     void textRemoved(Node*, unsigned offset, unsigned length);
 
     void textInserted(Node*, unsigned offset, unsigned length);
     void textRemoved(Node*, unsigned offset, unsigned length);
@@ -1310,7 +1310,7 @@ private:
     virtual String nodeName() const override final;
     virtual NodeType nodeType() const override final;
     virtual bool childTypeAllowed(NodeType) const override final;
     virtual String nodeName() const override final;
     virtual NodeType nodeType() const override final;
     virtual bool childTypeAllowed(NodeType) const override final;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override final;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override final;
     void cloneDataFromDocument(const Document&);
 
     virtual void refScriptExecutionContext() override final { ref(); }
     void cloneDataFromDocument(const Document&);
 
     virtual void refScriptExecutionContext() override final { ref(); }
index 4fab58e..f9b38a0 100644 (file)
@@ -67,18 +67,18 @@ bool DocumentFragment::childTypeAllowed(NodeType type) const
     }
 }
 
     }
 }
 
-RefPtr<Node> DocumentFragment::cloneNodeInternal(Document& targetDocument, CloningOperation type)
+Ref<Node> DocumentFragment::cloneNodeInternal(Document& targetDocument, CloningOperation type)
 {
 {
-    RefPtr<DocumentFragment> clone = create(targetDocument);
+    Ref<DocumentFragment> clone = create(targetDocument);
     switch (type) {
     case CloningOperation::OnlySelf:
     case CloningOperation::SelfWithTemplateContent:
         break;
     case CloningOperation::Everything:
     switch (type) {
     case CloningOperation::OnlySelf:
     case CloningOperation::SelfWithTemplateContent:
         break;
     case CloningOperation::Everything:
-        cloneChildNodes(clone.get());
+        cloneChildNodes(clone);
         break;
     }
         break;
     }
-    return clone;
+    return WTF::move(clone);
 }
 
 void DocumentFragment::parseHTML(const String& source, Element* contextElement, ParserContentPolicy parserContentPolicy)
 }
 
 void DocumentFragment::parseHTML(const String& source, Element* contextElement, ParserContentPolicy parserContentPolicy)
index d07e034..6eb1ed6 100644 (file)
@@ -48,7 +48,7 @@ protected:
 
 private:
     virtual NodeType nodeType() const override final;
 
 private:
     virtual NodeType nodeType() const override final;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
     virtual bool childTypeAllowed(NodeType) const override;
 };
 
     virtual bool childTypeAllowed(NodeType) const override;
 };
 
index 67e3d53..c19d018 100644 (file)
@@ -51,7 +51,7 @@ Node::NodeType DocumentType::nodeType() const
     return DOCUMENT_TYPE_NODE;
 }
 
     return DOCUMENT_TYPE_NODE;
 }
 
-RefPtr<Node> DocumentType::cloneNodeInternal(Document& documentTarget, CloningOperation)
+Ref<Node> DocumentType::cloneNodeInternal(Document& documentTarget, CloningOperation)
 {
     return create(documentTarget, m_name, m_publicId, m_systemId);
 }
 {
     return create(documentTarget, m_name, m_publicId, m_systemId);
 }
index c7a1d9b..c79c0ce 100644 (file)
@@ -52,7 +52,7 @@ private:
     virtual URL baseURI() const override;
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
     virtual URL baseURI() const override;
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
 
     String m_name;
     String m_publicId;
 
     String m_name;
     String m_publicId;
index 675000a..3a89061 100644 (file)
@@ -312,38 +312,37 @@ void Element::dispatchSimulatedClick(Event* underlyingEvent, SimulatedClickMouse
     EventDispatcher::dispatchSimulatedClick(this, underlyingEvent, eventOptions, visualOptions);
 }
 
     EventDispatcher::dispatchSimulatedClick(this, underlyingEvent, eventOptions, visualOptions);
 }
 
-RefPtr<Node> Element::cloneNodeInternal(Document& targetDocument, CloningOperation type)
+Ref<Node> Element::cloneNodeInternal(Document& targetDocument, CloningOperation type)
 {
     switch (type) {
     case CloningOperation::OnlySelf:
     case CloningOperation::SelfWithTemplateContent:
         return cloneElementWithoutChildren(targetDocument);
     case CloningOperation::Everything:
 {
     switch (type) {
     case CloningOperation::OnlySelf:
     case CloningOperation::SelfWithTemplateContent:
         return cloneElementWithoutChildren(targetDocument);
     case CloningOperation::Everything:
-        return cloneElementWithChildren(targetDocument);
+        break;
     }
     }
-    ASSERT_NOT_REACHED();
-    return nullptr;
+    return cloneElementWithChildren(targetDocument);
 }
 
 }
 
-RefPtr<Element> Element::cloneElementWithChildren(Document& targetDocument)
+Ref<Element> Element::cloneElementWithChildren(Document& targetDocument)
 {
 {
-    RefPtr<Element> clone = cloneElementWithoutChildren(targetDocument);
-    cloneChildNodes(clone.get());
-    return clone.release();
+    Ref<Element> clone = cloneElementWithoutChildren(targetDocument);
+    cloneChildNodes(clone);
+    return clone;
 }
 
 }
 
-RefPtr<Element> Element::cloneElementWithoutChildren(Document& targetDocument)
+Ref<Element> Element::cloneElementWithoutChildren(Document& targetDocument)
 {
 {
-    RefPtr<Element> clone = cloneElementWithoutAttributesAndChildren(targetDocument);
+    Ref<Element> clone = cloneElementWithoutAttributesAndChildren(targetDocument);
     // This will catch HTML elements in the wrong namespace that are not correctly copied.
     // This is a sanity check as HTML overloads some of the DOM methods.
     ASSERT(isHTMLElement() == clone->isHTMLElement());
 
     clone->cloneDataFromElement(*this);
     // This will catch HTML elements in the wrong namespace that are not correctly copied.
     // This is a sanity check as HTML overloads some of the DOM methods.
     ASSERT(isHTMLElement() == clone->isHTMLElement());
 
     clone->cloneDataFromElement(*this);
-    return clone.release();
+    return clone;
 }
 
 }
 
-RefPtr<Element> Element::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
+Ref<Element> Element::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
 {
     return targetDocument.createElement(tagQName(), false);
 }
 {
     return targetDocument.createElement(tagQName(), false);
 }
@@ -2319,7 +2318,7 @@ void Element::setOuterHTML(const String& html, ExceptionCode& ec)
     if (ec)
         return;
     
     if (ec)
         return;
     
-    parent->replaceChild(fragment.release(), this, ec);
+    parent->replaceChild(fragment.releaseNonNull(), *this, ec);
     RefPtr<Node> node = next ? next->previousSibling() : nullptr;
     if (!ec && is<Text>(node.get()))
         mergeWithNextTextNode(downcast<Text>(*node), ec);
     RefPtr<Node> node = next ? next->previousSibling() : nullptr;
     if (!ec && is<Text>(node.get()))
         mergeWithNextTextNode(downcast<Text>(*node), ec);
@@ -2338,7 +2337,7 @@ void Element::setInnerHTML(const String& html, ExceptionCode& ec)
             container = downcast<HTMLTemplateElement>(*this).content();
 #endif
 
             container = downcast<HTMLTemplateElement>(*this).content();
 #endif
 
-        replaceChildrenWithFragment(*container, fragment.release(), ec);
+        replaceChildrenWithFragment(*container, fragment.releaseNonNull(), ec);
     }
 }
 
     }
 }
 
index 1e60703..04810e1 100644 (file)
@@ -201,8 +201,8 @@ public:
 
     virtual String nodeName() const override;
 
 
     virtual String nodeName() const override;
 
-    RefPtr<Element> cloneElementWithChildren(Document&);
-    RefPtr<Element> cloneElementWithoutChildren(Document&);
+    Ref<Element> cloneElementWithChildren(Document&);
+    Ref<Element> cloneElementWithoutChildren(Document&);
 
     void normalizeAttributes();
     String nodeNamePreservingCase() const;
 
     void normalizeAttributes();
     String nodeNamePreservingCase() const;
@@ -563,8 +563,8 @@ private:
 
     // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren
     // are used instead.
 
     // cloneNode is private so that non-virtual cloneElementWithChildren and cloneElementWithoutChildren
     // are used instead.
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
-    virtual RefPtr<Element> cloneElementWithoutAttributesAndChildren(Document&);
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Element> cloneElementWithoutAttributesAndChildren(Document&);
 
     void addShadowRoot(Ref<ShadowRoot>&&);
     void removeShadowRoot();
 
     void addShadowRoot(Ref<ShadowRoot>&&);
     void removeShadowRoot();
index a2ff63b..7e91a46 100644 (file)
@@ -46,7 +46,7 @@ Node::NodeType EntityReference::nodeType() const
     return ENTITY_REFERENCE_NODE;
 }
 
     return ENTITY_REFERENCE_NODE;
 }
 
-RefPtr<Node> EntityReference::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> EntityReference::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
     return create(targetDocument, m_entityName);
 }
 {
     return create(targetDocument, m_entityName);
 }
index 03f43cd..86dfeb3 100644 (file)
@@ -35,7 +35,7 @@ private:
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
 
     String m_entityName;
 };
 
     String m_entityName;
 };
index 8aa4a1f..2f8c6f7 100644 (file)
@@ -429,38 +429,54 @@ Element* Node::nextElementSibling() const
 
 bool Node::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)
 {
 
 bool Node::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)
 {
+    if (!newChild) {
+        ec = TypeError;
+        return false;
+    }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
-    return downcast<ContainerNode>(*this).insertBefore(newChild, refChild, ec);
+    return downcast<ContainerNode>(*this).insertBefore(*newChild, refChild, ec);
 }
 
 bool Node::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec)
 {
 }
 
 bool Node::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec)
 {
+    if (!newChild || !oldChild) {
+        ec = TypeError;
+        return false;
+    }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
-    return downcast<ContainerNode>(*this).replaceChild(newChild, oldChild, ec);
+    return downcast<ContainerNode>(*this).replaceChild(*newChild, *oldChild, ec);
 }
 
 bool Node::removeChild(Node* oldChild, ExceptionCode& ec)
 {
 }
 
 bool Node::removeChild(Node* oldChild, ExceptionCode& ec)
 {
+    if (!oldChild) {
+        ec = TypeError;
+        return false;
+    }
     if (!is<ContainerNode>(*this)) {
         ec = NOT_FOUND_ERR;
         return false;
     }
     if (!is<ContainerNode>(*this)) {
         ec = NOT_FOUND_ERR;
         return false;
     }
-    return downcast<ContainerNode>(*this).removeChild(oldChild, ec);
+    return downcast<ContainerNode>(*this).removeChild(*oldChild, ec);
 }
 
 bool Node::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
 {
 }
 
 bool Node::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
 {
+    if (!newChild) {
+        ec = TypeError;
+        return false;
+    }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
     if (!is<ContainerNode>(*this)) {
         ec = HIERARCHY_REQUEST_ERR;
         return false;
     }
-    return downcast<ContainerNode>(*this).appendChild(newChild, ec);
+    return downcast<ContainerNode>(*this).appendChild(*newChild, ec);
 }
 
 static HashSet<RefPtr<Node>> nodeSetPreTransformedFromNodeOrStringVector(const Vector<NodeOrString>& nodeOrStringVector)
 }
 
 static HashSet<RefPtr<Node>> nodeSetPreTransformedFromNodeOrStringVector(const Vector<NodeOrString>& nodeOrStringVector)
@@ -515,7 +531,7 @@ void Node::before(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
     else
         viablePreviousSibling = parent->firstChild();
 
     else
         viablePreviousSibling = parent->firstChild();
 
-    parent->insertBefore(node.release(), viablePreviousSibling.get(), ec);
+    parent->insertBefore(node.releaseNonNull(), viablePreviousSibling.get(), ec);
 }
 
 void Node::after(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
 }
 
 void Node::after(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
@@ -531,7 +547,7 @@ void Node::after(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
     if (ec || !node)
         return;
 
     if (ec || !node)
         return;
 
-    parent->insertBefore(node.release(), viableNextSibling.get(), ec);
+    parent->insertBefore(node.releaseNonNull(), viableNextSibling.get(), ec);
 }
 
 void Node::replaceWith(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
 }
 
 void Node::replaceWith(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode& ec)
@@ -548,15 +564,15 @@ void Node::replaceWith(Vector<NodeOrString>&& nodeOrStringVector, ExceptionCode&
         return;
 
     if (parentNode() == parent)
         return;
 
     if (parentNode() == parent)
-        parent->replaceChild(node.release(), this, ec);
+        parent->replaceChild(node.releaseNonNull(), *this, ec);
     else
     else
-        parent->insertBefore(node.release(), viableNextSibling.get(), ec);
+        parent->insertBefore(node.releaseNonNull(), viableNextSibling.get(), ec);
 }
 
 void Node::remove(ExceptionCode& ec)
 {
     if (ContainerNode* parent = parentNode())
 }
 
 void Node::remove(ExceptionCode& ec)
 {
     if (ContainerNode* parent = parentNode())
-        parent->removeChild(this, ec);
+        parent->removeChild(*this, ec);
 }
 
 void Node::normalize()
 }
 
 void Node::normalize()
index 18487a6..4a46a79 100644 (file)
@@ -201,8 +201,8 @@ public:
         SelfWithTemplateContent,
         Everything,
     };
         SelfWithTemplateContent,
         Everything,
     };
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) = 0;
-    RefPtr<Node> cloneNode(bool deep) { return cloneNodeInternal(document(), deep ? CloningOperation::Everything : CloningOperation::OnlySelf); }
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) = 0;
+    Ref<Node> cloneNode(bool deep) { return cloneNodeInternal(document(), deep ? CloningOperation::Everything : CloningOperation::OnlySelf); }
 
     virtual const AtomicString& localName() const;
     virtual const AtomicString& namespaceURI() const;
 
     virtual const AtomicString& localName() const;
     virtual const AtomicString& namespaceURI() const;
index b343ca3..30009b7 100644 (file)
@@ -79,7 +79,7 @@ Node::NodeType ProcessingInstruction::nodeType() const
     return PROCESSING_INSTRUCTION_NODE;
 }
 
     return PROCESSING_INSTRUCTION_NODE;
 }
 
-RefPtr<Node> ProcessingInstruction::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> ProcessingInstruction::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
     // FIXME: Is it a problem that this does not copy m_localHref?
     // What about other data members?
 {
     // FIXME: Is it a problem that this does not copy m_localHref?
     // What about other data members?
index 21fd9e9..efa905b 100644 (file)
@@ -58,7 +58,7 @@ private:
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
 
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
 
     virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
     virtual void removedFrom(ContainerNode&) override;
 
     virtual InsertionNotificationRequest insertedInto(ContainerNode&) override;
     virtual void removedFrom(ContainerNode&) override;
index 4d227da..26508cf 100644 (file)
@@ -665,7 +665,7 @@ RefPtr<DocumentFragment> Range::processContents(ActionType action, ExceptionCode
     // (or just delete the stuff in between)
 
     if ((action == Extract || action == Clone) && leftContents)
     // (or just delete the stuff in between)
 
     if ((action == Extract || action == Clone) && leftContents)
-        fragment->appendChild(leftContents, ec);
+        fragment->appendChild(*leftContents, ec);
 
     if (processStart) {
         NodeVector nodes;
 
     if (processStart) {
         NodeVector nodes;
@@ -675,7 +675,7 @@ RefPtr<DocumentFragment> Range::processContents(ActionType action, ExceptionCode
     }
 
     if ((action == Extract || action == Clone) && rightContents)
     }
 
     if ((action == Extract || action == Clone) && rightContents)
-        fragment->appendChild(rightContents, ec);
+        fragment->appendChild(*rightContents, ec);
 
     return fragment;
 }
 
     return fragment;
 }
@@ -702,7 +702,7 @@ RefPtr<Node> Range::processContentsBetweenOffsets(ActionType action, PassRefPtr<
         endOffset = std::min(endOffset, static_cast<CharacterData*>(container)->length());
         startOffset = std::min(startOffset, endOffset);
         if (action == Extract || action == Clone) {
         endOffset = std::min(endOffset, static_cast<CharacterData*>(container)->length());
         startOffset = std::min(startOffset, endOffset);
         if (action == Extract || action == Clone) {
-            RefPtr<CharacterData> c = static_pointer_cast<CharacterData>(container->cloneNode(true));
+            RefPtr<CharacterData> c = static_cast<CharacterData*>(container->cloneNode(true).ptr());
             deleteCharacterData(c, startOffset, endOffset, ec);
             if (fragment) {
                 result = fragment;
             deleteCharacterData(c, startOffset, endOffset, ec);
             if (fragment) {
                 result = fragment;
@@ -717,7 +717,7 @@ RefPtr<Node> Range::processContentsBetweenOffsets(ActionType action, PassRefPtr<
         endOffset = std::min(endOffset, static_cast<ProcessingInstruction*>(container)->data().length());
         startOffset = std::min(startOffset, endOffset);
         if (action == Extract || action == Clone) {
         endOffset = std::min(endOffset, static_cast<ProcessingInstruction*>(container)->data().length());
         startOffset = std::min(startOffset, endOffset);
         if (action == Extract || action == Clone) {
-            RefPtr<ProcessingInstruction> c = static_pointer_cast<ProcessingInstruction>(container->cloneNode(true));
+            RefPtr<ProcessingInstruction> c = static_cast<ProcessingInstruction*>(container->cloneNode(true).ptr());
             c->setData(c->data().substring(startOffset, endOffset - startOffset), ec);
             if (fragment) {
                 result = fragment;
             c->setData(c->data().substring(startOffset, endOffset - startOffset), ec);
             if (fragment) {
                 result = fragment;
@@ -935,7 +935,7 @@ void Range::insertNode(PassRefPtr<Node> prpNewNode, ExceptionCode& ec)
             return;
         
         container = &startContainer();
             return;
         
         container = &startContainer();
-        container->parentNode()->insertBefore(newNode.release(), newText.get(), ec);
+        container->parentNode()->insertBefore(newNode.releaseNonNull(), newText.get(), ec);
         if (ec)
             return;
 
         if (ec)
             return;
 
@@ -1303,7 +1303,7 @@ void Range::surroundContents(PassRefPtr<Node> passNewParent, ExceptionCode& ec)
 
     ec = 0;
     while (Node* n = newParent->firstChild()) {
 
     ec = 0;
     while (Node* n = newParent->firstChild()) {
-        downcast<ContainerNode>(*newParent).removeChild(n, ec);
+        downcast<ContainerNode>(*newParent).removeChild(*n, ec);
         if (ec)
             return;
     }
         if (ec)
             return;
     }
index a12257f..886100d 100644 (file)
@@ -92,7 +92,7 @@ void ShadowRoot::setInnerHTML(const String& markup, ExceptionCode& ec)
     }
 
     if (RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, host(), AllowScriptingContent, ec))
     }
 
     if (RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, host(), AllowScriptingContent, ec))
-        replaceChildrenWithFragment(*this, fragment.release(), ec);
+        replaceChildrenWithFragment(*this, fragment.releaseNonNull(), ec);
 }
 
 bool ShadowRoot::childTypeAllowed(NodeType type) const
 }
 
 bool ShadowRoot::childTypeAllowed(NodeType type) const
@@ -131,9 +131,10 @@ void ShadowRoot::childrenChanged(const ChildChange& change)
     invalidateDistribution();
 }
 
     invalidateDistribution();
 }
 
-RefPtr<Node> ShadowRoot::cloneNodeInternal(Document&, CloningOperation)
+Ref<Node> ShadowRoot::cloneNodeInternal(Document&, CloningOperation)
 {
 {
-    return nullptr; // ShadowRoots should never be cloned.
+    RELEASE_ASSERT_NOT_REACHED();
+    return *static_cast<Node*>(nullptr); // ShadowRoots should never be cloned.
 }
 
 void ShadowRoot::removeAllEventListeners()
 }
 
 void ShadowRoot::removeAllEventListeners()
index 6d311fd..631608a 100644 (file)
@@ -76,7 +76,7 @@ private:
     virtual bool childTypeAllowed(NodeType) const override;
     virtual void childrenChanged(const ChildChange&) override;
 
     virtual bool childTypeAllowed(NodeType) const override;
     virtual void childrenChanged(const ChildChange&) override;
 
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
 
     // FIXME: This shouldn't happen. https://bugs.webkit.org/show_bug.cgi?id=88834
     bool isOrphan() const { return !m_host; }
 
     // FIXME: This shouldn't happen. https://bugs.webkit.org/show_bug.cgi?id=88834
     bool isOrphan() const { return !m_host; }
index b1171d7..6c4c89d 100644 (file)
@@ -73,7 +73,7 @@ RefPtr<Text> Text::splitText(unsigned offset, ExceptionCode& ec)
     dispatchModifiedEvent(oldStr);
 
     if (parentNode())
     dispatchModifiedEvent(oldStr);
 
     if (parentNode())
-        parentNode()->insertBefore(newText.ptr(), nextSibling(), ec);
+        parentNode()->insertBefore(newText.copyRef(), nextSibling(), ec);
     if (ec)
         return 0;
 
     if (ec)
         return 0;
 
@@ -132,28 +132,28 @@ RefPtr<Text> Text::replaceWholeText(const String& newText, ExceptionCode&)
     RefPtr<Text> protectedThis(this); // Mutation event handlers could cause our last ref to go away
     RefPtr<ContainerNode> parent = parentNode(); // Protect against mutation handlers moving this node during traversal
     for (RefPtr<Node> n = startText; n && n != this && n->isTextNode() && n->parentNode() == parent;) {
     RefPtr<Text> protectedThis(this); // Mutation event handlers could cause our last ref to go away
     RefPtr<ContainerNode> parent = parentNode(); // Protect against mutation handlers moving this node during traversal
     for (RefPtr<Node> n = startText; n && n != this && n->isTextNode() && n->parentNode() == parent;) {
-        RefPtr<Node> nodeToRemove(n.release());
+        Ref<Node> nodeToRemove(n.releaseNonNull());
         n = nodeToRemove->nextSibling();
         n = nodeToRemove->nextSibling();
-        parent->removeChild(nodeToRemove.get(), IGNORE_EXCEPTION);
+        parent->removeChild(WTF::move(nodeToRemove), IGNORE_EXCEPTION);
     }
 
     if (this != endText) {
         Node* onePastEndText = endText->nextSibling();
         for (RefPtr<Node> n = nextSibling(); n && n != onePastEndText && n->isTextNode() && n->parentNode() == parent;) {
     }
 
     if (this != endText) {
         Node* onePastEndText = endText->nextSibling();
         for (RefPtr<Node> n = nextSibling(); n && n != onePastEndText && n->isTextNode() && n->parentNode() == parent;) {
-            RefPtr<Node> nodeToRemove(n.release());
+            Ref<Node> nodeToRemove(n.releaseNonNull());
             n = nodeToRemove->nextSibling();
             n = nodeToRemove->nextSibling();
-            parent->removeChild(nodeToRemove.get(), IGNORE_EXCEPTION);
+            parent->removeChild(WTF::move(nodeToRemove), IGNORE_EXCEPTION);
         }
     }
 
     if (newText.isEmpty()) {
         if (parent && parentNode() == parent)
         }
     }
 
     if (newText.isEmpty()) {
         if (parent && parentNode() == parent)
-            parent->removeChild(this, IGNORE_EXCEPTION);
-        return 0;
+            parent->removeChild(*this, IGNORE_EXCEPTION);
+        return nullptr;
     }
 
     setData(newText, IGNORE_EXCEPTION);
     }
 
     setData(newText, IGNORE_EXCEPTION);
-    return protectedThis.release();
+    return protectedThis;
 }
 
 String Text::nodeName() const
 }
 
 String Text::nodeName() const
@@ -166,7 +166,7 @@ Node::NodeType Text::nodeType() const
     return TEXT_NODE;
 }
 
     return TEXT_NODE;
 }
 
-RefPtr<Node> Text::cloneNodeInternal(Document& targetDocument, CloningOperation)
+Ref<Node> Text::cloneNodeInternal(Document& targetDocument, CloningOperation)
 {
     return create(targetDocument, data());
 }
 {
     return create(targetDocument, data());
 }
index a967436..efd6bde 100644 (file)
@@ -62,7 +62,7 @@ protected:
 private:
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
 private:
     virtual String nodeName() const override;
     virtual NodeType nodeType() const override;
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
     virtual bool childTypeAllowed(NodeType) const override;
 
     virtual Ref<Text> virtualCreate(const String&);
     virtual bool childTypeAllowed(NodeType) const override;
 
     virtual Ref<Text> virtualCreate(const String&);
index 6a8d9e9..b935312 100644 (file)
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-AppendNodeCommand::AppendNodeCommand(PassRefPtr<ContainerNode> parent, PassRefPtr<Node> node, EditAction editingAction)
+AppendNodeCommand::AppendNodeCommand(PassRefPtr<ContainerNode> parent, Ref<Node>&& node, EditAction editingAction)
     : SimpleEditCommand(parent->document(), editingAction)
     , m_parent(parent)
     : SimpleEditCommand(parent->document(), editingAction)
     , m_parent(parent)
-    , m_node(node)
+    , m_node(WTF::move(node))
 {
     ASSERT(m_parent);
 {
     ASSERT(m_parent);
-    ASSERT(m_node);
     ASSERT(!m_node->parentNode());
 
     ASSERT(m_parent->hasEditableStyle() || !m_parent->renderer());
     ASSERT(!m_node->parentNode());
 
     ASSERT(m_parent->hasEditableStyle() || !m_parent->renderer());
@@ -68,10 +67,10 @@ void AppendNodeCommand::doApply()
     if (!m_parent->hasEditableStyle() && m_parent->renderer())
         return;
 
     if (!m_parent->hasEditableStyle() && m_parent->renderer())
         return;
 
-    m_parent->appendChild(m_node.get(), IGNORE_EXCEPTION);
+    m_parent->appendChild(m_node.copyRef(), IGNORE_EXCEPTION);
 
     if (shouldPostAccessibilityNotification())
 
     if (shouldPostAccessibilityNotification())
-        sendAXTextChangedIgnoringLineBreaks(m_node.get(), applyEditType());
+        sendAXTextChangedIgnoringLineBreaks(m_node.ptr(), applyEditType());
 }
 
 void AppendNodeCommand::doUnapply()
 }
 
 void AppendNodeCommand::doUnapply()
@@ -81,7 +80,7 @@ void AppendNodeCommand::doUnapply()
 
     // Need to notify this before actually deleting the text
     if (shouldPostAccessibilityNotification())
 
     // Need to notify this before actually deleting the text
     if (shouldPostAccessibilityNotification())
-        sendAXTextChangedIgnoringLineBreaks(m_node.get(), unapplyEditType());
+        sendAXTextChangedIgnoringLineBreaks(m_node.ptr(), unapplyEditType());
 
     m_node->remove(IGNORE_EXCEPTION);
 }
 
     m_node->remove(IGNORE_EXCEPTION);
 }
@@ -90,7 +89,7 @@ void AppendNodeCommand::doUnapply()
 void AppendNodeCommand::getNodesInCommand(HashSet<Node*>& nodes)
 {
     addNodeAndDescendants(m_parent.get(), nodes);
 void AppendNodeCommand::getNodesInCommand(HashSet<Node*>& nodes)
 {
     addNodeAndDescendants(m_parent.get(), nodes);
-    addNodeAndDescendants(m_node.get(), nodes);
+    addNodeAndDescendants(m_node.ptr(), nodes);
 }
 #endif
 
 }
 #endif
 
index f782975..640fa75 100644 (file)
@@ -32,13 +32,13 @@ namespace WebCore {
 
 class AppendNodeCommand : public SimpleEditCommand {
 public:
 
 class AppendNodeCommand : public SimpleEditCommand {
 public:
-    static Ref<AppendNodeCommand> create(PassRefPtr<ContainerNode> parent, PassRefPtr<Node> node, EditAction editingAction)
+    static Ref<AppendNodeCommand> create(PassRefPtr<ContainerNode> parent, Ref<Node>&& node, EditAction editingAction)
     {
     {
-        return adoptRef(*new AppendNodeCommand(parent, node, editingAction));
+        return adoptRef(*new AppendNodeCommand(parent, WTF::move(node), editingAction));
     }
 
 private:
     }
 
 private:
-    AppendNodeCommand(PassRefPtr<ContainerNode> parent, PassRefPtr<Node>, EditAction);
+    AppendNodeCommand(PassRefPtr<ContainerNode> parent, Ref<Node>&&, EditAction);
 
     virtual void doApply() override;
     virtual void doUnapply() override;
 
     virtual void doApply() override;
     virtual void doUnapply() override;
@@ -48,7 +48,7 @@ private:
 #endif
 
     RefPtr<ContainerNode> m_parent;
 #endif
 
     RefPtr<ContainerNode> m_parent;
-    RefPtr<Node> m_node;
+    Ref<Node> m_node;
 };
 
 } // namespace WebCore
 };
 
 } // namespace WebCore
index 3d77942..5d9d36f 100644 (file)
@@ -395,7 +395,8 @@ void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Posi
 void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<ContainerNode> parent)
 {
     ASSERT(canHaveChildrenForEditing(parent.get()));
 void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<ContainerNode> parent)
 {
     ASSERT(canHaveChildrenForEditing(parent.get()));
-    applyCommandToComposite(AppendNodeCommand::create(parent, node, editingAction()));
+    ASSERT(node);
+    applyCommandToComposite(AppendNodeCommand::create(parent, *node, editingAction()));
 }
 
 void CompositeEditCommand::removeChildrenInRange(PassRefPtr<Node> node, unsigned from, unsigned to)
 }
 
 void CompositeEditCommand::removeChildrenInRange(PassRefPtr<Node> node, unsigned from, unsigned to)
@@ -414,7 +415,7 @@ void CompositeEditCommand::removeNode(PassRefPtr<Node> node, ShouldAssumeContent
 {
     if (!node || !node->nonShadowBoundaryParentNode())
         return;
 {
     if (!node || !node->nonShadowBoundaryParentNode())
         return;
-    applyCommandToComposite(RemoveNodeCommand::create(node, shouldAssumeContentIsAlwaysEditable));
+    applyCommandToComposite(RemoveNodeCommand::create(*node, shouldAssumeContentIsAlwaysEditable));
 }
 
 void CompositeEditCommand::removeNodePreservingChildren(PassRefPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 }
 
 void CompositeEditCommand::removeNodePreservingChildren(PassRefPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
@@ -1541,7 +1542,7 @@ PassRefPtr<Node> CompositeEditCommand::splitTreeToNode(Node* start, Node* end, b
     return node.release();
 }
 
     return node.release();
 }
 
-PassRefPtr<Element> createBlockPlaceholderElement(Document& document)
+Ref<Element> createBlockPlaceholderElement(Document& document)
 {
     return document.createElement(brTag, false);
 }
 {
     return document.createElement(brTag, false);
 }
index c6491d2..5609971 100644 (file)
@@ -632,7 +632,7 @@ void DeleteSelectionCommand::mergeParagraphs()
     
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
     if (!mergeDestination.deepEquivalent().deprecatedNode() || !mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode())) || m_startsAtEmptyLine) {
     
     // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion.
     if (!mergeDestination.deepEquivalent().deprecatedNode() || !mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode())) || m_startsAtEmptyLine) {
-        insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);
+        insertNodeAt(createBreakElement(document()).ptr(), m_upstreamStart);
         mergeDestination = VisiblePosition(m_upstreamStart);
     }
     
         mergeDestination = VisiblePosition(m_upstreamStart);
     }
     
@@ -855,7 +855,7 @@ void DeleteSelectionCommand::doApply()
     
     removePreviouslySelectedEmptyTableRows();
     
     
     removePreviouslySelectedEmptyTableRows();
     
-    RefPtr<Node> placeholder = m_needPlaceholder ? createBreakElement(document()).get() : 0;
+    RefPtr<Node> placeholder = m_needPlaceholder ? createBreakElement(document()).ptr() : nullptr;
     
     if (placeholder) {
         if (m_sanitizeMarkup)
     
     if (placeholder) {
         if (m_sanitizeMarkup)
index 148e35c..44b2ac7 100644 (file)
@@ -613,8 +613,8 @@ void Editor::setTextAsChildOfElement(const String& text, Element* elem)
             
         RefPtr<Range> context = document().createRange();
         context->selectNodeContents(elem, ec);
             
         RefPtr<Range> context = document().createRange();
         context->selectNodeContents(elem, ec);
-        RefPtr<DocumentFragment> fragment = createFragmentFromText(*context.get(), text);
-        elem->appendChild(fragment, ec);
+        Ref<DocumentFragment> fragment = createFragmentFromText(*context.get(), text);
+        elem->appendChild(WTF::move(fragment), ec);
     
         // restore element to document
         if (parent) {
     
         // restore element to document
         if (parent) {
index 0f8f880..12cdd21 100644 (file)
@@ -165,11 +165,11 @@ static bool executeInsertFragment(Frame& frame, PassRefPtr<DocumentFragment> fra
     return true;
 }
 
     return true;
 }
 
-static bool executeInsertNode(Frame& frame, PassRefPtr<Node> content)
+static bool executeInsertNode(Frame& frame, Ref<Node>&& content)
 {
     RefPtr<DocumentFragment> fragment = DocumentFragment::create(*frame.document());
     ExceptionCode ec = 0;
 {
     RefPtr<DocumentFragment> fragment = DocumentFragment::create(*frame.document());
     ExceptionCode ec = 0;
-    fragment->appendChild(content, ec);
+    fragment->appendChild(WTF::move(content), ec);
     if (ec)
         return false;
     return executeInsertFragment(frame, fragment.release());
     if (ec)
         return false;
     return executeInsertFragment(frame, fragment.release());
@@ -464,10 +464,10 @@ static bool executeInsertBacktab(Frame& frame, Event* event, EditorCommandSource
 
 static bool executeInsertHorizontalRule(Frame& frame, Event*, EditorCommandSource, const String& value)
 {
 
 static bool executeInsertHorizontalRule(Frame& frame, Event*, EditorCommandSource, const String& value)
 {
-    RefPtr<HTMLHRElement> rule = HTMLHRElement::create(*frame.document());
+    Ref<HTMLHRElement> rule = HTMLHRElement::create(*frame.document());
     if (!value.isEmpty())
         rule->setIdAttribute(value);
     if (!value.isEmpty())
         rule->setIdAttribute(value);
-    return executeInsertNode(frame, rule.release());
+    return executeInsertNode(frame, WTF::move(rule));
 }
 
 static bool executeInsertHTML(Frame& frame, Event*, EditorCommandSource, const String& value)
 }
 
 static bool executeInsertHTML(Frame& frame, Event*, EditorCommandSource, const String& value)
@@ -478,9 +478,9 @@ static bool executeInsertHTML(Frame& frame, Event*, EditorCommandSource, const S
 static bool executeInsertImage(Frame& frame, Event*, EditorCommandSource, const String& value)
 {
     // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image.
 static bool executeInsertImage(Frame& frame, Event*, EditorCommandSource, const String& value)
 {
     // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image.
-    RefPtr<HTMLImageElement> image = HTMLImageElement::create(*frame.document());
+    Ref<HTMLImageElement> image = HTMLImageElement::create(*frame.document());
     image->setSrc(value);
     image->setSrc(value);
-    return executeInsertNode(frame, image.release());
+    return executeInsertNode(frame, WTF::move(image));
 }
 
 static bool executeInsertLineBreak(Frame& frame, Event* event, EditorCommandSource source, const String&)
 }
 
 static bool executeInsertLineBreak(Frame& frame, Event* event, EditorCommandSource source, const String&)
index 6ee21d9..25ab071 100644 (file)
@@ -129,7 +129,7 @@ void InsertLineBreakCommand::doApply()
         
         // Insert an extra br or '\n' if the just inserted one collapsed.
         if (!isStartOfParagraph(positionBeforeNode(nodeToInsert.get())))
         
         // Insert an extra br or '\n' if the just inserted one collapsed.
         if (!isStartOfParagraph(positionBeforeNode(nodeToInsert.get())))
-            insertNodeBefore(nodeToInsert->cloneNode(false).get(), nodeToInsert.get());
+            insertNodeBefore(nodeToInsert->cloneNode(false), nodeToInsert.get());
         
         setEndingSelection(VisibleSelection(positionInParentAfterNode(nodeToInsert.get()), DOWNSTREAM, endingSelection().isDirectional()));
     // If we're inserting after all of the rendered text in a text node, or into a non-text node,
         
         setEndingSelection(VisibleSelection(positionInParentAfterNode(nodeToInsert.get()), DOWNSTREAM, endingSelection().isDirectional()));
     // If we're inserting after all of the rendered text in a text node, or into a non-text node,
index fa14d07..50f6545 100644 (file)
@@ -55,7 +55,7 @@ void InsertNodeBeforeCommand::doApply()
         return;
     ASSERT(isEditableNode(*parent));
 
         return;
     ASSERT(isEditableNode(*parent));
 
-    parent->insertBefore(m_insertChild.get(), m_refChild.get(), IGNORE_EXCEPTION);
+    parent->insertBefore(*m_insertChild, m_refChild.get(), IGNORE_EXCEPTION);
 
     if (shouldPostAccessibilityNotification()) {
         Position position = is<Text>(m_insertChild.get()) ? Position(downcast<Text>(m_insertChild.get()), 0) : createLegacyEditingPosition(m_insertChild.get(), 0);
 
     if (shouldPostAccessibilityNotification()) {
         Position position = is<Text>(m_insertChild.get()) ? Position(downcast<Text>(m_insertChild.get()), 0) : createLegacyEditingPosition(m_insertChild.get(), 0);
index 7dd0160..1503229 100644 (file)
@@ -368,7 +368,7 @@ void InsertParagraphSeparatorCommand::doApply()
     // created.  All of the nodes, starting at visiblePos, are about to be added to the new paragraph 
     // element.  If the first node to be inserted won't be one that will hold an empty line open, add a br.
     if (isEndOfParagraph(visiblePos) && !lineBreakExistsAtVisiblePosition(visiblePos))
     // created.  All of the nodes, starting at visiblePos, are about to be added to the new paragraph 
     // element.  If the first node to be inserted won't be one that will hold an empty line open, add a br.
     if (isEndOfParagraph(visiblePos) && !lineBreakExistsAtVisiblePosition(visiblePos))
-        appendNode(createBreakElement(document()).get(), blockToInsert.get());
+        appendNode(createBreakElement(document()), blockToInsert.get());
 
     // Move the start node and the siblings of the start node.
     if (VisiblePosition(insertionPosition) != VisiblePosition(positionBeforeNode(blockToInsert.get()))) {
 
     // Move the start node and the siblings of the start node.
     if (VisiblePosition(insertionPosition) != VisiblePosition(positionBeforeNode(blockToInsert.get()))) {
index 4651884..4a59ef6 100644 (file)
@@ -47,13 +47,13 @@ void MergeIdenticalElementsCommand::doApply()
 
     m_atChild = m_element2->firstChild();
 
 
     m_atChild = m_element2->firstChild();
 
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* child = m_element1->firstChild(); child; child = child->nextSibling())
     for (Node* child = m_element1->firstChild(); child; child = child->nextSibling())
-        children.append(child);
+        children.append(*child);
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_element2->insertBefore(children[i].release(), m_atChild.get(), IGNORE_EXCEPTION);
+        m_element2->insertBefore(WTF::move(children[i]), m_atChild.get(), IGNORE_EXCEPTION);
 
     m_element1->remove(IGNORE_EXCEPTION);
 }
 
     m_element1->remove(IGNORE_EXCEPTION);
 }
@@ -71,17 +71,17 @@ void MergeIdenticalElementsCommand::doUnapply()
 
     ExceptionCode ec = 0;
 
 
     ExceptionCode ec = 0;
 
-    parent->insertBefore(m_element1.get(), m_element2.get(), ec);
+    parent->insertBefore(*m_element1, m_element2.get(), ec);
     if (ec)
         return;
 
     if (ec)
         return;
 
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* child = m_element2->firstChild(); child && child != atChild; child = child->nextSibling())
     for (Node* child = m_element2->firstChild(); child && child != atChild; child = child->nextSibling())
-        children.append(child);
+        children.append(*child);
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_element1->appendChild(children[i].release(), ec);
+        m_element1->appendChild(WTF::move(children[i]), ec);
 }
 
 #ifndef NDEBUG
 }
 
 #ifndef NDEBUG
index 31c54d1..9ca5f8b 100644 (file)
 
 namespace WebCore {
 
 
 namespace WebCore {
 
-RemoveNodeCommand::RemoveNodeCommand(PassRefPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
+RemoveNodeCommand::RemoveNodeCommand(Ref<Node>&& node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
     : SimpleEditCommand(node->document())
     : SimpleEditCommand(node->document())
-    , m_node(node)
+    , m_node(WTF::move(node))
     , m_shouldAssumeContentIsAlwaysEditable(shouldAssumeContentIsAlwaysEditable)
 {
     , m_shouldAssumeContentIsAlwaysEditable(shouldAssumeContentIsAlwaysEditable)
 {
-    ASSERT(m_node);
     ASSERT(m_node->parentNode());
 }
 
     ASSERT(m_node->parentNode());
 }
 
@@ -64,7 +63,7 @@ void RemoveNodeCommand::doUnapply()
     if (!parent || !parent->hasEditableStyle())
         return;
 
     if (!parent || !parent->hasEditableStyle())
         return;
 
-    parent->insertBefore(m_node.get(), refChild.get(), IGNORE_EXCEPTION);
+    parent->insertBefore(m_node.copyRef(), refChild.get(), IGNORE_EXCEPTION);
 }
 
 #ifndef NDEBUG
 }
 
 #ifndef NDEBUG
@@ -72,7 +71,7 @@ void RemoveNodeCommand::getNodesInCommand(HashSet<Node*>& nodes)
 {
     addNodeAndDescendants(m_parent.get(), nodes);
     addNodeAndDescendants(m_refChild.get(), nodes);
 {
     addNodeAndDescendants(m_parent.get(), nodes);
     addNodeAndDescendants(m_refChild.get(), nodes);
-    addNodeAndDescendants(m_node.get(), nodes);
+    addNodeAndDescendants(m_node.ptr(), nodes);
 }
 #endif
 
 }
 #endif
 
index 181e985..33a1f8c 100644 (file)
@@ -32,13 +32,13 @@ namespace WebCore {
 
 class RemoveNodeCommand : public SimpleEditCommand {
 public:
 
 class RemoveNodeCommand : public SimpleEditCommand {
 public:
-    static Ref<RemoveNodeCommand> create(PassRefPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
+    static Ref<RemoveNodeCommand> create(Ref<Node>&& node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
     {
     {
-        return adoptRef(*new RemoveNodeCommand(node, shouldAssumeContentIsAlwaysEditable));
+        return adoptRef(*new RemoveNodeCommand(WTF::move(node), shouldAssumeContentIsAlwaysEditable));
     }
 
 private:
     }
 
 private:
-    explicit RemoveNodeCommand(PassRefPtr<Node>, ShouldAssumeContentIsAlwaysEditable);
+    RemoveNodeCommand(Ref<Node>&&, ShouldAssumeContentIsAlwaysEditable);
 
     virtual void doApply() override;
     virtual void doUnapply() override;
 
     virtual void doApply() override;
     virtual void doUnapply() override;
@@ -47,7 +47,7 @@ private:
     void getNodesInCommand(HashSet<Node*>&) override;
 #endif
 
     void getNodesInCommand(HashSet<Node*>&) override;
 #endif
 
-    RefPtr<Node> m_node;
+    Ref<Node> m_node;
     RefPtr<ContainerNode> m_parent;
     RefPtr<Node> m_refChild;
     ShouldAssumeContentIsAlwaysEditable m_shouldAssumeContentIsAlwaysEditable;
     RefPtr<ContainerNode> m_parent;
     RefPtr<Node> m_refChild;
     ShouldAssumeContentIsAlwaysEditable m_shouldAssumeContentIsAlwaysEditable;
index 0e189bd..10bef3a 100644 (file)
@@ -48,19 +48,19 @@ ReplaceNodeWithSpanCommand::ReplaceNodeWithSpanCommand(PassRefPtr<HTMLElement> e
     ASSERT(m_elementToReplace);
 }
 
     ASSERT(m_elementToReplace);
 }
 
-static void swapInNodePreservingAttributesAndChildren(HTMLElement* newNode, HTMLElement* nodeToReplace)
+static void swapInNodePreservingAttributesAndChildren(HTMLElement& newNode, HTMLElement& nodeToReplace)
 {
 {
-    ASSERT(nodeToReplace->inDocument());
-    RefPtr<ContainerNode> parentNode = nodeToReplace->parentNode();
+    ASSERT(nodeToReplace.inDocument());
+    RefPtr<ContainerNode> parentNode = nodeToReplace.parentNode();
 
     // FIXME: Fix this to send the proper MutationRecords when MutationObservers are present.
 
     // FIXME: Fix this to send the proper MutationRecords when MutationObservers are present.
-    newNode->cloneDataFromElement(*nodeToReplace);
+    newNode.cloneDataFromElement(nodeToReplace);
     NodeVector children;
     NodeVector children;
-    getChildNodes(*nodeToReplace, children);
+    getChildNodes(nodeToReplace, children);
     for (auto& child : children)
     for (auto& child : children)
-        newNode->appendChild(child.ptr(), ASSERT_NO_EXCEPTION);
+        newNode.appendChild(WTF::move(child), ASSERT_NO_EXCEPTION);
 
 
-    parentNode->insertBefore(newNode, nodeToReplace, ASSERT_NO_EXCEPTION);
+    parentNode->insertBefore(newNode, &nodeToReplace, ASSERT_NO_EXCEPTION);
     parentNode->removeChild(nodeToReplace, ASSERT_NO_EXCEPTION);
 }
 
     parentNode->removeChild(nodeToReplace, ASSERT_NO_EXCEPTION);
 }
 
@@ -70,14 +70,14 @@ void ReplaceNodeWithSpanCommand::doApply()
         return;
     if (!m_spanElement)
         m_spanElement = createHTMLElement(m_elementToReplace->document(), spanTag);
         return;
     if (!m_spanElement)
         m_spanElement = createHTMLElement(m_elementToReplace->document(), spanTag);
-    swapInNodePreservingAttributesAndChildren(m_spanElement.get(), m_elementToReplace.get());
+    swapInNodePreservingAttributesAndChildren(*m_spanElement, *m_elementToReplace);
 }
 
 void ReplaceNodeWithSpanCommand::doUnapply()
 {
     if (!m_spanElement->inDocument())
         return;
 }
 
 void ReplaceNodeWithSpanCommand::doUnapply()
 {
     if (!m_spanElement->inDocument())
         return;
-    swapInNodePreservingAttributesAndChildren(m_elementToReplace.get(), m_spanElement.get());
+    swapInNodePreservingAttributesAndChildren(*m_elementToReplace, *m_spanElement);
 }
 
 #ifndef NDEBUG
 }
 
 #ifndef NDEBUG
index eee220c..08c6277 100644 (file)
@@ -238,7 +238,7 @@ void ReplacementFragment::removeNode(PassRefPtr<Node> node)
     if (!parent)
         return;
     
     if (!parent)
         return;
     
-    parent->removeChild(node.get(), ASSERT_NO_EXCEPTION);
+    parent->removeChild(*node, ASSERT_NO_EXCEPTION);
 }
 
 void ReplacementFragment::insertNodeBefore(PassRefPtr<Node> node, Node* refNode)
 }
 
 void ReplacementFragment::insertNodeBefore(PassRefPtr<Node> node, Node* refNode)
@@ -250,14 +250,14 @@ void ReplacementFragment::insertNodeBefore(PassRefPtr<Node> node, Node* refNode)
     if (!parent)
         return;
         
     if (!parent)
         return;
         
-    parent->insertBefore(node, refNode, ASSERT_NO_EXCEPTION);
+    parent->insertBefore(*node, refNode, ASSERT_NO_EXCEPTION);
 }
 
 PassRefPtr<StyledElement> ReplacementFragment::insertFragmentForTestRendering(Node* rootEditableElement)
 {
     RefPtr<StyledElement> holder = createDefaultParagraphElement(document());
 
 }
 
 PassRefPtr<StyledElement> ReplacementFragment::insertFragmentForTestRendering(Node* rootEditableElement)
 {
     RefPtr<StyledElement> holder = createDefaultParagraphElement(document());
 
-    holder->appendChild(m_fragment, ASSERT_NO_EXCEPTION);
+    holder->appendChild(*m_fragment, ASSERT_NO_EXCEPTION);
     rootEditableElement->appendChild(holder.get(), ASSERT_NO_EXCEPTION);
     document().updateLayoutIgnorePendingStylesheets();
 
     rootEditableElement->appendChild(holder.get(), ASSERT_NO_EXCEPTION);
     document().updateLayoutIgnorePendingStylesheets();
 
@@ -270,8 +270,8 @@ void ReplacementFragment::restoreAndRemoveTestRenderingNodesToFragment(StyledEle
         return;
     
     while (RefPtr<Node> node = holder->firstChild()) {
         return;
     
     while (RefPtr<Node> node = holder->firstChild()) {
-        holder->removeChild(node.get(), ASSERT_NO_EXCEPTION);
-        m_fragment->appendChild(node.get(), ASSERT_NO_EXCEPTION);
+        holder->removeChild(*node, ASSERT_NO_EXCEPTION);
+        m_fragment->appendChild(*node, ASSERT_NO_EXCEPTION);
     }
 
     removeNode(holder);
     }
 
     removeNode(holder);
@@ -1454,7 +1454,7 @@ Node* ReplaceSelectionCommand::insertAsListItems(PassRefPtr<HTMLElement> prpList
     }
 
     while (RefPtr<Node> listItem = listElement->firstChild()) {
     }
 
     while (RefPtr<Node> listItem = listElement->firstChild()) {
-        listElement->removeChild(listItem.get(), ASSERT_NO_EXCEPTION);
+        listElement->removeChild(*listItem, ASSERT_NO_EXCEPTION);
         if (isStart || isMiddle) {
             insertNodeBefore(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(listItem.get());
         if (isStart || isMiddle) {
             insertNodeBefore(listItem, lastNode);
             insertedNodes.respondToNodeInsertion(listItem.get());
index 09beb85..35d821b 100644 (file)
@@ -47,16 +47,16 @@ void SplitElementCommand::executeApply()
     if (m_atChild->parentNode() != m_element2)
         return;
     
     if (m_atChild->parentNode() != m_element2)
         return;
     
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* node = m_element2->firstChild(); node != m_atChild; node = node->nextSibling())
     for (Node* node = m_element2->firstChild(); node != m_atChild; node = node->nextSibling())
-        children.append(node);
+        children.append(*node);
     
     ExceptionCode ec = 0;
     
     ContainerNode* parent = m_element2->parentNode();
     if (!parent || !parent->hasEditableStyle())
         return;
     
     ExceptionCode ec = 0;
     
     ContainerNode* parent = m_element2->parentNode();
     if (!parent || !parent->hasEditableStyle())
         return;
-    parent->insertBefore(m_element1.get(), m_element2.get(), ec);
+    parent->insertBefore(*m_element1, m_element2.get(), ec);
     if (ec)
         return;
 
     if (ec)
         return;
 
@@ -65,7 +65,7 @@ void SplitElementCommand::executeApply()
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_element1->appendChild(children[i], ec);
+        m_element1->appendChild(WTF::move(children[i]), ec);
 }
     
 void SplitElementCommand::doApply()
 }
     
 void SplitElementCommand::doApply()
@@ -80,15 +80,15 @@ void SplitElementCommand::doUnapply()
     if (!m_element1 || !m_element1->hasEditableStyle() || !m_element2->hasEditableStyle())
         return;
 
     if (!m_element1 || !m_element1->hasEditableStyle() || !m_element2->hasEditableStyle())
         return;
 
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* node = m_element1->firstChild(); node; node = node->nextSibling())
     for (Node* node = m_element1->firstChild(); node; node = node->nextSibling())
-        children.append(node);
+        children.append(*node);
 
     RefPtr<Node> refChild = m_element2->firstChild();
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     RefPtr<Node> refChild = m_element2->firstChild();
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_element2->insertBefore(children[i].get(), refChild.get(), IGNORE_EXCEPTION);
+        m_element2->insertBefore(WTF::move(children[i]), refChild.get(), IGNORE_EXCEPTION);
 
     // Recover the id attribute of the original element.
     const AtomicString& id = m_element1->getIdAttribute();
 
     // Recover the id attribute of the original element.
     const AtomicString& id = m_element1->getIdAttribute();
index 17a817f..6999139 100644 (file)
@@ -95,7 +95,7 @@ void SplitTextNodeCommand::doReapply()
 void SplitTextNodeCommand::insertText1AndTrimText2()
 {
     ExceptionCode ec = 0;
 void SplitTextNodeCommand::insertText1AndTrimText2()
 {
     ExceptionCode ec = 0;
-    m_text2->parentNode()->insertBefore(m_text1.get(), m_text2.get(), ec);
+    m_text2->parentNode()->insertBefore(*m_text1, m_text2.get(), ec);
     if (ec)
         return;
     m_text2->deleteData(0, m_offset, ec);
     if (ec)
         return;
     m_text2->deleteData(0, m_offset, ec);
index 5646f34..f80b773 100644 (file)
@@ -40,15 +40,15 @@ WrapContentsInDummySpanCommand::WrapContentsInDummySpanCommand(PassRefPtr<Elemen
 
 void WrapContentsInDummySpanCommand::executeApply()
 {
 
 void WrapContentsInDummySpanCommand::executeApply()
 {
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* child = m_element->firstChild(); child; child = child->nextSibling())
     for (Node* child = m_element->firstChild(); child; child = child->nextSibling())
-        children.append(child);
+        children.append(*child);
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_dummySpan->appendChild(children[i].release(), IGNORE_EXCEPTION);
+        m_dummySpan->appendChild(WTF::move(children[i]), IGNORE_EXCEPTION);
 
 
-    m_element->appendChild(m_dummySpan.get(), IGNORE_EXCEPTION);
+    m_element->appendChild(*m_dummySpan, IGNORE_EXCEPTION);
 }
 
 void WrapContentsInDummySpanCommand::doApply()
 }
 
 void WrapContentsInDummySpanCommand::doApply()
@@ -65,13 +65,13 @@ void WrapContentsInDummySpanCommand::doUnapply()
     if (!m_dummySpan || !m_element->hasEditableStyle())
         return;
 
     if (!m_dummySpan || !m_element->hasEditableStyle())
         return;
 
-    Vector<RefPtr<Node>> children;
+    Vector<Ref<Node>> children;
     for (Node* child = m_dummySpan->firstChild(); child; child = child->nextSibling())
     for (Node* child = m_dummySpan->firstChild(); child; child = child->nextSibling())
-        children.append(child);
+        children.append(*child);
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = children.size();
     for (size_t i = 0; i < size; ++i)
-        m_element->appendChild(children[i].release(), IGNORE_EXCEPTION);
+        m_element->appendChild(WTF::move(children[i]), IGNORE_EXCEPTION);
 
     m_dummySpan->remove(IGNORE_EXCEPTION);
 }
 
     m_dummySpan->remove(IGNORE_EXCEPTION);
 }
index ce4bcbc..95e66db 100644 (file)
@@ -56,16 +56,16 @@ RenderStyle* Editor::styleForSelectionStart(Frame* frame, Node *&nodeToRemove)
     if (!typingStyle || !typingStyle->style())
         return &position.deprecatedNode()->renderer()->style();
 
     if (!typingStyle || !typingStyle->style())
         return &position.deprecatedNode()->renderer()->style();
 
-    RefPtr<Element> styleElement = frame->document()->createElement(HTMLNames::spanTag, false);
+    Ref<Element> styleElement = frame->document()->createElement(HTMLNames::spanTag, false);
 
     String styleText = typingStyle->style()->asText() + " display: inline";
     styleElement->setAttribute(HTMLNames::styleAttr, styleText);
 
     styleElement->appendChild(frame->document()->createEditingTextNode(""), ASSERT_NO_EXCEPTION);
 
 
     String styleText = typingStyle->style()->asText() + " display: inline";
     styleElement->setAttribute(HTMLNames::styleAttr, styleText);
 
     styleElement->appendChild(frame->document()->createEditingTextNode(""), ASSERT_NO_EXCEPTION);
 
-    position.deprecatedNode()->parentNode()->appendChild(styleElement, ASSERT_NO_EXCEPTION);
+    position.deprecatedNode()->parentNode()->appendChild(styleElement.copyRef(), ASSERT_NO_EXCEPTION);
 
 
-    nodeToRemove = styleElement.get();
+    nodeToRemove = styleElement.ptr();
 
     frame->document()->updateStyleIfNeeded();
     return styleElement->renderer() ? &styleElement->renderer()->style() : nullptr;
 
     frame->document()->updateStyleIfNeeded();
     return styleElement->renderer() ? &styleElement->renderer()->style() : nullptr;
index 8f04d08..7caa14f 100644 (file)
@@ -899,20 +899,18 @@ bool isEmptyTableCell(const Node* node)
     return !childRenderer->nextSibling();
 }
 
     return !childRenderer->nextSibling();
 }
 
-PassRefPtr<HTMLElement> createDefaultParagraphElement(Document& document)
+Ref<HTMLElement> createDefaultParagraphElement(Document& document)
 {
     switch (document.frame()->editor().defaultParagraphSeparator()) {
     case EditorParagraphSeparatorIsDiv:
         return HTMLDivElement::create(document);
     case EditorParagraphSeparatorIsP:
 {
     switch (document.frame()->editor().defaultParagraphSeparator()) {
     case EditorParagraphSeparatorIsDiv:
         return HTMLDivElement::create(document);
     case EditorParagraphSeparatorIsP:
-        return HTMLParagraphElement::create(document);
+        break;
     }
     }
-
-    ASSERT_NOT_REACHED();
-    return 0;
+    return HTMLParagraphElement::create(document);
 }
 
 }
 
-PassRefPtr<HTMLElement> createBreakElement(Document& document)
+Ref<HTMLElement> createBreakElement(Document& document)
 {
     return HTMLBRElement::create(document);
 }
 {
     return HTMLBRElement::create(document);
 }
@@ -971,7 +969,7 @@ Position positionOutsideTabSpan(const Position& pos)
     return positionInParentBeforeNode(node);
 }
 
     return positionInParentBeforeNode(node);
 }
 
-PassRefPtr<Element> createTabSpanElement(Document& document, PassRefPtr<Node> prpTabTextNode)
+Ref<Element> createTabSpanElement(Document& document, PassRefPtr<Node> prpTabTextNode)
 {
     RefPtr<Node> tabTextNode = prpTabTextNode;
 
 {
     RefPtr<Node> tabTextNode = prpTabTextNode;
 
@@ -984,17 +982,17 @@ PassRefPtr<Element> createTabSpanElement(Document& document, PassRefPtr<Node> pr
     if (!tabTextNode)
         tabTextNode = document.createEditingTextNode("\t");
 
     if (!tabTextNode)
         tabTextNode = document.createEditingTextNode("\t");
 
-    spanElement->appendChild(tabTextNode.release(), ASSERT_NO_EXCEPTION);
+    spanElement->appendChild(tabTextNode.releaseNonNull(), ASSERT_NO_EXCEPTION);
 
 
-    return spanElement.release();
+    return spanElement.releaseNonNull();
 }
 
 }
 
-PassRefPtr<Element> createTabSpanElement(Document& document, const String& tabText)
+Ref<Element> createTabSpanElement(Document& document, const String& tabText)
 {
     return createTabSpanElement(document, document.createTextNode(tabText));
 }
 
 {
     return createTabSpanElement(document, document.createTextNode(tabText));
 }
 
-PassRefPtr<Element> createTabSpanElement(Document& document)
+Ref<Element> createTabSpanElement(Document& document)
 {
     return createTabSpanElement(document, PassRefPtr<Node>());
 }
 {
     return createTabSpanElement(document, PassRefPtr<Node>());
 }
index 788af3f..f69d9d8 100644 (file)
@@ -206,8 +206,8 @@ VisiblePosition visiblePositionForIndexUsingCharacterIterator(Node*, int index);
     
 // Functions returning HTMLElement
     
     
 // Functions returning HTMLElement
     
-WEBCORE_EXPORT PassRefPtr<HTMLElement> createDefaultParagraphElement(Document&);
-PassRefPtr<HTMLElement> createBreakElement(Document&);
+WEBCORE_EXPORT Ref<HTMLElement> createDefaultParagraphElement(Document&);
+Ref<HTMLElement> createBreakElement(Document&);
 PassRefPtr<HTMLElement> createOrderedListElement(Document&);
 PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
 PassRefPtr<HTMLElement> createListItemElement(Document&);
 PassRefPtr<HTMLElement> createOrderedListElement(Document&);
 PassRefPtr<HTMLElement> createUnorderedListElement(Document&);
 PassRefPtr<HTMLElement> createListItemElement(Document&);
@@ -222,10 +222,10 @@ Node* enclosingListChild(Node*);
 // Element
 // -------------------------------------------------------------------------
 
 // Element
 // -------------------------------------------------------------------------
 
-PassRefPtr<Element> createTabSpanElement(Document&);
-PassRefPtr<Element> createTabSpanElement(Document&, PassRefPtr<Node> tabTextNode);
-PassRefPtr<Element> createTabSpanElement(Document&, const String& tabText);
-PassRefPtr<Element> createBlockPlaceholderElement(Document&);
+Ref<Element> createTabSpanElement(Document&);
+Ref<Element> createTabSpanElement(Document&, PassRefPtr<Node> tabTextNode);
+Ref<Element> createTabSpanElement(Document&, const String& tabText);
+Ref<Element> createBlockPlaceholderElement(Document&);
 
 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
 Element* unsplittableElementForPosition(const Position&);
 
 Element* editableRootForPosition(const Position&, EditableType = ContentIsEditable);
 Element* unsplittableElementForPosition(const Position&);
index 226ead5..8151985 100644 (file)
@@ -397,7 +397,7 @@ void Editor::WebContentReader::addFragment(PassRefPtr<DocumentFragment> newFragm
     if (fragment) {
         if (newFragment && newFragment->firstChild()) {
             ExceptionCode ec;
     if (fragment) {
         if (newFragment && newFragment->firstChild()) {
             ExceptionCode ec;
-            fragment->appendChild(newFragment->firstChild(), ec);
+            fragment->appendChild(*newFragment->firstChild(), ec);
         }
     } else
         fragment = newFragment;
         }
     } else
         fragment = newFragment;
@@ -494,12 +494,12 @@ bool Editor::WebContentReader::readURL(const URL& url, const String&)
             return fragment;
         }
     } else {
             return fragment;
         }
     } else {
-        RefPtr<Element> anchor = frame.document()->createElement(HTMLNames::aTag, false);
+        Ref<Element> anchor = frame.document()->createElement(HTMLNames::aTag, false);
         anchor->setAttribute(HTMLNames::hrefAttr, url.string());
         anchor->appendChild(frame.document()->createTextNode([[(NSURL *)url absoluteString] precomposedStringWithCanonicalMapping]));
 
         RefPtr<DocumentFragment> newFragment = frame.document()->createDocumentFragment();
         anchor->setAttribute(HTMLNames::hrefAttr, url.string());
         anchor->appendChild(frame.document()->createTextNode([[(NSURL *)url absoluteString] precomposedStringWithCanonicalMapping]));
 
         RefPtr<DocumentFragment> newFragment = frame.document()->createDocumentFragment();
-        newFragment->appendChild(anchor.release());
+        newFragment->appendChild(WTF::move(anchor));
         addFragment(newFragment);
         return true;
     }
         addFragment(newFragment);
         return true;
     }
@@ -583,7 +583,7 @@ PassRefPtr<DocumentFragment> Editor::createFragmentForImageResourceAndAddResourc
     if (!resource)
         return nullptr;
 
     if (!resource)
         return nullptr;
 
-    RefPtr<Element> imageElement = m_frame.document()->createElement(HTMLNames::imgTag, false);
+    Ref<Element> imageElement = m_frame.document()->createElement(HTMLNames::imgTag, false);
     // FIXME: The code in createFragmentAndAddResources calls setDefersLoading(true). Don't we need that here?
     if (DocumentLoader* loader = m_frame.loader().documentLoader())
         loader->addArchiveResource(resource.get());
     // FIXME: The code in createFragmentAndAddResources calls setDefersLoading(true). Don't we need that here?
     if (DocumentLoader* loader = m_frame.loader().documentLoader())
         loader->addArchiveResource(resource.get());
@@ -592,7 +592,7 @@ PassRefPtr<DocumentFragment> Editor::createFragmentForImageResourceAndAddResourc
     imageElement->setAttribute(HTMLNames::srcAttr, [URL isFileURL] ? [URL absoluteString] : resource->url());
 
     RefPtr<DocumentFragment> fragment = m_frame.document()->createDocumentFragment();
     imageElement->setAttribute(HTMLNames::srcAttr, [URL isFileURL] ? [URL absoluteString] : resource->url());
 
     RefPtr<DocumentFragment> fragment = m_frame.document()->createDocumentFragment();
-    fragment->appendChild(imageElement.release());
+    fragment->appendChild(WTF::move(imageElement));
 
     return fragment.release();
 }
 
     return fragment.release();
 }
index 6cef489..cd252dc 100644 (file)
@@ -527,15 +527,15 @@ bool Editor::WebContentReader::readFilenames(const Vector<String>& paths)
     for (size_t i = 0; i < size; i++) {
         String text = paths[i];
 #if ENABLE(ATTACHMENT_ELEMENT)
     for (size_t i = 0; i < size; i++) {
         String text = paths[i];
 #if ENABLE(ATTACHMENT_ELEMENT)
-        RefPtr<HTMLAttachmentElement> attachment = HTMLAttachmentElement::create(attachmentTag, document);
+        Ref<HTMLAttachmentElement> attachment = HTMLAttachmentElement::create(attachmentTag, document);
         attachment->setFile(File::create([[NSURL fileURLWithPath:text] path]).ptr());
         attachment->setFile(File::create([[NSURL fileURLWithPath:text] path]).ptr());
-        fragment->appendChild(attachment.release());
+        fragment->appendChild(WTF::move(attachment));
 #else
         text = frame.editor().client()->userVisibleString([NSURL fileURLWithPath:text]);
 
 #else
         text = frame.editor().client()->userVisibleString([NSURL fileURLWithPath:text]);
 
-        RefPtr<HTMLElement> paragraph = createDefaultParagraphElement(document);
+        Ref<HTMLElement> paragraph = createDefaultParagraphElement(document);
         paragraph->appendChild(document.createTextNode(text));
         paragraph->appendChild(document.createTextNode(text));
-        fragment->appendChild(paragraph.release());
+        fragment->appendChild(WTF::move(paragraph));
 #endif
     }
 
 #endif
     }
 
@@ -594,12 +594,12 @@ bool Editor::WebContentReader::readURL(const URL& url, const String& title)
     if (url.string().isEmpty())
         return false;
 
     if (url.string().isEmpty())
         return false;
 
-    RefPtr<Element> anchor = frame.document()->createElement(HTMLNames::aTag, false);
+    Ref<Element> anchor = frame.document()->createElement(HTMLNames::aTag, false);
     anchor->setAttribute(HTMLNames::hrefAttr, url.string());
     anchor->appendChild(frame.document()->createTextNode([title precomposedStringWithCanonicalMapping]));
 
     fragment = frame.document()->createDocumentFragment();
     anchor->setAttribute(HTMLNames::hrefAttr, url.string());
     anchor->appendChild(frame.document()->createTextNode([title precomposedStringWithCanonicalMapping]));
 
     fragment = frame.document()->createDocumentFragment();
-    fragment->appendChild(anchor.release());
+    fragment->appendChild(WTF::move(anchor));
     return true;
 }
 
     return true;
 }
 
@@ -635,11 +635,11 @@ PassRefPtr<DocumentFragment> Editor::createFragmentForImageResourceAndAddResourc
     if (DocumentLoader* loader = m_frame.loader().documentLoader())
         loader->addArchiveResource(resource.get());
 
     if (DocumentLoader* loader = m_frame.loader().documentLoader())
         loader->addArchiveResource(resource.get());
 
-    RefPtr<Element> imageElement = document().createElement(HTMLNames::imgTag, false);
+    Ref<Element> imageElement = document().createElement(HTMLNames::imgTag, false);
     imageElement->setAttribute(HTMLNames::srcAttr, resource->url().string());
 
     RefPtr<DocumentFragment> fragment = document().createDocumentFragment();
     imageElement->setAttribute(HTMLNames::srcAttr, resource->url().string());
 
     RefPtr<DocumentFragment> fragment = document().createDocumentFragment();
-    fragment->appendChild(imageElement.release());
+    fragment->appendChild(WTF::move(imageElement));
 
     return fragment.release();
 }
 
     return fragment.release();
 }
index 0cac8b4..2054c4e 100644 (file)
@@ -704,12 +704,12 @@ String createMarkup(const Node& node, EChildrenOnly childrenOnly, Vector<Node*>*
     return accumulator.serializeNodes(const_cast<Node&>(node), childrenOnly, tagNamesToSkip);
 }
 
     return accumulator.serializeNodes(const_cast<Node&>(node), childrenOnly, tagNamesToSkip);
 }
 
-static void fillContainerFromString(ContainerNode* paragraph, const String& string)
+static void fillContainerFromString(ContainerNode& paragraph, const String& string)
 {
 {
-    Document& document = paragraph->document();
+    Document& document = paragraph.document();
 
     if (string.isEmpty()) {
 
     if (string.isEmpty()) {
-        paragraph->appendChild(createBlockPlaceholderElement(document), ASSERT_NO_EXCEPTION);
+        paragraph.appendChild(createBlockPlaceholderElement(document), ASSERT_NO_EXCEPTION);
         return;
     }
 
         return;
     }
 
@@ -726,11 +726,11 @@ static void fillContainerFromString(ContainerNode* paragraph, const String& stri
         // append the non-tab textual part
         if (!s.isEmpty()) {
             if (!tabText.isEmpty()) {
         // append the non-tab textual part
         if (!s.isEmpty()) {
             if (!tabText.isEmpty()) {
-                paragraph->appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
+                paragraph.appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
                 tabText = emptyString();
             }
                 tabText = emptyString();
             }
-            RefPtr<Node> textNode = document.createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
-            paragraph->appendChild(textNode.release(), ASSERT_NO_EXCEPTION);
+            Ref<Node> textNode = document.createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
+            paragraph.appendChild(WTF::move(textNode), ASSERT_NO_EXCEPTION);
         }
 
         // there is a tab after every entry, except the last entry
         }
 
         // there is a tab after every entry, except the last entry
@@ -738,7 +738,7 @@ static void fillContainerFromString(ContainerNode* paragraph, const String& stri
         if (i + 1 != numEntries)
             tabText.append('\t');
         else if (!tabText.isEmpty())
         if (i + 1 != numEntries)
             tabText.append('\t');
         else if (!tabText.isEmpty())
-            paragraph->appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
+            paragraph.appendChild(createTabSpanElement(document, tabText), ASSERT_NO_EXCEPTION);
 
         first = false;
     }
 
         first = false;
     }
@@ -778,13 +778,13 @@ static bool contextPreservesNewline(const Range& context)
     return container->renderer()->style().preserveNewline();
 }
 
     return container->renderer()->style().preserveNewline();
 }
 
-PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String& text)
+Ref<DocumentFragment> createFragmentFromText(Range& context, const String& text)
 {
     Document& document = context.ownerDocument();
 {
     Document& document = context.ownerDocument();
-    RefPtr<DocumentFragment> fragment = document.createDocumentFragment();
+    Ref<DocumentFragment> fragment = document.createDocumentFragment();
     
     if (text.isEmpty())
     
     if (text.isEmpty())
-        return fragment.release();
+        return fragment;
 
     String string = text;
     string.replace("\r\n", "\n");
 
     String string = text;
     string.replace("\r\n", "\n");
@@ -793,17 +793,17 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String
     if (contextPreservesNewline(context)) {
         fragment->appendChild(document.createTextNode(string), ASSERT_NO_EXCEPTION);
         if (string.endsWith('\n')) {
     if (contextPreservesNewline(context)) {
         fragment->appendChild(document.createTextNode(string), ASSERT_NO_EXCEPTION);
         if (string.endsWith('\n')) {
-            RefPtr<Element> element = createBreakElement(document);
+            Ref<Element> element = createBreakElement(document);
             element->setAttribute(classAttr, AppleInterchangeNewline);            
             element->setAttribute(classAttr, AppleInterchangeNewline);            
-            fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
+            fragment->appendChild(WTF::move(element), ASSERT_NO_EXCEPTION);
         }
         }
-        return fragment.release();
+        return fragment;
     }
 
     // A string with no newlines gets added inline, rather than being put into a paragraph.
     if (string.find('\n') == notFound) {
     }
 
     // A string with no newlines gets added inline, rather than being put into a paragraph.
     if (string.find('\n') == notFound) {
-        fillContainerFromString(fragment.get(), string);
-        return fragment.release();
+        fillContainerFromString(fragment, string);
+        return fragment;
     }
 
     // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
     }
 
     // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
@@ -829,17 +829,17 @@ PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String
             element->setAttribute(classAttr, AppleInterchangeNewline);
         } else if (useLineBreak) {
             element = createBreakElement(document);
             element->setAttribute(classAttr, AppleInterchangeNewline);
         } else if (useLineBreak) {
             element = createBreakElement(document);
-            fillContainerFromString(fragment.get(), s);
+            fillContainerFromString(fragment, s);
         } else {
             if (useClonesOfEnclosingBlock)
                 element = block->cloneElementWithoutChildren(document);
             else
                 element = createDefaultParagraphElement(document);
         } else {
             if (useClonesOfEnclosingBlock)
                 element = block->cloneElementWithoutChildren(document);
             else
                 element = createDefaultParagraphElement(document);
-            fillContainerFromString(element.get(), s);
+            fillContainerFromString(*element, s);
         }
         }
-        fragment->appendChild(element.release(), ASSERT_NO_EXCEPTION);
+        fragment->appendChild(element.releaseNonNull(), ASSERT_NO_EXCEPTION);
     }
     }
-    return fragment.release();
+    return fragment;
 }
 
 String documentTypeString(const Document& document)
 }
 
 String documentTypeString(const Document& document)
@@ -945,10 +945,10 @@ static void removeElementFromFragmentPreservingChildren(DocumentFragment& fragme
     RefPtr<Node> nextChild;
     for (RefPtr<Node> child = element.firstChild(); child; child = nextChild) {
         nextChild = child->nextSibling();
     RefPtr<Node> nextChild;
     for (RefPtr<Node> child = element.firstChild(); child; child = nextChild) {
         nextChild = child->nextSibling();
-        element.removeChild(child.get(), ASSERT_NO_EXCEPTION);
-        fragment.insertBefore(child, &element, ASSERT_NO_EXCEPTION);
+        element.removeChild(*child, ASSERT_NO_EXCEPTION);
+        fragment.insertBefore(*child, &element, ASSERT_NO_EXCEPTION);
     }
     }
-    fragment.removeChild(&element, ASSERT_NO_EXCEPTION);
+    fragment.removeChild(element, ASSERT_NO_EXCEPTION);
 }
 
 PassRefPtr<DocumentFragment> createContextualFragment(const String& markup, HTMLElement* element, ParserContentPolicy parserContentPolicy, ExceptionCode& ec)
 }
 
 PassRefPtr<DocumentFragment> createContextualFragment(const String& markup, HTMLElement* element, ParserContentPolicy parserContentPolicy, ExceptionCode& ec)
@@ -990,7 +990,7 @@ static inline bool hasOneTextChild(ContainerNode& node)
     return hasOneChild(node) && node.firstChild()->isTextNode();
 }
 
     return hasOneChild(node) && node.firstChild()->isTextNode();
 }
 
-void replaceChildrenWithFragment(ContainerNode& container, PassRefPtr<DocumentFragment> fragment, ExceptionCode& ec)
+void replaceChildrenWithFragment(ContainerNode& container, Ref<DocumentFragment>&& fragment, ExceptionCode& ec)
 {
     Ref<ContainerNode> containerNode(container);
     ChildListMutationScope mutation(containerNode);
 {
     Ref<ContainerNode> containerNode(container);
     ChildListMutationScope mutation(containerNode);
@@ -1000,18 +1000,18 @@ void replaceChildrenWithFragment(ContainerNode& container, PassRefPtr<DocumentFr
         return;
     }
 
         return;
     }
 
-    if (hasOneTextChild(containerNode) && hasOneTextChild(*fragment)) {
+    if (hasOneTextChild(containerNode) && hasOneTextChild(fragment)) {
         downcast<Text>(*containerNode->firstChild()).setData(downcast<Text>(*fragment->firstChild()).data(), ec);
         return;
     }
 
     if (hasOneChild(containerNode)) {
         downcast<Text>(*containerNode->firstChild()).setData(downcast<Text>(*fragment->firstChild()).data(), ec);
         return;
     }
 
     if (hasOneChild(containerNode)) {
-        containerNode->replaceChild(fragment, containerNode->firstChild(), ec);
+        containerNode->replaceChild(WTF::move(fragment), *containerNode->firstChild(), ec);
         return;
     }
 
     containerNode->removeChildren();
         return;
     }
 
     containerNode->removeChildren();
-    containerNode->appendChild(fragment, ec);
+    containerNode->appendChild(WTF::move(fragment), ec);
 }
 
 void replaceChildrenWithText(ContainerNode& container, const String& text, ExceptionCode& ec)
 }
 
 void replaceChildrenWithText(ContainerNode& container, const String& text, ExceptionCode& ec)
@@ -1027,7 +1027,7 @@ void replaceChildrenWithText(ContainerNode& container, const String& text, Excep
     Ref<Text> textNode = Text::create(containerNode->document(), text);
 
     if (hasOneChild(containerNode)) {
     Ref<Text> textNode = Text::create(containerNode->document(), text);
 
     if (hasOneChild(containerNode)) {
-        containerNode->replaceChild(WTF::move(textNode), containerNode->firstChild(), ec);
+        containerNode->replaceChild(WTF::move(textNode), *containerNode->firstChild(), ec);
         return;
     }
 
         return;
     }
 
index c552010..a545ba5 100644 (file)
@@ -49,7 +49,7 @@ enum EChildrenOnly { IncludeNode, ChildrenOnly };
 enum EAbsoluteURLs { DoNotResolveURLs, ResolveAllURLs, ResolveNonLocalURLs };
 enum EFragmentSerialization { HTMLFragmentSerialization, XMLFragmentSerialization };
 
 enum EAbsoluteURLs { DoNotResolveURLs, ResolveAllURLs, ResolveNonLocalURLs };
 enum EFragmentSerialization { HTMLFragmentSerialization, XMLFragmentSerialization };
 
-WEBCORE_EXPORT PassRefPtr<DocumentFragment> createFragmentFromText(Range& context, const String& text);
+WEBCORE_EXPORT Ref<DocumentFragment> createFragmentFromText(Range& context, const String& text);
 WEBCORE_EXPORT Ref<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);
 WEBCORE_EXPORT Ref<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);
@@ -59,11 +59,11 @@ bool isPlainTextMarkup(Node*);
 
 // These methods are used by HTMLElement & ShadowRoot to replace the
 // children with respected fragment/text.
 
 // These methods are used by HTMLElement & ShadowRoot to replace the
 // children with respected fragment/text.
-void replaceChildrenWithFragment(ContainerNode&, PassRefPtr<DocumentFragment>, ExceptionCode&);
+void replaceChildrenWithFragment(ContainerNode&, Ref<DocumentFragment>&&, ExceptionCode&);
 void replaceChildrenWithText(ContainerNode&, const String&, 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*>* = nullptr, EAnnotateForInterchange = DoNotAnnotateForInterchange, bool convertBlocksToInlines = false, EAbsoluteURLs = DoNotResolveURLs);
+String createMarkup(const Node&, EChildrenOnly = IncludeNode, Vector<Node*>* = nullptr, EAbsoluteURLs = DoNotResolveURLs, Vector<QualifiedName>* tagNamesToSkip = 0, EFragmentSerialization = HTMLFragmentSerialization);
 
 WEBCORE_EXPORT String createFullMarkup(const Node&);
 WEBCORE_EXPORT String createFullMarkup(const Range&);
 
 WEBCORE_EXPORT String createFullMarkup(const Node&);
 WEBCORE_EXPORT String createFullMarkup(const Range&);
index dbea0e9..57e388b 100644 (file)
@@ -60,9 +60,9 @@ void BaseChooserOnlyDateAndTimeInputType::createShadowSubtree()
 {
     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, valueContainerPseudo, ("-webkit-date-and-time-value", AtomicString::ConstructFromLiteral));
 
 {
     DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, valueContainerPseudo, ("-webkit-date-and-time-value", AtomicString::ConstructFromLiteral));
 
-    RefPtr<HTMLDivElement> valueContainer = HTMLDivElement::create(element().document());
+    Ref<HTMLDivElement> valueContainer = HTMLDivElement::create(element().document());
     valueContainer->setPseudo(valueContainerPseudo);
     valueContainer->setPseudo(valueContainerPseudo);
-    element().userAgentShadowRoot()->appendChild(valueContainer.get());
+    element().userAgentShadowRoot()->appendChild(WTF::move(valueContainer));
     updateAppearance();
 }
 
     updateAppearance();
 }
 
index 8bbdb97..c5385a0 100644 (file)
@@ -107,12 +107,12 @@ void ColorInputType::createShadowSubtree()
     ASSERT(element().shadowRoot());
 
     Document& document = element().document();
     ASSERT(element().shadowRoot());
 
     Document& document = element().document();
-    RefPtr<HTMLDivElement> wrapperElement = HTMLDivElement::create(document);
+    Ref<HTMLDivElement> wrapperElement = HTMLDivElement::create(document);
     wrapperElement->setPseudo(AtomicString("-webkit-color-swatch-wrapper", AtomicString::ConstructFromLiteral));
     wrapperElement->setPseudo(AtomicString("-webkit-color-swatch-wrapper", AtomicString::ConstructFromLiteral));
-    RefPtr<HTMLDivElement> colorSwatch = HTMLDivElement::create(document);
+    Ref<HTMLDivElement> colorSwatch = HTMLDivElement::create(document);
     colorSwatch->setPseudo(AtomicString("-webkit-color-swatch", AtomicString::ConstructFromLiteral));
     colorSwatch->setPseudo(AtomicString("-webkit-color-swatch", AtomicString::ConstructFromLiteral));
-    wrapperElement->appendChild(colorSwatch.release(), ASSERT_NO_EXCEPTION);
-    element().userAgentShadowRoot()->appendChild(wrapperElement.release(), ASSERT_NO_EXCEPTION);
+    wrapperElement->appendChild(WTF::move(colorSwatch), ASSERT_NO_EXCEPTION);
+    element().userAgentShadowRoot()->appendChild(WTF::move(wrapperElement), ASSERT_NO_EXCEPTION);
     
     updateColorSwatch();
 }
     
     updateColorSwatch();
 }
index 4065a17..1447a46 100644 (file)
@@ -104,27 +104,27 @@ void FTPDirectoryDocumentParser::appendEntry(const String& filename, const Strin
     RefPtr<Element> rowElement = m_tableElement->insertRow(-1, IGNORE_EXCEPTION);
     rowElement->setAttribute(HTMLNames::classAttr, "ftpDirectoryEntryRow");
 
     RefPtr<Element> rowElement = m_tableElement->insertRow(-1, IGNORE_EXCEPTION);
     rowElement->setAttribute(HTMLNames::classAttr, "ftpDirectoryEntryRow");
 
-    RefPtr<Element> element = document()->createElement(tdTag, false);
+    Ref<Element> element = document()->createElement(tdTag, false);
     element->appendChild(Text::create(*document(), String(&noBreakSpace, 1)), IGNORE_EXCEPTION);
     if (isDirectory)
         element->setAttribute(HTMLNames::classAttr, "ftpDirectoryIcon ftpDirectoryTypeDirectory");
     else
         element->setAttribute(HTMLNames::classAttr, "ftpDirectoryIcon ftpDirectoryTypeFile");
     element->appendChild(Text::create(*document(), String(&noBreakSpace, 1)), IGNORE_EXCEPTION);
     if (isDirectory)
         element->setAttribute(HTMLNames::classAttr, "ftpDirectoryIcon ftpDirectoryTypeDirectory");
     else
         element->setAttribute(HTMLNames::classAttr, "ftpDirectoryIcon ftpDirectoryTypeFile");
-    rowElement->appendChild(element, IGNORE_EXCEPTION);
+    rowElement->appendChild(WTF::move(element), IGNORE_EXCEPTION);
 
     element = createTDForFilename(filename);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileName");
 
     element = createTDForFilename(filename);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileName");
-    rowElement->appendChild(element, IGNORE_EXCEPTION);
+    rowElement->appendChild(WTF::move(element), IGNORE_EXCEPTION);
 
     element = document()->createElement(tdTag, false);
     element->appendChild(Text::create(*document(), date), IGNORE_EXCEPTION);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileDate");
 
     element = document()->createElement(tdTag, false);
     element->appendChild(Text::create(*document(), date), IGNORE_EXCEPTION);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileDate");
-    rowElement->appendChild(element, IGNORE_EXCEPTION);
+    rowElement->appendChild(WTF::move(element), IGNORE_EXCEPTION);
 
     element = document()->createElement(tdTag, false);
     element->appendChild(Text::create(*document(), size), IGNORE_EXCEPTION);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileSize");
 
     element = document()->createElement(tdTag, false);
     element->appendChild(Text::create(*document(), size), IGNORE_EXCEPTION);
     element->setAttribute(HTMLNames::classAttr, "ftpDirectoryFileSize");
-    rowElement->appendChild(element, IGNORE_EXCEPTION);
+    rowElement->appendChild(WTF::move(element), IGNORE_EXCEPTION);
 }
 
 Ref<Element> FTPDirectoryDocumentParser::createTDForFilename(const String& filename)
 }
 
 Ref<Element> FTPDirectoryDocumentParser::createTDForFilename(const String& filename)
@@ -135,12 +135,12 @@ Ref<Element> FTPDirectoryDocumentParser::createTDForFilename(const String& filen
     else
         fullURL = fullURL + '/' + filename;
 
     else
         fullURL = fullURL + '/' + filename;
 
-    RefPtr<Element> anchorElement = document()->createElement(aTag, false);
+    Ref<Element> anchorElement = document()->createElement(aTag, false);
     anchorElement->setAttribute(HTMLNames::hrefAttr, fullURL);
     anchorElement->appendChild(Text::create(*document(), filename), IGNORE_EXCEPTION);
 
     Ref<Element> tdElement = document()->createElement(tdTag, false);
     anchorElement->setAttribute(HTMLNames::hrefAttr, fullURL);
     anchorElement->appendChild(Text::create(*document(), filename), IGNORE_EXCEPTION);
 
     Ref<Element> tdElement = document()->createElement(tdTag, false);
-    tdElement->appendChild(anchorElement, IGNORE_EXCEPTION);
+    tdElement->appendChild(WTF::move(anchorElement), IGNORE_EXCEPTION);
 
     return tdElement;
 }
 
     return tdElement;
 }
@@ -312,9 +312,9 @@ bool FTPDirectoryDocumentParser::loadDocumentTemplate()
     // If that fails for some reason, cram it on the end of the document as a last
     // ditch effort
     if (auto* body = document()->bodyOrFrameset())
     // If that fails for some reason, cram it on the end of the document as a last
     // ditch effort
     if (auto* body = document()->bodyOrFrameset())
-        body->appendChild(m_tableElement, IGNORE_EXCEPTION);
+        body->appendChild(*m_tableElement, IGNORE_EXCEPTION);
     else
     else
-        document()->appendChild(m_tableElement, IGNORE_EXCEPTION);
+        document()->appendChild(*m_tableElement, IGNORE_EXCEPTION);
 
     return true;
 }
 
     return true;
 }
@@ -325,16 +325,16 @@ void FTPDirectoryDocumentParser::createBasicDocument()
 
     // FIXME: Make this "basic document" more acceptable
 
 
     // FIXME: Make this "basic document" more acceptable
 
-    RefPtr<Element> bodyElement = document()->createElement(bodyTag, false);
+    Ref<Element> bodyElement = document()->createElement(bodyTag, false);
 
 
-    document()->appendChild(bodyElement, IGNORE_EXCEPTION);
+    document()->appendChild(bodyElement.copyRef(), IGNORE_EXCEPTION);
 
 
-    RefPtr<Element> tableElement = document()->createElement(tableTag, false);
-    m_tableElement = downcast<HTMLTableElement>(tableElement.get());
+    Ref<Element> tableElement = document()->createElement(tableTag, false);
+    m_tableElement = downcast<HTMLTableElement>(tableElement.ptr());
     m_tableElement->setAttribute(HTMLNames::idAttr, "ftpDirectoryTable");
     m_tableElement->setAttribute(HTMLNames::styleAttr, "width:100%");
 
     m_tableElement->setAttribute(HTMLNames::idAttr, "ftpDirectoryTable");
     m_tableElement->setAttribute(HTMLNames::styleAttr, "width:100%");
 
-    bodyElement->appendChild(m_tableElement, IGNORE_EXCEPTION);
+    bodyElement->appendChild(WTF::move(tableElement), IGNORE_EXCEPTION);
 
     document()->processViewport("width=device-width", ViewportArguments::ViewportMeta);
 }
 
     document()->processViewport("width=device-width", ViewportArguments::ViewportMeta);
 }
index 430212c..48cc9b8 100644 (file)
@@ -90,11 +90,11 @@ private:
 
 Ref<DetailsSummaryElement> DetailsSummaryElement::create(Document& document)
 {
 
 Ref<DetailsSummaryElement> DetailsSummaryElement::create(Document& document)
 {
-    RefPtr<HTMLSummaryElement> summary = HTMLSummaryElement::create(summaryTag, document);
+    Ref<HTMLSummaryElement> summary = HTMLSummaryElement::create(summaryTag, document);
     summary->appendChild(Text::create(document, defaultDetailsSummaryText()), ASSERT_NO_EXCEPTION);
 
     Ref<DetailsSummaryElement> detailsSummary = adoptRef(*new DetailsSummaryElement(document));
     summary->appendChild(Text::create(document, defaultDetailsSummaryText()), ASSERT_NO_EXCEPTION);
 
     Ref<DetailsSummaryElement> detailsSummary = adoptRef(*new DetailsSummaryElement(document));
-    detailsSummary->appendChild(summary);
+    detailsSummary->appendChild(WTF::move(summary));
     return detailsSummary;
 }
 
     return detailsSummary;
 }
 
index 520ce03..5c377da 100644 (file)
@@ -584,9 +584,9 @@ void HTMLElement::setInnerText(const String& text, ExceptionCode& ec)
 
     // Add text nodes and <br> elements.
     ec = 0;
 
     // Add text nodes and <br> elements.
     ec = 0;
-    RefPtr<DocumentFragment> fragment = textToFragment(text, ec);
+    Ref<DocumentFragment> fragment = textToFragment(text, ec);
     if (!ec)
     if (!ec)
-        replaceChildrenWithFragment(*this, fragment.release(), ec);
+        replaceChildrenWithFragment(*this, WTF::move(fragment), ec);
 }
 
 void HTMLElement::setOuterText(const String& text, ExceptionCode& ec)
 }
 
 void HTMLElement::setOuterText(const String& text, ExceptionCode& ec)
@@ -621,7 +621,7 @@ void HTMLElement::setOuterText(const String& text, ExceptionCode& ec)
         ec = HIERARCHY_REQUEST_ERR;
     if (ec)
         return;
         ec = HIERARCHY_REQUEST_ERR;
     if (ec)
         return;
-    parent->replaceChild(newChild.release(), this, ec);
+    parent->replaceChild(newChild.releaseNonNull(), *this, ec);
 
     RefPtr<Node> node = next ? next->previousSibling() : nullptr;
     if (!ec && is<Text>(node.get()))
 
     RefPtr<Node> node = next ? next->previousSibling() : nullptr;
     if (!ec && is<Text>(node.get()))
@@ -630,7 +630,7 @@ void HTMLElement::setOuterText(const String& text, ExceptionCode& ec)
         mergeWithNextTextNode(downcast<Text>(*prev), ec);
 }
 
         mergeWithNextTextNode(downcast<Text>(*prev), ec);
 }
 
-Node* HTMLElement::insertAdjacent(const String& where, Node* newChild, ExceptionCode& ec)
+Node* HTMLElement::insertAdjacent(const String& where, Ref<Node>&& newChild, ExceptionCode& ec)
 {
     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
     // a document fragment is created and the elements appended in the correct order. This document
 {
     // In Internet Explorer if the element has no parent and where is "beforeBegin" or "afterEnd",
     // a document fragment is created and the elements appended in the correct order. This document
@@ -641,18 +641,18 @@ Node* HTMLElement::insertAdjacent(const String& where, Node* newChild, Exception
 
     if (equalIgnoringCase(where, "beforeBegin")) {
         ContainerNode* parent = this->parentNode();
 
     if (equalIgnoringCase(where, "beforeBegin")) {
         ContainerNode* parent = this->parentNode();
-        return (parent && parent->insertBefore(newChild, this, ec)) ? newChild : nullptr;
+        return (parent && parent->insertBefore(newChild.copyRef(), this, ec)) ? newChild.ptr() : nullptr;
     }
 
     if (equalIgnoringCase(where, "afterBegin"))
     }
 
     if (equalIgnoringCase(where, "afterBegin"))
-        return insertBefore(newChild, firstChild(), ec) ? newChild : nullptr;
+        return insertBefore(newChild.copyRef(), firstChild(), ec) ? newChild.ptr() : nullptr;
 
     if (equalIgnoringCase(where, "beforeEnd"))
 
     if (equalIgnoringCase(where, "beforeEnd"))
-        return appendChild(newChild, ec) ? newChild : nullptr;
+        return appendChild(newChild.copyRef(), ec) ? newChild.ptr() : nullptr;
 
     if (equalIgnoringCase(where, "afterEnd")) {
         ContainerNode* parent = this->parentNode();
 
     if (equalIgnoringCase(where, "afterEnd")) {
         ContainerNode* parent = this->parentNode();
-        return (parent && parent->insertBefore(newChild, nextSibling(), ec)) ? newChild : nullptr;
+        return (parent && parent->insertBefore(newChild.copyRef(), nextSibling(), ec)) ? newChild.ptr() : nullptr;
     }
     
     // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
     }
     
     // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
@@ -668,7 +668,7 @@ Element* HTMLElement::insertAdjacentElement(const String& where, Element* newChi
         return nullptr;
     }
 
         return nullptr;
     }
 
-    Node* returnValue = insertAdjacent(where, newChild, ec);
+    Node* returnValue = insertAdjacent(where, *newChild, ec);
     ASSERT_WITH_SECURITY_IMPLICATION(!returnValue || is<Element>(*returnValue));
     return downcast<Element>(returnValue); 
 }
     ASSERT_WITH_SECURITY_IMPLICATION(!returnValue || is<Element>(*returnValue));
     return downcast<Element>(returnValue); 
 }
@@ -699,13 +699,12 @@ void HTMLElement::insertAdjacentHTML(const String& where, const String& markup,
     RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, contextElement, AllowScriptingContent, ec);
     if (!fragment)
         return;
     RefPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, contextElement, AllowScriptingContent, ec);
     if (!fragment)
         return;
-    insertAdjacent(where, fragment.get(), ec);
+    insertAdjacent(where, fragment.releaseNonNull(), ec);
 }
 
 void HTMLElement::insertAdjacentText(const String& where, const String& text, ExceptionCode& ec)
 {
 }
 
 void HTMLElement::insertAdjacentText(const String& where, const String& text, ExceptionCode& ec)
 {
-    RefPtr<Text> textNode = document().createTextNode(text);
-    insertAdjacent(where, textNode.get(), ec);
+    insertAdjacent(where, document().createTextNode(text), ec);
 }
 
 void HTMLElement::applyAlignmentAttributeToStyle(const AtomicString& alignment, MutableStyleProperties& style)
 }
 
 void HTMLElement::applyAlignmentAttributeToStyle(const AtomicString& alignment, MutableStyleProperties& style)
index 30e3775..70d4961 100644 (file)
@@ -130,7 +130,7 @@ private:
 
     virtual HTMLFormElement* virtualForm() const;
 
 
     virtual HTMLFormElement* virtualForm() const;
 
-    Node* insertAdjacent(const String& where, Node* newChild, ExceptionCode&);
+    Node* insertAdjacent(const String& where, Ref<Node>&& newChild, ExceptionCode&);
     Ref<DocumentFragment> textToFragment(const String&, ExceptionCode&);
 
     void dirAttributeChanged(const AtomicString&);
     Ref<DocumentFragment> textToFragment(const String&, ExceptionCode&);
 
     void dirAttributeChanged(const AtomicString&);
index b2a277a..a4a73ca 100644 (file)
@@ -504,7 +504,7 @@ void HTMLImageElement::createImageControls()
     if (!imageControls)
         return;
 
     if (!imageControls)
         return;
 
-    ensureUserAgentShadowRoot().appendChild(imageControls);
+    ensureUserAgentShadowRoot().appendChild(imageControls.releaseNonNull());
 
     auto* renderObject = renderer();
     if (!renderObject)
 
     auto* renderObject = renderer();
     if (!renderObject)
@@ -521,7 +521,7 @@ void HTMLImageElement::destroyImageControls()
 
     if (Node* node = shadowRoot->firstChild()) {
         ASSERT_WITH_SECURITY_IMPLICATION(node->isImageControlsRootElement());
 
     if (Node* node = shadowRoot->firstChild()) {
         ASSERT_WITH_SECURITY_IMPLICATION(node->isImageControlsRootElement());
-        shadowRoot->removeChild(node);
+        shadowRoot->removeChild(*node);
     }
 
     auto* renderObject = renderer();
     }
 
     auto* renderObject = renderer();
index e7d9148..4a63b00 100644 (file)
@@ -58,7 +58,7 @@ protected:
     }
 
 private:
     }
 
 private:
-    virtual RefPtr<Element> cloneElementWithoutAttributesAndChildren(Document& targetDocument) override
+    virtual Ref<Element> cloneElementWithoutAttributesAndChildren(Document& targetDocument) override
     {
         return create(targetDocument);
     }
     {
         return create(targetDocument);
     }
@@ -73,14 +73,14 @@ inline HTMLKeygenElement::HTMLKeygenElement(const QualifiedName& tagName, Docume
     Vector<String> keys;
     getSupportedKeySizes(keys);
 
     Vector<String> keys;
     getSupportedKeySizes(keys);
 
-    RefPtr<HTMLSelectElement> select = KeygenSelectElement::create(document);
+    Ref<HTMLSelectElement> select = KeygenSelectElement::create(document);
     for (size_t i = 0; i < keys.size(); ++i) {
     for (size_t i = 0; i < keys.size(); ++i) {
-        RefPtr<HTMLOptionElement> option = HTMLOptionElement::create(document);
-        select->appendChild(option, IGNORE_EXCEPTION);
+        Ref<HTMLOptionElement> option = HTMLOptionElement::create(document);
+        select->appendChild(option.copyRef(), IGNORE_EXCEPTION);
         option->appendChild(Text::create(document, keys[i]), IGNORE_EXCEPTION);
     }
 
         option->appendChild(Text::create(document, keys[i]), IGNORE_EXCEPTION);
     }
 
-    ensureUserAgentShadowRoot().appendChild(select, IGNORE_EXCEPTION);
+    ensureUserAgentShadowRoot().appendChild(WTF::move(select), IGNORE_EXCEPTION);
 }
 
 Ref<HTMLKeygenElement> HTMLKeygenElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
 }
 
 Ref<HTMLKeygenElement> HTMLKeygenElement::create(const QualifiedName& tagName, Document& document, HTMLFormElement* form)
index 22b2f39..e5e3de0 100644 (file)
@@ -229,16 +229,16 @@ void HTMLMeterElement::didAddUserAgentShadowRoot(ShadowRoot* root)
 {
     ASSERT(!m_value);
 
 {
     ASSERT(!m_value);
 
-    RefPtr<MeterInnerElement> inner = MeterInnerElement::create(document());
-    root->appendChild(inner);
+    Ref<MeterInnerElement> inner = MeterInnerElement::create(document());
+    root->appendChild(inner.copyRef());
 
 
-    RefPtr<MeterBarElement> bar = MeterBarElement::create(document());
+    Ref<MeterBarElement> bar = MeterBarElement::create(document());
     m_value = MeterValueElement::create(document());
     m_value->setWidthPercentage(0);
     m_value->updatePseudo();
     m_value = MeterValueElement::create(document());
     m_value->setWidthPercentage(0);
     m_value->updatePseudo();
-    bar->appendChild(m_value, ASSERT_NO_EXCEPTION);
+    bar->appendChild(*m_value, ASSERT_NO_EXCEPTION);
 
 
-    inner->appendChild(bar, ASSERT_NO_EXCEPTION);
+    inner->appendChild(WTF::move(bar), ASSERT_NO_EXCEPTION);
 }
 
 } // namespace
 }
 
 } // namespace
index 2dfff26..ed9caea 100644 (file)
@@ -71,12 +71,12 @@ RefPtr<HTMLOptionElement> HTMLOptionElement::createForJSConstructor(Document& do
 {
     RefPtr<HTMLOptionElement> element = adoptRef(new HTMLOptionElement(optionTag, document));
 
 {
     RefPtr<HTMLOptionElement> element = adoptRef(new HTMLOptionElement(optionTag, document));
 
-    RefPtr<Text> text = Text::create(document, data.isNull() ? "" : data);
+    Ref<Text> text = Text::create(document, data.isNull() ? "" : data);
 
     ec = 0;
 
     ec = 0;
-    element->appendChild(text.release(), ec);
+    element->appendChild(WTF::move(text), ec);
     if (ec)
     if (ec)
-        return 0;
+        return nullptr;
 
     if (!value.isNull())
         element->setValue(value);
 
     if (!value.isNull())
         element->setValue(value);
@@ -84,7 +84,7 @@ RefPtr<HTMLOptionElement> HTMLOptionElement::createForJSConstructor(Document& do
         element->setAttribute(selectedAttr, emptyAtom);
     element->setSelected(selected);
 
         element->setAttribute(selectedAttr, emptyAtom);
     element->setSelected(selected);
 
-    return element.release();
+    return element;
 }
 
 bool HTMLOptionElement::isFocusable() const
 }
 
 bool HTMLOptionElement::isFocusable() const
index 87f0e37..db7d06a 100644 (file)
@@ -149,16 +149,16 @@ void HTMLProgressElement::didAddUserAgentShadowRoot(ShadowRoot* root)
 {
     ASSERT(!m_value);
 
 {
     ASSERT(!m_value);
 
-    RefPtr<ProgressInnerElement> inner = ProgressInnerElement::create(document());
-    root->appendChild(inner);
+    Ref<ProgressInnerElement> inner = ProgressInnerElement::create(document());
+    root->appendChild(inner.copyRef());
 
 
-    RefPtr<ProgressBarElement> bar = ProgressBarElement::create(document());
-    RefPtr<ProgressValueElement> value = ProgressValueElement::create(document());
-    m_value = value.get();
+    Ref<ProgressBarElement> bar = ProgressBarElement::create(document());
+    Ref<ProgressValueElement> value = ProgressValueElement::create(document());
+    m_value = value.ptr();
     m_value->setWidthPercentage(HTMLProgressElement::IndeterminatePosition * 100);
     m_value->setWidthPercentage(HTMLProgressElement::IndeterminatePosition * 100);
-    bar->appendChild(m_value, ASSERT_NO_EXCEPTION);
+    bar->appendChild(*m_value, ASSERT_NO_EXCEPTION);
 
 
-    inner->appendChild(bar, ASSERT_NO_EXCEPTION);
+    inner->appendChild(WTF::move(bar), ASSERT_NO_EXCEPTION);
 }
 
 bool HTMLProgressElement::shouldAppearIndeterminate() const
 }
 
 bool HTMLProgressElement::shouldAppearIndeterminate() const
index 6951146..e13a5cd 100644 (file)
@@ -169,9 +169,9 @@ void HTMLScriptElement::dispatchLoadEvent()
     dispatchEvent(Event::create(eventNames().loadEvent, false, false));
 }
 
     dispatchEvent(Event::create(eventNames().loadEvent, false, false));
 }
 
-RefPtr<Element> HTMLScriptElement::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
+Ref<Element> HTMLScriptElement::cloneElementWithoutAttributesAndChildren(Document& targetDocument)
 {
 {
-    return adoptRef(new HTMLScriptElement(tagQName(), targetDocument, false, alreadyStarted()));
+    return adoptRef(*new HTMLScriptElement(tagQName(), targetDocument, false, alreadyStarted()));
 }
 
 }
 }
 
 }
index e39c10c..312c662 100644 (file)
@@ -65,7 +65,7 @@ private:
 
     virtual void dispatchLoadEvent() override;
 
 
     virtual void dispatchLoadEvent() override;
 
-    virtual RefPtr<Element> cloneElementWithoutAttributesAndChildren(Document&) override;
+    virtual Ref<Element> cloneElementWithoutAttributesAndChildren(Document&) override;
 };
 
 } //namespace
 };
 
 } //namespace
index eb73945..4f10458 100644 (file)
@@ -227,7 +227,7 @@ void HTMLSelectElement::add(HTMLElement* element, HTMLElement* beforeElement, Ex
     // Make sure the element is ref'd and deref'd so we don't leak it.
     Ref<HTMLElement> protectNewChild(*element);
 
     // Make sure the element is ref'd and deref'd so we don't leak it.
     Ref<HTMLElement> protectNewChild(*element);
 
-    insertBefore(element, beforeElement, ec);
+    insertBefore(*element, beforeElement, ec);
     updateValidity();
 }
 
     updateValidity();
 }
 
@@ -486,12 +486,12 @@ void HTMLSelectElement::setLength(unsigned newLen, ExceptionCode& ec)
 
         // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
         // of elements that we intend to remove then attempt to remove them one at a time.
 
         // Removing children fires mutation events, which might mutate the DOM further, so we first copy out a list
         // of elements that we intend to remove then attempt to remove them one at a time.
-        Vector<RefPtr<Element>> itemsToRemove;
+        Vector<Ref<Element>> itemsToRemove;
         size_t optionIndex = 0;
         for (auto& item : items) {
             if (is<HTMLOptionElement>(*item) && optionIndex++ >= newLen) {
                 ASSERT(item->parentNode());
         size_t optionIndex = 0;
         for (auto& item : items) {
             if (is<HTMLOptionElement>(*item) && optionIndex++ >= newLen) {
                 ASSERT(item->parentNode());
-                itemsToRemove.append(item);
+                itemsToRemove.append(*item);
             }
         }
 
             }
         }
 
index cfb4de3..cf9e9a5 100644 (file)
@@ -81,7 +81,7 @@ void HTMLTableElement::setCaption(PassRefPtr<HTMLTableCaptionElement> newCaption
 {
     deleteCaption();
     if (newCaption)
 {
     deleteCaption();
     if (newCaption)
-        insertBefore(newCaption, firstChild(), ec);
+        insertBefore(*newCaption, firstChild(), ec);
 }
 
 HTMLTableSectionElement* HTMLTableElement::tHead() const
 }
 
 HTMLTableSectionElement* HTMLTableElement::tHead() const
@@ -110,7 +110,7 @@ void HTMLTableElement::setTHead(PassRefPtr<HTMLTableSectionElement> newHead, Exc
         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
             break;
 
         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
             break;
 
-    insertBefore(newHead, child, ec);
+    insertBefore(*newHead, child, ec);
 }
 
 HTMLTableSectionElement* HTMLTableElement::tFoot() const
 }
 
 HTMLTableSectionElement* HTMLTableElement::tFoot() const
@@ -139,57 +139,60 @@ void HTMLTableElement::setTFoot(PassRefPtr<HTMLTableSectionElement> newFoot, Exc
         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
             break;
 
         if (child->isElementNode() && !child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
             break;
 
-    insertBefore(newFoot, child, ec);
+    insertBefore(*newFoot, child, ec);
 }
 
 }
 
-RefPtr<HTMLElement> HTMLTableElement::createTHead()
+Ref<HTMLTableSectionElement> HTMLTableElement::createTHead()
 {
     if (HTMLTableSectionElement* existingHead = tHead())
 {
     if (HTMLTableSectionElement* existingHead = tHead())
-        return existingHead;
-    RefPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
-    setTHead(head, IGNORE_EXCEPTION);
+        return *existingHead;
+    Ref<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
+    setTHead(head.ptr(), IGNORE_EXCEPTION);
     return head;
 }
 
 void HTMLTableElement::deleteTHead()
 {
     return head;
 }
 
 void HTMLTableElement::deleteTHead()
 {
-    removeChild(tHead(), IGNORE_EXCEPTION);
+    if (auto* tHead = this->tHead())
+        removeChild(*tHead, IGNORE_EXCEPTION);
 }
 
 }
 
-RefPtr<HTMLElement> HTMLTableElement::createTFoot()
+Ref<HTMLTableSectionElement> HTMLTableElement::createTFoot()
 {
     if (HTMLTableSectionElement* existingFoot = tFoot())
 {
     if (HTMLTableSectionElement* existingFoot = tFoot())
-        return existingFoot;
-    RefPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
-    setTFoot(foot, IGNORE_EXCEPTION);
+        return *existingFoot;
+    Ref<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
+    setTFoot(foot.ptr(), IGNORE_EXCEPTION);
     return foot;
 }
 
 void HTMLTableElement::deleteTFoot()
 {
     return foot;
 }
 
 void HTMLTableElement::deleteTFoot()
 {
-    removeChild(tFoot(), IGNORE_EXCEPTION);
+    if (auto* tFoot = this->tFoot())
+        removeChild(*tFoot, IGNORE_EXCEPTION);
 }
 
 }
 
-RefPtr<HTMLElement> HTMLTableElement::createTBody()
+Ref<HTMLTableSectionElement> HTMLTableElement::createTBody()
 {
 {
-    RefPtr<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
-    Node* referenceElement = lastBody() ? lastBody()->nextSibling() : 0;
-    insertBefore(body, referenceElement, ASSERT_NO_EXCEPTION);
+    Ref<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
+    Node* referenceElement = lastBody() ? lastBody()->nextSibling() : nullptr;
+    insertBefore(body.copyRef(), referenceElement, ASSERT_NO_EXCEPTION);
     return body;
 }
 
     return body;
 }
 
-RefPtr<HTMLElement> HTMLTableElement::createCaption()
+Ref<HTMLTableCaptionElement> HTMLTableElement::createCaption()
 {
     if (HTMLTableCaptionElement* existingCaption = caption())
 {
     if (HTMLTableCaptionElement* existingCaption = caption())
-        return existingCaption;
-    RefPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(captionTag, document());
-    setCaption(caption, IGNORE_EXCEPTION);
+        return *existingCaption;
+    Ref<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(captionTag, document());
+    setCaption(caption.ptr(), IGNORE_EXCEPTION);
     return caption;
 }
 
 void HTMLTableElement::deleteCaption()
 {
     return caption;
 }
 
 void HTMLTableElement::deleteCaption()
 {
-    removeChild(caption(), IGNORE_EXCEPTION);
+    if (auto* caption = this->caption())
+        removeChild(*caption, IGNORE_EXCEPTION);
 }
 
 HTMLTableSectionElement* HTMLTableElement::lastBody() const
 }
 
 HTMLTableSectionElement* HTMLTableElement::lastBody() const
@@ -234,22 +237,22 @@ RefPtr<HTMLElement> HTMLTableElement::insertRow(int index, ExceptionCode& ec)
     else {
         parent = lastBody();
         if (!parent) {
     else {
         parent = lastBody();
         if (!parent) {
-            RefPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
-            RefPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
-            newBody->appendChild(newRow, ec);
-            appendChild(newBody.release(), ec);
-            return newRow;
+            Ref<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
+            Ref<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
+            newBody->appendChild(newRow.copyRef(), ec);
+            appendChild(WTF::move(newBody), ec);
+            return WTF::move(newRow);
         }
     }
 
         }
     }
 
-    RefPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
-    parent->insertBefore(newRow, row.get(), ec);
-    return newRow;
+    Ref<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
+    parent->insertBefore(newRow.copyRef(), row.get(), ec);
+    return WTF::move(newRow);
 }
 
 void HTMLTableElement::deleteRow(int index, ExceptionCode& ec)
 {
 }
 
 void HTMLTableElement::deleteRow(int index, ExceptionCode& ec)
 {
-    HTMLTableRowElement* row = 0;
+    HTMLTableRowElement* row = nullptr;
     if (index == -1)
         row = HTMLTableRowsCollection::lastRow(*this);
     else {
     if (index == -1)
         row = HTMLTableRowsCollection::lastRow(*this);
     else {
index cf5f4a0..3075835 100644 (file)
@@ -49,12 +49,12 @@ public:
     HTMLTableSectionElement* tFoot() const;
     void setTFoot(PassRefPtr<HTMLTableSectionElement>, ExceptionCode&);
 
     HTMLTableSectionElement* tFoot() const;
     void setTFoot(PassRefPtr<HTMLTableSectionElement>, ExceptionCode&);
 
-    RefPtr<HTMLElement> createTHead();
+    Ref<HTMLTableSectionElement> createTHead();
     void deleteTHead();
     void deleteTHead();
-    RefPtr<HTMLElement> createTFoot();
+    Ref<HTMLTableSectionElement> createTFoot();
     void deleteTFoot();
     void deleteTFoot();
-    RefPtr<HTMLElement> createTBody();
-    RefPtr<HTMLElement> createCaption();
+    Ref<HTMLTableSectionElement> createTBody();
+    Ref<HTMLTableCaptionElement> createCaption();
     void deleteCaption();
     RefPtr<HTMLElement> insertRow(ExceptionCode& ec) { return insertRow(-1, ec); }
     RefPtr<HTMLElement> insertRow(int index, ExceptionCode&);
     void deleteCaption();
     RefPtr<HTMLElement> insertRow(ExceptionCode& ec) { return insertRow(-1, ec); }
     RefPtr<HTMLElement> insertRow(int index, ExceptionCode&);
index c87259f..d8893cd 100644 (file)
@@ -28,7 +28,6 @@
 #include "ExceptionCode.h"
 #include "GenericCachedHTMLCollection.h"
 #include "HTMLNames.h"
 #include "ExceptionCode.h"
 #include "GenericCachedHTMLCollection.h"
 #include "HTMLNames.h"
-#include "HTMLTableCellElement.h"
 #include "HTMLTableElement.h"
 #include "HTMLTableSectionElement.h"
 #include "NodeList.h"
 #include "HTMLTableElement.h"
 #include "HTMLTableSectionElement.h"
 #include "NodeList.h"
@@ -119,27 +118,27 @@ int HTMLTableRowElement::sectionRowIndex() const
     return rIndex;
 }
 
     return rIndex;
 }
 
-RefPtr<HTMLElement> HTMLTableRowElement::insertCell(int index, ExceptionCode& ec)
+RefPtr<HTMLTableCellElement> HTMLTableRowElement::insertCell(int index, ExceptionCode& ec)
 {
     Ref<HTMLCollection> children = cells();
     int numCells = children->length();
     if (index < -1 || index > numCells) {
         ec = INDEX_SIZE_ERR;
 {
     Ref<HTMLCollection> children = cells();
     int numCells = children->length();
     if (index < -1 || index > numCells) {
         ec = INDEX_SIZE_ERR;
-        return 0;
+        return nullptr;
     }
 
     }
 
-    RefPtr<HTMLTableCellElement> cell = HTMLTableCellElement::create(tdTag, document());
+    Ref<HTMLTableCellElement> cell = HTMLTableCellElement::create(tdTag, document());
     if (index < 0 || index >= numCells)
     if (index < 0 || index >= numCells)
-        appendChild(cell, ec);
+        appendChild(cell.copyRef(), ec);
     else {
         Node* n;
         if (index < 1)
             n = firstChild();
         else
             n = children->item(index);
     else {
         Node* n;
         if (index < 1)
             n = firstChild();
         else
             n = children->item(index);
-        insertBefore(cell, n, ec);
+        insertBefore(cell.copyRef(), n, ec);
     }
     }
-    return cell;
+    return WTF::move(cell);
 }
 
 void HTMLTableRowElement::deleteCell(int index, ExceptionCode& ec)
 }
 
 void HTMLTableRowElement::deleteCell(int index, ExceptionCode& ec)
@@ -150,7 +149,7 @@ void HTMLTableRowElement::deleteCell(int index, ExceptionCode& ec)
         index = numCells-1;
     if (index >= 0 && index < numCells) {
         RefPtr<Node> cell = children->item(index);
         index = numCells-1;
     if (index >= 0 && index < numCells) {
         RefPtr<Node> cell = children->item(index);
-        HTMLElement::removeChild(cell.get(), ec);
+        HTMLElement::removeChild(*cell, ec);
     } else
         ec = INDEX_SIZE_ERR;
 }
     } else
         ec = INDEX_SIZE_ERR;
 }
index c997aec..c9df5b6 100644 (file)
@@ -26,6 +26,7 @@
 #ifndef HTMLTableRowElement_h
 #define HTMLTableRowElement_h
 
 #ifndef HTMLTableRowElement_h
 #define HTMLTableRowElement_h
 
+#include "HTMLTableCellElement.h"
 #include "HTMLTablePartElement.h"
 
 namespace WebCore {
 #include "HTMLTablePartElement.h"
 
 namespace WebCore {
@@ -41,8 +42,8 @@ public:
     int sectionRowIndex() const;
     void setSectionRowIndex(int);
 
     int sectionRowIndex() const;
     void setSectionRowIndex(int);
 
-    RefPtr<HTMLElement> insertCell(ExceptionCode& ec) { return insertCell(-1, ec); }
-    RefPtr<HTMLElement> insertCell(int index, ExceptionCode&);
+    RefPtr<HTMLTableCellElement> insertCell(ExceptionCode& ec) { return insertCell(-1, ec); }
+    RefPtr<HTMLTableCellElement> insertCell(int index, ExceptionCode&);
     void deleteCell(int index, ExceptionCode&);
 
     Ref<HTMLCollection> cells();
     void deleteCell(int index, ExceptionCode&);
 
     Ref<HTMLCollection> cells();
index 9e45316..fd02c60 100644 (file)
@@ -68,14 +68,14 @@ RefPtr<HTMLElement> HTMLTableSectionElement::insertRow(int index, ExceptionCode&
     else {
         row = HTMLTableRowElement::create(trTag, document());
         if (numRows == index || index == -1)
     else {
         row = HTMLTableRowElement::create(trTag, document());
         if (numRows == index || index == -1)
-            appendChild(row, ec);
+            appendChild(*row, ec);
         else {
             Node* n;
             if (index < 1)
                 n = firstChild();
             else
                 n = children->item(index);
         else {
             Node* n;
             if (index < 1)
                 n = firstChild();
             else
                 n = children->item(index);
-            insertBefore(row, n, ec);
+            insertBefore(*row, n, ec);
         }
     }
     return row;
         }
     }
     return row;
@@ -89,7 +89,7 @@ void HTMLTableSectionElement::deleteRow(int index, ExceptionCode& ec)
         index = numRows - 1;
     if (index >= 0 && index < numRows) {
         RefPtr<Node> row = children->item(index);
         index = numRows - 1;
     if (index >= 0 && index < numRows) {
         RefPtr<Node> row = children->item(index);
-        HTMLElement::removeChild(row.get(), ec);
+        HTMLElement::removeChild(*row, ec);
     } else
         ec = INDEX_SIZE_ERR;
 }
     } else
         ec = INDEX_SIZE_ERR;
 }
index aec3010..2e1edb2 100644 (file)
@@ -68,7 +68,7 @@ DocumentFragment* HTMLTemplateElement::content() const
     return m_content.get();
 }
 
     return m_content.get();
 }
 
-RefPtr<Node> HTMLTemplateElement::cloneNodeInternal(Document& targetDocument, CloningOperation type)
+Ref<Node> HTMLTemplateElement::cloneNodeInternal(Document& targetDocument, CloningOperation type)
 {
     RefPtr<Node> clone;
     switch (type) {
 {
     RefPtr<Node> clone;
     switch (type) {
@@ -82,8 +82,8 @@ RefPtr<Node> HTMLTemplateElement::cloneNodeInternal(Document& targetDocument, Cl
         break;
     }
     if (m_content)
         break;
     }
     if (m_content)
-        content()->cloneChildNodes(downcast<HTMLTemplateElement>(clone.get())->content());
-    return clone.release();
+        content()->cloneChildNodes(*downcast<HTMLTemplateElement>(clone.get())->content());
+    return clone.releaseNonNull();
 }
 
 void HTMLTemplateElement::didMoveToNewDocument(Document* oldDocument)
 }
 
 void HTMLTemplateElement::didMoveToNewDocument(Document* oldDocument)
index 767f2a1..d1fa864 100644 (file)
@@ -50,7 +50,7 @@ public:
 private:
     HTMLTemplateElement(const QualifiedName&, Document&);
 
 private:
     HTMLTemplateElement(const QualifiedName&, Document&);
 
-    virtual RefPtr<Node> cloneNodeInternal(Document&, CloningOperation) override;
+    virtual Ref<Node> cloneNodeInternal(Document&, CloningOperation) override;
     virtual void didMoveToNewDocument(Document* oldDocument) override;
 
     mutable RefPtr<TemplateContentDocumentFragment> m_content;
     virtual void didMoveToNewDocument(Document* oldDocument) override;
 
     mutable RefPtr<TemplateContentDocumentFragment> m_content;
index 9392911..a2de730 100644 (file)
@@ -406,9 +406,9 @@ void HTMLTextAreaElement::setDefaultValue(const String& defaultValue)
     Ref<HTMLTextAreaElement> protectFromMutationEvents(*this);
 
     // To preserve comments, remove only the text nodes, then add a single text node.
     Ref<HTMLTextAreaElement> protectFromMutationEvents(*this);
 
     // To preserve comments, remove only the text nodes, then add a single text node.
-    Vector<RefPtr<Text>> textNodes;
+    Vector<Ref<Text>> textNodes;
     for (Text* textNode = TextNodeTraversal::firstChild(*this); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
     for (Text* textNode = TextNodeTraversal::firstChild(*this); textNode; textNode = TextNodeTraversal::nextSibling(*textNode))
-        textNodes.append(textNode);
+        textNodes.append(*textNode);
 
     size_t size = textNodes.size();
     for (size_t i = 0; i < size; ++i)
 
     size_t size = textNodes.size();
     for (size_t i = 0; i < size; ++i)
@@ -523,8 +523,8 @@ void HTMLTextAreaElement::updatePlaceholderText()
     String placeholderText = strippedPlaceholder();
     if (placeholderText.isEmpty()) {
         if (m_placeholder) {
     String placeholderText = strippedPlaceholder();
     if (placeholderText.isEmpty()) {
         if (m_placeholder) {
-            userAgentShadowRoot()->removeChild(m_placeholder, ASSERT_NO_EXCEPTION);
-            m_placeholder = 0;
+            userAgentShadowRoot()->removeChild(*m_placeholder, ASSERT_NO_EXCEPTION);
+            m_placeholder = nullptr;
         }
         return;
     }
         }
         return;
     }
@@ -533,7 +533,7 @@ void HTMLTextAreaElement::updatePlaceholderText()
         m_placeholder = placeholder.get();
         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
         m_placeholder->setInlineStyleProperty(CSSPropertyDisplay, isPlaceholderVisible() ? CSSValueBlock : CSSValueNone, true);
         m_placeholder = placeholder.get();
         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
         m_placeholder->setInlineStyleProperty(CSSPropertyDisplay, isPlaceholderVisible() ? CSSValueBlock : CSSValueNone, true);
-        userAgentShadowRoot()->insertBefore(m_placeholder, innerTextElement()->nextSibling());
+        userAgentShadowRoot()->insertBefore(*m_placeholder, innerTextElement()->nextSibling());
     }
     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
 }
     }
     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
 }
index 980ea4e..0d1ab80 100644 (file)
@@ -92,7 +92,7 @@ private:
 
 class ImageDocumentElement final : public HTMLImageElement {
 public:
 
 class ImageDocumentElement final : public HTMLImageElement {
 public:
-    static RefPtr<ImageDocumentElement> create(ImageDocument&);
+    static Ref<ImageDocumentElement> create(ImageDocument&);
 
 private:
     ImageDocumentElement(ImageDocument& document)
 
 private:
     ImageDocumentElement(ImageDocument& document)
@@ -107,9 +107,9 @@ private:
     ImageDocument* m_imageDocument;
 };
 
     ImageDocument* m_imageDocument;
 };
 
-inline RefPtr<ImageDocumentElement> ImageDocumentElement::create(ImageDocument& document)
+inline Ref<ImageDocumentElement> ImageDocumentElement::create(ImageDocument& document)
 {
 {
-    return adoptRef(new ImageDocumentElement(document));
+    return adoptRef(*new ImageDocumentElement(document));
 }
 
 // --------
 }
 
 // --------
@@ -210,19 +210,19 @@ Ref<DocumentParser> ImageDocument::createParser()
 
 void ImageDocument::createDocumentStructure()
 {
 
 void ImageDocument::createDocumentStructure()
 {
-    RefPtr<Element> rootElement = Document::createElement(htmlTag, false);
-    appendChild(rootElement);
-    downcast<HTMLHtmlElement>(*rootElement).insertedByParser();
+    Ref<Element> rootElement = Document::createElement(htmlTag, false);
+    appendChild(rootElement.copyRef());
+    downcast<HTMLHtmlElement>(rootElement.get()).insertedByParser();
 
     frame()->injectUserScripts(InjectAtDocumentStart);
 
 
     frame()->injectUserScripts(InjectAtDocumentStart);
 
-    RefPtr<Element> body = Document::createElement(bodyTag, false);
+    Ref<Element> body = Document::createElement(bodyTag, false);
     body->setAttribute(styleAttr, "margin: 0px");
     if (MIMETypeRegistry::isPDFMIMEType(document().loader()->responseMIMEType()))
     body->setAttribute(styleAttr, "margin: 0px");
     if (MIMETypeRegistry::isPDFMIMEType(document().loader()->responseMIMEType()))
-        downcast<HTMLBodyElement>(*body).setInlineStyleProperty(CSSPropertyBackgroundColor, "white", CSSPrimitiveValue::CSS_IDENT);
-    rootElement->appendChild(body);
+        downcast<HTMLBodyElement>(body.get()).setInlineStyleProperty(CSSPropertyBackgroundColor, "white", CSSPrimitiveValue::CSS_IDENT);
+    rootElement->appendChild(body.copyRef());
     
     
-    RefPtr<ImageDocumentElement> imageElement = ImageDocumentElement::create(*this);
+    Ref<ImageDocumentElement> imageElement = ImageDocumentElement::create(*this);
     if (m_shouldShrinkImage)
         imageElement->setAttribute(styleAttr, "-webkit-user-select:none; display:block; margin:auto;");
     else
     if (m_shouldShrinkImage)
         imageElement->setAttribute(styleAttr, "-webkit-user-select:none; display:block; margin:auto;");
     else
@@ -230,7 +230,7 @@ void ImageDocument::createDocumentStructure()
     imageElement->setLoadManually(true);
     imageElement->setSrc(url().string());
     imageElement->cachedImage()->setResponse(loader()->response());
     imageElement->setLoadManually(true);
     imageElement->setSrc(url().string());
     imageElement->cachedImage()->setResponse(loader()->response());
-    body->appendChild(imageElement);
+    body->appendChild(imageElement.copyRef());
     
     if (m_shouldShrinkImage) {
 #if PLATFORM(IOS)
     
     if (m_shouldShrinkImage) {
 #if PLATFORM(IOS)
@@ -244,7 +244,7 @@ void ImageDocument::createDocumentStructure()
 #endif
     }
 
 #endif
     }
 
-    m_imageElement = imageElement.get();
+    m_imageElement = imageElement.ptr();
 }
 
 void ImageDocument::imageUpdated()
 }
 
 void ImageDocument::imageUpdated()
index 185aba8..d762452 100644 (file)
@@ -78,30 +78,30 @@ private:
     
 void MediaDocumentParser::createDocumentStructure()
 {
     
 void MediaDocumentParser::createDocumentStructure()
 {
-    RefPtr<Element> rootElement = document()->createElement(htmlTag, false);
-    document()->appendChild(rootElement, IGNORE_EXCEPTION);
-    document()->setCSSTarget(rootElement.get());
-    downcast<HTMLHtmlElement>(*rootElement).insertedByParser();
+    Ref<Element> rootElement = document()->createElement(htmlTag, false);
+    document()->appendChild(rootElement.copyRef(), IGNORE_EXCEPTION);
+    document()->setCSSTarget(rootElement.ptr());
+    downcast<HTMLHtmlElement>(rootElement.get()).insertedByParser();
 
     if (document()->frame())
         document()->frame()->injectUserScripts(InjectAtDocumentStart);
 
 #if PLATFORM(IOS)
 
     if (document()->frame())
         document()->frame()->injectUserScripts(InjectAtDocumentStart);
 
 #if PLATFORM(IOS)
-    RefPtr<Element> headElement = document()->createElement(headTag, false);
-    rootElement->appendChild(headElement, IGNORE_EXCEPTION);
+    Ref<Element> headElement = document()->createElement(headTag, false);
+    rootElement->appendChild(headElement.copyRef(), IGNORE_EXCEPTION);
 
 
-    RefPtr<Element> metaElement = document()->createElement(metaTag, false);
+    Ref<Element> metaElement = document()->createElement(metaTag, false);
     metaElement->setAttribute(nameAttr, "viewport");
     metaElement->setAttribute(contentAttr, "width=device-width,initial-scale=1,user-scalable=no");
     metaElement->setAttribute(nameAttr, "viewport");
     metaElement->setAttribute(contentAttr, "width=device-width,initial-scale=1,user-scalable=no");
-    headElement->appendChild(metaElement, IGNORE_EXCEPTION);
+    headElement->appendChild(WTF::move(metaElement), IGNORE_EXCEPTION);
 #endif
 
 #endif
 
-    RefPtr<Element> body = document()->createElement(bodyTag, false);
-    rootElement->appendChild(body, IGNORE_EXCEPTION);
+    Ref<Element> body = document()->createElement(bodyTag, false);
+    rootElement->appendChild(body.copyRef(), IGNORE_EXCEPTION);
 
 
-    RefPtr<Element> mediaElement = document()->createElement(videoTag, false);
+    Ref<Element> mediaElement = document()->createElement(videoTag, false);
 
 
-    m_mediaElement = downcast<HTMLVideoElement>(mediaElement.get());
+    m_mediaElement = downcast<HTMLVideoElement>(mediaElement.ptr());
     m_mediaElement->setAttribute(controlsAttr, emptyAtom);
     m_mediaElement->setAttribute(autoplayAttr, emptyAtom);
 
     m_mediaElement->setAttribute(controlsAttr, emptyAtom);
     m_mediaElement->setAttribute(autoplayAttr, emptyAtom);
 
@@ -114,15 +114,15 @@ void MediaDocumentParser::createDocumentStructure()
 #endif
     m_mediaElement->setAttribute(styleAttr, elementStyle.toString());
 
 #endif
     m_mediaElement->setAttribute(styleAttr, elementStyle.toString());
 
-    RefPtr<Element> sourceElement = document()->createElement(sourceTag, false);
-    HTMLSourceElement& source = downcast<HTMLSourceElement>(*sourceElement);
+    Ref<Element> sourceElement = document()->createElement(sourceTag, false);
+    HTMLSourceElement& source = downcast<HTMLSourceElement>(sourceElement.get());
     source.setSrc(document()->url());
 
     if (DocumentLoader* loader = document()->loader())
         source.setType(loader->responseMIMEType());
 
     source.setSrc(document()->url());
 
     if (DocumentLoader* loader = document()->loader())
         source.setType(loader->responseMIMEType());
 
-    m_mediaElement->appendChild(sourceElement, IGNORE_EXCEPTION);
-    body->appendChild(mediaElement, IGNORE_EXCEPTION);
+    m_mediaElement->appendChild(WTF::move(sourceElement), IGNORE_EXCEPTION);
+    body->appendChild(WTF::move(mediaElement), IGNORE_EXCEPTION);
 
     Frame* frame = document()->frame();
     if (!frame)
 
     Frame* frame = document()->frame();
     if (!frame)
@@ -253,7 +253,7 @@ void MediaDocument::replaceMediaElementTimerFired()
         if (documentLoader)
             embedElement.setAttribute(typeAttr, documentLoader->writer().mimeType());
 
         if (documentLoader)
             embedElement.setAttribute(typeAttr, documentLoader->writer().mimeType());
 
-        videoElement->parentNode()->replaceChild(&embedElement, videoElement, IGNORE_EXCEPTION);
+        videoElement->parentNode()->replaceChild(embedElement, *videoElement, IGNORE_EXCEPTION);
     }
 }
 
     }
 }
 
index e967709..c0a80ba 100644 (file)
@@ -67,9 +67,9 @@ private:
 
 void PluginDocumentParser::createDocumentStructure()
 {
 
 void PluginDocumentParser::createDocumentStructure()
 {
-    RefPtr<Element> rootElement = document()->createElement(htmlTag, false);
-    document()->appendChild(rootElement, IGNORE_EXCEPTION);
-    downcast<HTMLHtmlElement>(*rootElement).insertedByParser();
+    Ref<Element> rootElement = document()->createElement(htmlTag, false);
+    document()->appendChild(rootElement.copyRef(), IGNORE_EXCEPTION);
+    downcast<HTMLHtmlElement>(rootElement.get()).insertedByParser();
 
     if (document()->frame())
         document()->frame()->injectUserScripts(InjectAtDocumentStart);
 
     if (document()->frame())
         document()->frame()->injectUserScripts(InjectAtDocumentStart);
@@ -79,7 +79,7 @@ void PluginDocumentParser::createDocumentStructure()
     document()->processViewport(ASCIILiteral("user-scalable=no"), ViewportArguments::PluginDocument);
 #endif
 
     document()->processViewport(ASCIILiteral("user-scalable=no"), ViewportArguments::PluginDocument);
 #endif
 
-    RefPtr<Element> body = document()->createElement(bodyTag, false);
+    Ref<Element> body = document()->createElement(bodyTag, false);
     body->setAttribute(marginwidthAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
     body->setAttribute(marginheightAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
 #if PLATFORM(IOS)
     body->setAttribute(marginwidthAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
     body->setAttribute(marginheightAttr, AtomicString("0", AtomicString::ConstructFromLiteral));
 #if PLATFORM(IOS)
@@ -88,11 +88,11 @@ void PluginDocumentParser::createDocumentStructure()
     body->setAttribute(styleAttr, AtomicString("background-color: rgb(38,38,38)", AtomicString::ConstructFromLiteral));
 #endif
 
     body->setAttribute(styleAttr, AtomicString("background-color: rgb(38,38,38)", AtomicString::ConstructFromLiteral));
 #endif
 
-    rootElement->appendChild(body, IGNORE_EXCEPTION);
+    rootElement->appendChild(body.copyRef(), IGNORE_EXCEPTION);
         
         
-    RefPtr<Element> embedElement = document()->createElement(embedTag, false);
+    Ref<Element> embedElement = document()->createElement(embedTag, false);
         
         
-    m_embedElement = downcast<HTMLEmbedElement>(embedElement.get());
+    m_embedElement = downcast<HTMLEmbedElement>(embedElement.ptr());
     m_embedElement->setAttribute(widthAttr, "100%");
     m_embedElement->setAttribute(heightAttr, "100%");
     
     m_embedElement->setAttribute(widthAttr, "100%");
     m_embedElement->setAttribute(heightAttr, "100%");
     
@@ -106,7 +106,7 @@ void PluginDocumentParser::createDocumentStructure()
 
     downcast<PluginDocument>(*document()).setPluginElement(m_embedElement);
 
 
     downcast<PluginDocument>(*document()).setPluginElement(m_embedElement);
 
-    body->appendChild(embedElement, IGNORE_EXCEPTION);
+    body->appendChild(WTF::move(embedElement), IGNORE_EXCEPTION);
 }
 
 void PluginDocumentParser::appendBytes(DocumentWriter&, const char*, size_t)
 }
 
 void PluginDocumentParser::appendBytes(DocumentWriter&, const char*, size_t)
index b5b9e79..66a7415 100644 (file)
@@ -253,12 +253,12 @@ void RangeInputType::createShadowSubtree()
     ASSERT(element().userAgentShadowRoot());
 
     Document& document = element().document();
     ASSERT(element().userAgentShadowRoot());
 
     Document& document = element().document();
-    RefPtr<HTMLDivElement> track = HTMLDivElement::create(document);
+    Ref<HTMLDivElement> track = HTMLDivElement::create(document);
     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
     track->appendChild(SliderThumbElement::create(document), IGNORE_EXCEPTION);
     track->setPseudo(AtomicString("-webkit-slider-runnable-track", AtomicString::ConstructFromLiteral));
     track->appendChild(SliderThumbElement::create(document), IGNORE_EXCEPTION);
-    RefPtr<HTMLElement> container = SliderContainerElement::create(document);
-    container->appendChild(track.release(), IGNORE_EXCEPTION);
-    element().userAgentShadowRoot()->appendChild(container.release(), IGNORE_EXCEPTION);
+    Ref<HTMLElement> container = SliderContainerElement::create(document);
+    container->appendChild(WTF::move(track), IGNORE_EXCEPTION);
+    element().userAgentShadowRoot()->appendChild(WTF::move(container), IGNORE_EXCEPTION);
 }
 
 HTMLElement* RangeInputType::sliderTrackElement() const
 }
 
 HTMLElement* RangeInputType::sliderTrackElement() const
index de43db5..357c7a6 100644 (file)
@@ -107,14 +107,14 @@ void SearchInputType::createShadowSubtree()
     ASSERT(container);
     ASSERT(textWrapper);
 
     ASSERT(container);
     ASSERT(textWrapper);
 
-    RefPtr<SearchFieldResultsButtonElement> resultsButton = SearchFieldResultsButtonElement::create(element().document());
-    m_resultsButton = resultsButton.get();
-    updateResultButtonPseudoType(*m_resultsButton, element().maxResults());
-    container->insertBefore(m_resultsButton, textWrapper, IGNORE_EXCEPTION);
-
-    RefPtr<SearchFieldCancelButtonElement> cancelButton = SearchFieldCancelButtonElement::create(element().document());
-    m_cancelButton = cancelButton.get();
-    container->insertBefore(m_cancelButton, textWrapper->nextSibling(), IGNORE_EXCEPTION);
+    Ref<SearchFieldResultsButtonElement> resultsButton = SearchFieldResultsButtonElement::create(element().document());
+    m_resultsButton = resultsButton.ptr();
+    updateResultButtonPseudoType(resultsButton.get(), element().maxResults());
+    container->insertBefore(WTF::move(resultsButton), textWrapper, IGNORE_EXCEPTION);
+
+    Ref<SearchFieldCancelButtonElement> cancelButton = SearchFieldCancelButtonElement::create(element().document());
+    m_cancelButton = cancelButton.ptr();
+    container->insertBefore(WTF::move(cancelButton), textWrapper->nextSibling(), IGNORE_EXCEPTION);
 }
 
 HTMLElement* SearchInputType::resultsButtonElement() const
 }
 
 HTMLElement* SearchInputType::resultsButtonElement() const
index eae3db2..136f097 100644 (file)
@@ -274,7 +274,7 @@ void TextFieldInputType::createShadowSubtree()
     m_innerText = TextControlInnerTextElement::create(document);
 
     if (!createsContainer) {
     m_innerText = TextControlInnerTextElement::create(document);
 
     if (!createsContainer) {
-        element().userAgentShadowRoot()->appendChild(m_innerText, IGNORE_EXCEPTION);
+        element().userAgentShadowRoot()->appendChild(*m_innerText, IGNORE_EXCEPTION);
         updatePlaceholderText();
         return;
     }
         updatePlaceholderText();
         return;
     }
@@ -284,7 +284,7 @@ void TextFieldInputType::createShadowSubtree()
 
     if (shouldHaveSpinButton) {
         m_innerSpinButton = SpinButtonElement::create(document, *this);
 
     if (shouldHaveSpinButton) {
         m_innerSpinButton = SpinButtonElement::create(document, *this);
-        m_container->appendChild(m_innerSpinButton, IGNORE_EXCEPTION);
+        m_container->appendChild(*m_innerSpinButton, IGNORE_EXCEPTION);
     }
 
     if (shouldHaveCapsLockIndicator) {
     }
 
     if (shouldHaveCapsLockIndicator) {
@@ -294,7 +294,7 @@ void TextFieldInputType::createShadowSubtree()
         bool shouldDrawCapsLockIndicator = this->shouldDrawCapsLockIndicator();
         m_capsLockIndicator->setInlineStyleProperty(CSSPropertyDisplay, shouldDrawCapsLockIndicator ? CSSValueBlock : CSSValueNone, true);
 
         bool shouldDrawCapsLockIndicator = this->shouldDrawCapsLockIndicator();
         m_capsLockIndicator->setInlineStyleProperty(CSSPropertyDisplay, shouldDrawCapsLockIndicator ? CSSValueBlock : CSSValueNone, true);
 
-        m_container->appendChild(m_capsLockIndicator, IGNORE_EXCEPTION);
+        m_container->appendChild(*m_capsLockIndicator, IGNORE_EXCEPTION);
     }
 
     updateAutoFillButton();
     }
 
     updateAutoFillButton();
@@ -461,7 +461,7 @@ void TextFieldInputType::updatePlaceholderText()
     String placeholderText = element().strippedPlaceholder();
     if (placeholderText.isEmpty()) {
         if (m_placeholder) {
     String placeholderText = element().strippedPlaceholder();
     if (placeholderText.isEmpty()) {
         if (m_placeholder) {
-            m_placeholder->parentNode()->removeChild(m_placeholder.get(), ASSERT_NO_EXCEPTION);
+            m_placeholder->parentNode()->removeChild(*m_placeholder, ASSERT_NO_EXCEPTION);
             m_placeholder = nullptr;
         }
         return;
             m_placeholder = nullptr;
         }
         return;
@@ -470,7 +470,7 @@ void TextFieldInputType::updatePlaceholderText()
         m_placeholder = HTMLDivElement::create(element().document());
         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
         m_placeholder->setInlineStyleProperty(CSSPropertyDisplay, element().isPlaceholderVisible() ? CSSValueBlock : CSSValueNone, true);
         m_placeholder = HTMLDivElement::create(element().document());
         m_placeholder->setPseudo(AtomicString("-webkit-input-placeholder", AtomicString::ConstructFromLiteral));
         m_placeholder->setInlineStyleProperty(CSSPropertyDisplay, element().isPlaceholderVisible() ? CSSValueBlock : CSSValueNone, true);
-        element().userAgentShadowRoot()->insertBefore(m_placeholder, m_container ? m_container.get() : innerTextElement(), ASSERT_NO_EXCEPTION);
+        element().userAgentShadowRoot()->insertBefore(*m_placeholder, m_container ? m_container.get() : innerTextElement(), ASSERT_NO_EXCEPTION);
         
     }
     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
         
     }
     m_placeholder->setInnerText(placeholderText, ASSERT_NO_EXCEPTION);
@@ -600,10 +600,10 @@ void TextFieldInputType::createContainer()
     m_container->setPseudo(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
 
     m_innerBlock = TextControlInnerElement::create(element().document());
     m_container->setPseudo(AtomicString("-webkit-textfield-decoration-container", AtomicString::ConstructFromLiteral));
 
     m_innerBlock = TextControlInnerElement::create(element().document());
-    m_innerBlock->appendChild(m_innerText, IGNORE_EXCEPTION);
-    m_container->appendChild(m_innerBlock, IGNORE_EXCEPTION);
+    m_innerBlock->appendChild(*m_innerText, IGNORE_EXCEPTION);
+    m_container->appendChild(*m_innerBlock, IGNORE_EXCEPTION);
 
 
-    element().userAgentShadowRoot()->appendChild(m_container, IGNORE_EXCEPTION);
+    element().userAgentShadowRoot()->appendChild(*m_container, IGNORE_EXCEPTION);
 }
 
 void TextFieldInputType::createAutoFillButton()
 }