Only allow one shadowRoot.

sky/engine/core/dom/shadow/ComposedTreeWalker.cpp

 
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 26 matching lines @@
 {
     if (node && node->isElementNode())
         return toElement(node)->shadow();
     return 0;
 }
 
 Node* ComposedTreeWalker::traverseChild(const Node* node, TraversalDirection direction) const
 {
     ASSERT(node);
     ElementShadow* shadow = shadowFor(node);
-    return shadow ? traverseLightChildren(shadow->youngestShadowRoot(), direction)
+    return shadow ? traverseLightChildren(shadow->shadowRoot(), direction)
             : traverseLightChildren(node, direction);
 }
 
 Node* ComposedTreeWalker::traverseLightChildren(const Node* node, TraversalDirection direction)
 {
     ASSERT(node);
     return traverseSiblings(direction == TraversalDirectionForward ? node->firstChild() : node->lastChild(), direction);
 }
 
 Node* ComposedTreeWalker::traverseSiblings(const Node* node, TraversalDirection direction)
@@ skipping 40 matching lines @@
     if (Node* found = traverseDistributedNodes(direction == TraversalDirectionForward ? insertionPoint->nextTo(node) : insertionPoint->previousTo(node), insertionPoint, direction))
         return found;
     return traverseSiblingOrBackToInsertionPoint(insertionPoint, direction);
 }
 
 Node* ComposedTreeWalker::traverseSiblingInCurrentTree(const Node* node, TraversalDirection direction)
 {
     ASSERT(node);
     if (Node* found = traverseSiblings(direction == TraversalDirectionForward ? node->nextSibling() : node->previousSibling(), direction))
         return found;
-    if (Node* next = traverseBackToYoungerShadowRoot(node, direction))
-        return next;
     return 0;
 }
 
-Node* ComposedTreeWalker::traverseBackToYoungerShadowRoot(const Node* node, TraversalDirection direction)
-{
-    // FIXME(sky): Remove this.
-    return 0;
-}
-
 // FIXME: Use an iterative algorithm so that it can be inlined.
 // https://bugs.webkit.org/show_bug.cgi?id=90415
 Node* ComposedTreeWalker::traverseParent(const Node* node, ParentTraversalDetails* details) const
 {
     if (shadowWhereNodeCanBeDistributed(*node)) {
         if (const InsertionPoint* insertionPoint = resolveReprojection(node)) {
             if (details)
                 details->didTraverseInsertionPoint(insertionPoint);
             // The node is distributed. But the distribution was stopped at this insertion point.
             if (shadowWhereNodeCanBeDistributed(*insertionPoint))
                 return 0;
             return traverseParentOrHost(insertionPoint);
         }
         return 0;
     }
     return traverseParentOrHost(node);
 }
 
 inline Node* ComposedTreeWalker::traverseParentOrHost(const Node* node) const
 {
     Node* parent = node->parentNode();
     if (!parent)
         return 0;
     if (!parent->isShadowRoot())
         return parent;
     ShadowRoot* shadowRoot = toShadowRoot(parent);
-    if (!shadowRoot->isYoungest())
-        return 0;
     return shadowRoot->host();
 }
 
 } // namespace