Only allow one shadowRoot.

sky/engine/core/dom/shadow/ElementShadow.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.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 111 matching lines @@
             m_nodes[i]->lazyReattachIfAttached();
     }
 }
 
 PassOwnPtr<ElementShadow> ElementShadow::create()
 {
     return adoptPtr(new ElementShadow());
 }
 
 ElementShadow::ElementShadow()
-    : m_needsDistributionRecalc(false)
+    : m_shadowRoot(0)
+    , m_needsDistributionRecalc(false)
     , m_needsSelectFeatureSet(false)
 {
 }
 
 ElementShadow::~ElementShadow()
 {
-#if !ENABLE(OILPAN)
-    removeDetachedShadowRoots();
-#endif
+    removeDetachedShadowRoot();
 }
 
 ShadowRoot& ElementShadow::addShadowRoot(Element& shadowHost)
 {
     EventDispatchForbiddenScope assertNoEventDispatch;
     ScriptForbiddenScope forbidScript;
 
-    for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot())
-        root->lazyReattachIfAttached();
+    ASSERT(!m_shadowRoot);
 
     RefPtr<ShadowRoot> shadowRoot = ShadowRoot::create(shadowHost.document());
     shadowRoot->setParentOrShadowHostNode(&shadowHost);
     shadowRoot->setParentTreeScope(shadowHost.treeScope());
-    m_shadowRoots.push(shadowRoot.get());
+    m_shadowRoot = shadowRoot.get();
+
     setNeedsDistributionRecalc();
 
     shadowRoot->insertedInto(&shadowHost);
 
     return *shadowRoot;
 }
 
-#if !ENABLE(OILPAN)
-void ElementShadow::removeDetachedShadowRoots()
+void ElementShadow::removeDetachedShadowRoot()
 {
     // Dont protect this ref count.
     Element* shadowHost = host();
     ASSERT(shadowHost);
 
-    while (RefPtr<ShadowRoot> oldRoot = m_shadowRoots.head()) {
+    if (RefPtr<ShadowRoot> oldRoot = m_shadowRoot) {
         shadowHost->document().removeFocusedElementOfSubtree(oldRoot.get());
-        m_shadowRoots.removeHead();
+        m_shadowRoot = 0;
         oldRoot->setParentOrShadowHostNode(0);
         oldRoot->setParentTreeScope(shadowHost->document());
-        oldRoot->setPrev(0);
-        oldRoot->setNext(0);
     }
 }
-#endif
 
 void ElementShadow::attach(const Node::AttachContext& context)
 {
+    if (!m_shadowRoot)
+        return;
+
+    ASSERT(m_shadowRoot->needsAttach());
+
     Node::AttachContext childrenContext(context);
     childrenContext.resolvedStyle = 0;
-
-    for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
-        if (root->needsAttach())
-            root->attach(childrenContext);
-    }
+    m_shadowRoot->attach(childrenContext);
 }
 
 void ElementShadow::detach(const Node::AttachContext& context)
 {
+    if (!m_shadowRoot)
+        return;
+
     Node::AttachContext childrenContext(context);
     childrenContext.resolvedStyle = 0;
-
-    for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot())
-        root->detach(childrenContext);
+    m_shadowRoot->detach(childrenContext);
 }
 
 void ElementShadow::setNeedsDistributionRecalc()
 {
     if (m_needsDistributionRecalc)
         return;
     m_needsDistributionRecalc = true;
     host()->markAncestorsWithChildNeedsDistributionRecalc();
     clearDistribution();
 }
 
 bool ElementShadow::hasSameStyles(const ElementShadow* other) const
 {
-    ShadowRoot* root = youngestShadowRoot();
-    ShadowRoot* otherRoot = other->youngestShadowRoot();
-    while (root || otherRoot) {
+    ShadowRoot* root = m_shadowRoot;
+    ShadowRoot* otherRoot = other->shadowRoot();
+    if (root || otherRoot) {
         if (!root || !otherRoot)
             return false;
 
         StyleSheetList* list = root->styleSheets();
         StyleSheetList* otherList = otherRoot->styleSheets();
 
         if (list->length() != otherList->length())
             return false;
 
         for (size_t i = 0; i < list->length(); i++) {
             if (toCSSStyleSheet(list->item(i))->contents() != toCSSStyleSheet(otherList->item(i))->contents())
                 return false;
         }
-        root = root->olderShadowRoot();
-        otherRoot = otherRoot->olderShadowRoot();
     }
 
     return true;
 }
 
 const InsertionPoint* ElementShadow::finalDestinationInsertionPointFor(const Node* key) const
 {
     ASSERT(key && !key->document().childNeedsDistributionRecalc());
     NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(key);
     return it == m_nodeToInsertionPoints.end() ? 0: it->value.last().get();
 }
 
 const DestinationInsertionPoints* ElementShadow::destinationInsertionPointsFor(const Node* key) const
 {
     ASSERT(key && !key->document().childNeedsDistributionRecalc());
     NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(key);
     return it == m_nodeToInsertionPoints.end() ? 0: &it->value;
 }
 
 void ElementShadow::distribute()
 {
     host()->setNeedsStyleRecalc(SubtreeStyleChange);
     DistributionPool pool(*host());
 
-    for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
+    if (ShadowRoot* root = shadowRoot()) {
         const Vector<RefPtr<InsertionPoint> >& insertionPoints = root->descendantInsertionPoints();
         for (size_t i = 0; i < insertionPoints.size(); ++i) {
             InsertionPoint* point = insertionPoints[i].get();
             if (!point->isActive())
                 continue;
             pool.distributeTo(point, this);
             if (ElementShadow* shadow = shadowWhereNodeCanBeDistributed(*point))
                 shadow->setNeedsDistributionRecalc();
         }
     }
 }
 
 void ElementShadow::didDistributeNode(const Node* node, InsertionPoint* insertionPoint)
 {
     NodeToDestinationInsertionPoints::AddResult result = m_nodeToInsertionPoints.add(node, DestinationInsertionPoints());
     result.storedValue->value.append(insertionPoint);
 }
 
 const SelectRuleFeatureSet& ElementShadow::ensureSelectFeatureSet()
 {
     if (!m_needsSelectFeatureSet)
         return m_selectFeatures;
 
     m_selectFeatures.clear();
-    for (ShadowRoot* root = oldestShadowRoot(); root; root = root->youngerShadowRoot())
+    if (ShadowRoot* root = shadowRoot())
         collectSelectFeatureSetFrom(*root);
     m_needsSelectFeatureSet = false;
     return m_selectFeatures;
 }
 
 void ElementShadow::collectSelectFeatureSetFrom(ShadowRoot& root)
 {
     if (!root.containsShadowRoots() && !root.containsContentElements())
         return;
 
@@ skipping 19 matching lines @@
     }
     setNeedsDistributionRecalc();
 }
 
 void ElementShadow::clearDistribution()
 {
     m_nodeToInsertionPoints.clear();
 }
 
 } // namespace