Add Node.treeRoot
authorrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Jan 2016 20:09:50 +0000 (20:09 +0000)
committerrniwa@webkit.org <rniwa@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 27 Jan 2016 20:09:50 +0000 (20:09 +0000)
https://bugs.webkit.org/show_bug.cgi?id=153537

Reviewed by Antti Koivisto.

Source/WebCore:

Exposed highestAncestor as Node.prototype.treeRoot, which was added to shadow DOM spec in
https://github.com/w3c/webcomponents/commit/6864a40fe4efa8a737e78512e3c85319ddc5bf8b

See also:
http://w3c.github.io/webcomponents/spec/shadow/#extensions-to-node-interface

Test: fast/shadow-dom/Node-interface-treeRoot.html

* dom/Node.idl:

LayoutTests:

Added a testharness.js test for Node.treeRoot. Also rebaselined a test.

* js/dom/dom-static-property-for-in-iteration-expected.txt: Rebaselined.
* fast/shadow-dom/Node-interface-treeRoot-expected.txt: Added.
* fast/shadow-dom/Node-interface-treeRoot.html: Added.

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

LayoutTests/ChangeLog
LayoutTests/fast/shadow-dom/Node-interface-treeRoot-expected.txt [new file with mode: 0644]
LayoutTests/fast/shadow-dom/Node-interface-treeRoot.html [new file with mode: 0644]
LayoutTests/js/dom/dom-static-property-for-in-iteration-expected.txt
Source/WebCore/ChangeLog
Source/WebCore/dom/Node.idl

index 68e6e89..fa7c2a4 100644 (file)
@@ -1,5 +1,18 @@
 2016-01-26  Ryosuke Niwa  <rniwa@webkit.org>
 
+        Add Node.treeRoot
+        https://bugs.webkit.org/show_bug.cgi?id=153537
+
+        Reviewed by Antti Koivisto.
+
+        Added a testharness.js test for Node.treeRoot. Also rebaselined a test.
+
+        * js/dom/dom-static-property-for-in-iteration-expected.txt: Rebaselined.
+        * fast/shadow-dom/Node-interface-treeRoot-expected.txt: Added.
+        * fast/shadow-dom/Node-interface-treeRoot.html: Added.
+
+2016-01-26  Ryosuke Niwa  <rniwa@webkit.org>
+
         Rename HTMLSlotElement.getDistributedNodes to getAssignedNodes
         https://bugs.webkit.org/show_bug.cgi?id=153534
 
diff --git a/LayoutTests/fast/shadow-dom/Node-interface-treeRoot-expected.txt b/LayoutTests/fast/shadow-dom/Node-interface-treeRoot-expected.txt
new file mode 100644 (file)
index 0000000..0ba4b32
--- /dev/null
@@ -0,0 +1,12 @@
+
+PASS treeRoot attribute must be defined on Node interface 
+PASS treeRoot attribute must return the context object when it does not have any parent 
+PASS treeRoot attribute must return the parent node of the context object when the context object has a single ancestor not in a document 
+PASS treeRoot attribute must return the document when a node is in document and not in a shadow tree 
+PASS treeRoot attribute must return the open shadow root of the context object when the shadow host is in a document 
+PASS treeRoot attribute must return the closed shadow root of the context object when the shadow host is in a document 
+PASS treeRoot attribute must return the root node of the context object when the context object is inside a open shadow root whose shadow host is in another open shadow root 
+PASS treeRoot attribute must return the root node of the context object when the context object is inside a closed shadow root whose shadow host is in another open shadow root 
+PASS treeRoot attribute must return the root node of the context object when the context object is inside a open shadow root whose shadow host is in another closed shadow root 
+PASS treeRoot attribute must return the root node of the context object when the context object is inside a closed shadow root whose shadow host is in another closed shadow root 
+
diff --git a/LayoutTests/fast/shadow-dom/Node-interface-treeRoot.html b/LayoutTests/fast/shadow-dom/Node-interface-treeRoot.html
new file mode 100644 (file)
index 0000000..1466561
--- /dev/null
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Shadow DOM: Extensions to Node interface</title>
+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
+<meta name="assert" content="Node interface must have treeRoot attribute">
+<link rel="help" href="http://w3c.github.io/webcomponents/spec/shadow/#extensions-to-node-interface">
+<script src="../../resources/testharness.js"></script>
+<script src="../../resources/testharnessreport.js"></script>
+<link rel='stylesheet' href='../../resources/testharness.css'>
+</head>
+<body>
+<div id="log"></div>
+<script>
+
+test(function () {
+    assert_true('treeRoot' in Node.prototype, 'treeRoot must be defined on Node.prototype');
+    assert_true('treeRoot' in document.createElement('div'), 'treeRoot must be defined on a div element');
+    assert_true('treeRoot' in document.createTextNode(''), 'assignedSlot must be defined on a text node');
+    assert_true('treeRoot' in document.createComment(''), 'assignedSlot must be defined on a comment node');
+    assert_true('treeRoot' in document.createProcessingInstruction('target', 'data'), 'assignedSlot must be defined on a processing instruction node');
+    assert_true('treeRoot' in document, 'assignedSlot must be defined on a document node');
+    assert_true('treeRoot' in document.createElement('div').attachShadow({mode: 'closed'}), 'treeRoot must be defined on a closed shadow root element');
+    assert_true('treeRoot' in document.createElement('div').attachShadow({mode: 'open'}), 'treeRoot must be defined on a open shadow root element');
+}, 'treeRoot attribute must be defined on Node interface');
+
+test(function () {
+    var element = document.createElement('div');
+    assert_equals(element.treeRoot, element, 'treeRoot on an element without a parent must return the element itself');
+
+    var text = document.createTextNode('');
+    assert_equals(text.treeRoot, text, 'treeRoot on a text node without a parent must return the text node itself');
+
+    var processingInstruction = document.createProcessingInstruction('target', 'data');
+    assert_equals(processingInstruction.treeRoot, processingInstruction, 'treeRoot on a processing instruction node without a parent must return the processing instruction node itself');
+
+    assert_equals(document.treeRoot, document, 'treeRoot on a document node must return the document itself');
+
+    var closedShadowRoot = document.createElement('div').attachShadow({mode: 'closed'});
+    assert_equals(closedShadowRoot.treeRoot, closedShadowRoot, 'treeRoot on a closed shadow root must return the shadow root itself');
+
+    var openShadowRoot = document.createElement('div').attachShadow({mode: 'open'});
+    assert_equals(openShadowRoot.treeRoot, openShadowRoot, 'treeRoot on a open shadow root must return the shadow root itself');
+}, 'treeRoot attribute must return the context object when it does not have any parent');
+
+test(function () {
+    var parent = document.createElement('div');
+
+    var element = document.createElement('div');
+    parent.appendChild(element);
+    assert_equals(element.treeRoot, parent, 'treeRoot on an element with a single ancestor must return the parent node');
+
+    var text = document.createTextNode('');
+    parent.appendChild(text);
+    assert_equals(text.treeRoot, parent, 'treeRoot on a text node with a single ancestor must return the parent node');
+
+    var processingInstruction = document.createProcessingInstruction('target', 'data');
+    parent.appendChild(processingInstruction)
+    assert_equals(processingInstruction.treeRoot, parent, 'treeRoot on a processing instruction node with a single ancestor must return the parent node');
+
+    var hostWithClosedShadowRoot = document.createElement('div');
+    parent.appendChild(hostWithClosedShadowRoot);
+    var closedShadowRoot = hostWithClosedShadowRoot.attachShadow({mode: 'closed'});
+    assert_equals(closedShadowRoot.treeRoot, closedShadowRoot, 'treeRoot on a closed shadow root with a single ancestor on its host must return the shadow root itself');
+
+    var hostWithOpenShadowRoot = document.createElement('div');
+    parent.appendChild(hostWithOpenShadowRoot);
+    var openShadowRoot = hostWithOpenShadowRoot.attachShadow({mode: 'open'});
+    assert_equals(openShadowRoot.treeRoot, openShadowRoot, 'treeRoot on a open shadow root with a single ancestor on its host must return the shadow root itself');
+}, 'treeRoot attribute must return the parent node of the context object when the context object has a single ancestor not in a document');
+
+test(function () {
+    var parent = document.createElement('div');
+    document.body.appendChild(parent);
+
+    var element = document.createElement('div');
+    parent.appendChild(element);
+    assert_equals(element.treeRoot, document, 'treeRoot on an element inside a document must return the document');
+
+    var text = document.createTextNode('');
+    parent.appendChild(text);
+    assert_equals(text.treeRoot, document, 'treeRoot on a text node inside a document must return the document');
+
+    var processingInstruction = document.createProcessingInstruction('target', 'data');
+    parent.appendChild(processingInstruction)
+    assert_equals(processingInstruction.treeRoot, document, 'treeRoot on a processing instruction node inside a document must return the document');
+}, 'treeRoot attribute must return the document when a node is in document and not in a shadow tree');
+
+function testTreeRootOnNodeInsideShadowTree(mode) {
+    test(function () {
+        var host = document.createElement('div');
+        document.body.appendChild(host);
+
+        var shadowRoot = host.attachShadow({mode: mode});
+        var parent = document.createElement('p');
+        shadowRoot.appendChild(parent);
+
+        var element = document.createElement('span');
+        parent.appendChild(element);
+        assert_equals(element.treeRoot, shadowRoot, 'treeRoot on an element inside a shadow tree must return the shadow root');
+
+        var text = document.createTextNode('');
+        parent.appendChild(text);
+        assert_equals(text.treeRoot, shadowRoot, 'treeRoot on a text node inside a shadow tree must return the shadow root');
+
+        var processingInstruction = document.createProcessingInstruction('target', 'data');
+        parent.appendChild(processingInstruction);
+        assert_equals(processingInstruction.treeRoot, shadowRoot, 'treeRoot on a processing instruction node inside a shadow tree must return the shadow root');
+    }, 'treeRoot attribute must return the ' + mode + ' shadow root of the context object when the shadow host is in a document');
+}
+
+testTreeRootOnNodeInsideShadowTree('open');
+testTreeRootOnNodeInsideShadowTree('closed');
+
+function testTreeRootOnNodeInsideNestedShadowTree(outerMode, innerMode) {
+    test(function () {
+        var outerHost = document.createElement('div');
+        document.body.appendChild(outerHost);
+        var outerShadowRoot = outerHost.attachShadow({mode: outerMode});
+
+        var innerHost = document.createElement('section');
+        outerShadowRoot.appendChild(innerHost);
+        var innerShadowRoot = innerHost.attachShadow({mode: innerMode});
+
+        var parent = document.createElement('p');
+        innerShadowRoot.appendChild(parent);
+
+        var element = document.createElement('span');
+        parent.appendChild(element);
+        assert_equals(element.treeRoot, innerShadowRoot, 'treeRoot on an element inside a shadow tree must return its root node');
+
+        var text = document.createTextNode('');
+        parent.appendChild(text);
+        assert_equals(text.treeRoot, innerShadowRoot, 'treeRoot on a text node inside a shadow tree must return its root node');
+
+        var processingInstruction = document.createProcessingInstruction('target', 'data');
+        parent.appendChild(processingInstruction);
+        assert_equals(processingInstruction.treeRoot, innerShadowRoot, 'treeRoot on a processing instruction node inside a shadow tree must return its root node');
+    }, 'treeRoot attribute must return the root node of the context object when the context object is inside a ' + innerMode
+        + ' shadow root whose shadow host is in another ' + outerMode + ' shadow root');
+}
+
+testTreeRootOnNodeInsideNestedShadowTree('open', 'open');
+testTreeRootOnNodeInsideNestedShadowTree('open', 'closed');
+testTreeRootOnNodeInsideNestedShadowTree('closed', 'open');
+testTreeRootOnNodeInsideNestedShadowTree('closed', 'closed');
+
+</script>
+</body>
+</html>
index b48c20d..c49f574 100644 (file)
@@ -86,6 +86,7 @@ PASS a["lastChild"] is [object Text]
 PASS a["previousSibling"] is [object Text]
 PASS a["nextSibling"] is [object Text]
 PASS a["ownerDocument"] is [object HTMLDocument]
+PASS a["treeRoot"] is [object HTMLDocument]
 PASS a["namespaceURI"] is http://www.w3.org/1999/xhtml
 PASS a["prefix"] is null
 PASS a["localName"] is a
index 1e46c97..d846184 100644 (file)
@@ -1,5 +1,22 @@
 2016-01-26  Ryosuke Niwa  <rniwa@webkit.org>
 
+        Add Node.treeRoot
+        https://bugs.webkit.org/show_bug.cgi?id=153537
+
+        Reviewed by Antti Koivisto.
+
+        Exposed highestAncestor as Node.prototype.treeRoot, which was added to shadow DOM spec in
+        https://github.com/w3c/webcomponents/commit/6864a40fe4efa8a737e78512e3c85319ddc5bf8b
+
+        See also:
+        http://w3c.github.io/webcomponents/spec/shadow/#extensions-to-node-interface
+
+        Test: fast/shadow-dom/Node-interface-treeRoot.html
+
+        * dom/Node.idl:
+
+2016-01-26  Ryosuke Niwa  <rniwa@webkit.org>
+
         Rename HTMLSlotElement.getDistributedNodes to getAssignedNodes
         https://bugs.webkit.org/show_bug.cgi?id=153534
 
index 9f0cd5d..caea509 100644 (file)
@@ -60,6 +60,8 @@
     readonly attribute Node             nextSibling;
     readonly attribute Document         ownerDocument;
 
+    [Conditional=SHADOW_DOM, ImplementedAs=highestAncestor] readonly attribute Node treeRoot;
+
     [ObjCLegacyUnnamedParameters, Custom, RaisesException] Node insertBefore([CustomReturn] Node newChild,
                                                             Node refChild);
     [ObjCLegacyUnnamedParameters, Custom, RaisesException] Node replaceChild(Node newChild,