Only allow one shadowRoot.

sky/engine/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 441 matching lines @@
     FloatPoint absPos = renderer()->localToAbsolute();
     renderer()->absoluteRects(rects, flooredLayoutPoint(absPos));
     size_t n = rects.size();
     for (size_t i = 0; i < n; ++i)
         if (!rects[i].isEmpty())
             return true;
 
     return false;
 }
 
-#ifndef NDEBUG
-inline static ShadowRoot* oldestShadowRootFor(const Node* node)
-{
-    if (!node->isElementNode())
-        return 0;
-    if (ElementShadow* shadow = toElement(node)->shadow())
-        return shadow->oldestShadowRoot();
-    return 0;
-}
-#endif
-
 void Node::recalcDistribution()
 {
     if (isElementNode()) {
         if (ElementShadow* shadow = toElement(this)->shadow())
             shadow->distributeIfNeeded();
     }
 
     for (Node* child = firstChild(); child; child = child->nextSibling()) {
         if (child->childNeedsDistributionRecalc())
             child->recalcDistribution();
     }
 
-    for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
+    if (ShadowRoot* root = shadowRoot()) {
         if (root->childNeedsDistributionRecalc())
             root->recalcDistribution();
     }
 
     clearChildNeedsDistributionRecalc();
 }
 
 void Node::setIsLink(bool isLink)
 {
     setFlag(isLink, IsLinkFlag);
@@ skipping 30 matching lines @@
 
 } // anonymous namespace'd functions supporting traceStyleChange
 
 unsigned Node::styledSubtreeSize() const
 {
     unsigned nodeCount = 0;
 
     for (const Node* node = this; node; node = NodeTraversal::next(*node, this)) {
         if (node->isTextNode() || node->isElementNode())
             nodeCount++;
-        for (ShadowRoot* root = node->youngestShadowRoot(); root; root = root->olderShadowRoot())
+        if (ShadowRoot* root = node->shadowRoot())
             nodeCount += root->styledSubtreeSize();
     }
 
     return nodeCount;
 }
 
 void Node::traceStyleChange(StyleChangeType changeType)
 {
     static const unsigned kMinLoggedSize = 100;
     unsigned nodeCount = styledSubtreeSize();
@@ skipping 540 matching lines @@
         const Node* child1 = chain1[--index1];
         const Node* child2 = chain2[--index2];
         if (child1 != child2) {
             // If one of the children is a shadow root,
             if (child1->isShadowRoot() || child2->isShadowRoot()) {
                 if (!child2->isShadowRoot())
                     return Node::DOCUMENT_POSITION_FOLLOWING | connection;
                 if (!child1->isShadowRoot())
                     return Node::DOCUMENT_POSITION_PRECEDING | connection;
 
-                for (ShadowRoot* child = toShadowRoot(child2)->olderShadowRoot(); child; child = child->olderShadowRoot())
-                    if (child == child1)
-                        return Node::DOCUMENT_POSITION_FOLLOWING | connection;
-
                 return Node::DOCUMENT_POSITION_PRECEDING | connection;
             }
 
             if (!child2->nextSibling())
                 return DOCUMENT_POSITION_FOLLOWING | connection;
             if (!child1->nextSibling())
                 return DOCUMENT_POSITION_PRECEDING | connection;
 
             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
@@ skipping 82 matching lines @@
 {
     Vector<const Node*, 16> chain;
     const Node* node = this;
     while (node->parentOrShadowHostNode()) {
         chain.append(node);
         node = node->parentOrShadowHostNode();
     }
     for (unsigned index = chain.size(); index > 0; --index) {
         const Node* node = chain[index - 1];
         if (node->isShadowRoot()) {
-            int count = 0;
-            for (ShadowRoot* shadowRoot = toShadowRoot(node)->olderShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
-                ++count;
-            fprintf(stderr, "/#shadow-root[%d]", count);
+            fprintf(stderr, "/#shadow-root");
             continue;
         }
 
         switch (node->nodeType()) {
         case ELEMENT_NODE: {
             fprintf(stderr, "/%s", node->nodeName().utf8().data());
 
             const Element* element = toElement(node);
             const AtomicString& idattr = element->getIdAttribute();
             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
@@ skipping 29 matching lines @@
         if (node == markedNode2)
             fprintf(stderr, "%s", markedLabel2);
 
         StringBuilder indent;
         indent.append(baseIndent);
         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentOrShadowHostNode())
             indent.append('\t');
         fprintf(stderr, "%s", indent.toString().utf8().data());
         node->showNode();
         indent.append('\t');
-        if (node->isShadowRoot()) {
-            if (ShadowRoot* youngerShadowRoot = toShadowRoot(node)->youngerShadowRoot())
-                traverseTreeAndMark(indent.toString(), youngerShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
-        } else if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(node))
-            traverseTreeAndMark(indent.toString(), oldestShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
+        if (ShadowRoot* shadowRoot = node->shadowRoot())
+            traverseTreeAndMark(indent.toString(), shadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
     }
 }
 
 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2) const
 {
     const Node* rootNode;
     const Node* node = this;
     while (node->parentOrShadowHostNode())
         node = node->parentOrShadowHostNode();
     rootNode = node;
@@ skipping 15 matching lines @@
 
     strncpy(buffer, result.utf8().data(), length - 1);
 }
 
 static void showSubTreeAcrossFrame(const Node* node, const Node* markedNode, const String& indent)
 {
     if (node == markedNode)
         fputs("*", stderr);
     fputs(indent.utf8().data(), stderr);
     node->showNode();
-    if (node->isShadowRoot()) {
-        if (ShadowRoot* youngerShadowRoot = toShadowRoot(node)->youngerShadowRoot())
-            showSubTreeAcrossFrame(youngerShadowRoot, markedNode, indent + "\t");
-    } else {
-        if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(node))
-            showSubTreeAcrossFrame(oldestShadowRoot, markedNode, indent + "\t");
-    }
+    if (ShadowRoot* shadowRoot = node->shadowRoot())
+        showSubTreeAcrossFrame(shadowRoot, markedNode, indent + "\t");
     for (Node* child = node->firstChild(); child; child = child->nextSibling())
         showSubTreeAcrossFrame(child, markedNode, indent + "\t");
 }
 
 #endif
 
 // --------
 
 Element* Node::enclosingLinkEventParentOrSelf()
 {
@@ skipping 78 matching lines @@
 
 void Node::removeAllEventListeners()
 {
     EventTarget::removeAllEventListeners();
 }
 
 void Node::removeAllEventListenersRecursively()
 {
     for (Node* node = this; node; node = NodeTraversal::next(*node)) {
         node->removeAllEventListeners();
-        for (ShadowRoot* root = node->youngestShadowRoot(); root; root = root->olderShadowRoot())
+        if (ShadowRoot* root = node->shadowRoot())
             root->removeAllEventListenersRecursively();
     }
 }
 
 typedef HashMap<RawPtr<Node>, OwnPtr<EventTargetData> > EventTargetDataMap;
 
 static EventTargetDataMap& eventTargetDataMap()
 {
     DEFINE_STATIC_LOCAL(OwnPtr<EventTargetDataMap>, map, (adoptPtr(new EventTargetDataMap())));
     return *map;
@@ skipping 438 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif