Rename ComposedTree to FlatTree

third_party/WebKit/LayoutTests/fast/dom/shadow/resources/shadow-dom.js

 function createShadowRoot()
 {
     var children = Array.prototype.slice.call(arguments);
     if ((children[0] instanceof Object) && !(children[0] instanceof Node))
         return attachShadow.apply(null, children);
     return {'isShadowRoot': true,
             'children': children};
 }
 
 // TODO(kochi): This is not pure attachShadow wrapper, but also handles createShadowRoot()
@@ skipping 238 matching lines @@
 {
     for (var i = 0; i + 1 < elements.length; ++i)
         shouldNavigateFocus(elements[i], elements[i + 1], 'backward');
 }
 
 function dumpComposedShadowTree(node, indent)
 {
     indent = indent || "";
     var output = indent + dumpNode(node) + "\n";
     var child;
-    for (child = internals.firstChildInComposedTree(node); child; child = internals.nextSiblingInComposedTree(child))
+    for (child = internals.firstChildInFlatTree(node); child; child = internals.nextSiblingInFlatTree(child))
          output += dumpComposedShadowTree(child, indent + "\t");
     return output;
 }
 
-function lastNodeInComposedTree(root)
+function lastNodeInFlatTree(root)
 {
     var lastNode = root;
-    while (internals.lastChildInComposedTree(lastNode))
-        lastNode = internals.lastChildInComposedTree(lastNode);
+    while (internals.lastChildInFlatTree(lastNode))
+        lastNode = internals.lastChildInFlatTree(lastNode);
     return lastNode;
 }
 
 function showComposedShadowTreeByTraversingInForward(root)
 {
     var node = root;
-    var last = lastNodeInComposedTree(root);
+    var last = lastNodeInFlatTree(root);
     while (node) {
         debug(dumpNode(node));
         if (node == last)
             break;
-        node = internals.nextInComposedTree(node);
+        node = internals.nextInFlatTree(node);
     }
 }
 
 function showComposedShadowTreeByTraversingInBackward(root)
 {
-    var node = lastNodeInComposedTree(root);
+    var node = lastNodeInFlatTree(root);
     while (node) {
         debug(dumpNode(node));
         if (node == root)
             break;
-        node = internals.previousInComposedTree(node);
+        node = internals.previousInFlatTree(node);
     }
 }
 
 function showComposedShadowTree(node)
 {
     debug('Composed Shadow Tree:');
     debug(dumpComposedShadowTree(node));
 
     debug('Traverse in forward.');
     showComposedShadowTreeByTraversingInForward(node);
 
     debug('Traverse in backward.');
     showComposedShadowTreeByTraversingInBackward(node);
 
     debug('');
 }
 
 function showNextNode(node)
 {
-    var next = internals.nextInComposedTree(node);
+    var next = internals.nextInFlatTree(node);
     debug('Next node of [' + dumpNode(node) + '] is [' + dumpNode(next) + ']');
 }
 
 function backgroundColorOf(selector)
 {
     return window.getComputedStyle(getNodeInTreeOfTrees(selector)).backgroundColor;
 }
 
 function backgroundColorShouldBe(selector, expected)
 {
@@ skipping 32 matching lines @@
                 return node;
         }
 
         return null;
     };
 
     if (!window.internals)
         return null;
     return iter(root, id);
 }