Refactor ElementShadow by separating v0 related features as ElementShadowV0

third_party/WebKit/Source/core/dom/shadow/ElementShadowV0.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
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "core/dom/shadow/ElementShadowV0.h"
+
+#include "core/dom/ElementTraversal.h"
+#include "core/dom/shadow/DistributedNodes.h"
 #include "core/dom/shadow/ElementShadow.h"
-
-#include "core/css/StyleSheetList.h"
-#include "core/dom/ElementTraversal.h"
-#include "core/dom/NodeTraversal.h"
-#include "core/dom/StyleChangeReason.h"
-#include "core/dom/shadow/DistributedNodes.h"
-#include "core/frame/Deprecation.h"
 #include "core/html/HTMLContentElement.h"
 #include "core/html/HTMLShadowElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
-#include "platform/EventDispatchForbiddenScope.h"
-#include "platform/ScriptForbiddenScope.h"
 
 namespace blink {
 
 class DistributionPool final {
     STACK_ALLOCATED();
 public:
     explicit DistributionPool(const ContainerNode&);
     void clear();
     ~DistributionPool();
-    void distributeTo(InsertionPoint*, ElementShadow*);
+    void distributeTo(InsertionPoint*, ElementShadowV0*);
     void populateChildren(const ContainerNode&);
 
 private:
     void detachNonDistributedNodes();
     HeapVector<Member<Node>, 32> m_nodes;
     Vector<bool, 32> m_distributed;
 };
 
 inline DistributionPool::DistributionPool(const ContainerNode& parent)
 {
@@ skipping 20 matching lines @@
             for (size_t i = 0; i < insertionPoint->distributedNodesSize(); ++i)
                 m_nodes.append(insertionPoint->distributedNodeAt(i));
         } else {
             m_nodes.append(child);
         }
     }
     m_distributed.resize(m_nodes.size());
     m_distributed.fill(false);
 }
 
-void DistributionPool::distributeTo(InsertionPoint* insertionPoint, ElementShadow* elementShadow)
+void DistributionPool::distributeTo(InsertionPoint* insertionPoint, ElementShadowV0* elementShadow)
 {
     DistributedNodes distributedNodes;
 
     for (size_t i = 0; i < m_nodes.size(); ++i) {
         if (m_distributed[i])
             continue;
 
         if (isHTMLContentElement(*insertionPoint) && !toHTMLContentElement(insertionPoint)->canSelectNode(m_nodes, i))
             continue;
 
@@ skipping 21 matching lines @@
 inline void DistributionPool::detachNonDistributedNodes()
 {
     for (size_t i = 0; i < m_nodes.size(); ++i) {
         if (m_distributed[i])
             continue;
         if (m_nodes[i]->layoutObject())
             m_nodes[i]->lazyReattachIfAttached();
     }
 }
 
-ElementShadow* ElementShadow::create()
+ElementShadowV0* ElementShadowV0::create(ElementShadow& elementShadow)
 {
-    return new ElementShadow();
+    return new ElementShadowV0(elementShadow);
 }
 
-ElementShadow::ElementShadow()
-    : m_needsDistributionRecalc(false)
+ElementShadowV0::ElementShadowV0(ElementShadow& elementShadow)
+    : m_elementShadow(&elementShadow)
     , m_needsSelectFeatureSet(false)
 {
 }
 
-ElementShadow::~ElementShadow()
+ElementShadowV0::~ElementShadowV0()
 {
 }
 
-ShadowRoot& ElementShadow::youngestShadowRoot() const
+ShadowRoot& ElementShadowV0::youngestShadowRoot() const
 {
-    ShadowRoot* current = m_shadowRoot;
-    DCHECK(current);
-    while (current->youngerShadowRoot())
-        current = current->youngerShadowRoot();
-    return *current;
+    return m_elementShadow->youngestShadowRoot();
 }
 
-ShadowRoot& ElementShadow::addShadowRoot(Element& shadowHost, ShadowRootType type)
+ShadowRoot& ElementShadowV0::oldestShadowRoot() const
 {
-    EventDispatchForbiddenScope assertNoEventDispatch;
-    ScriptForbiddenScope forbidScript;
-
-    if (type == ShadowRootType::V0 && m_shadowRoot) {
-        DCHECK_EQ(m_shadowRoot->type(), ShadowRootType::V0);
-        Deprecation::countDeprecation(shadowHost.document(), UseCounter::ElementCreateShadowRootMultiple);
-    }
-
-    if (m_shadowRoot) {
-        // TODO(hayato): Is the order, from the youngest to the oldest, important?
-        for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot())
-            root->lazyReattachIfAttached();
-    }
-
-    ShadowRoot* shadowRoot = ShadowRoot::create(shadowHost.document(), type);
-    shadowRoot->setParentOrShadowHostNode(&shadowHost);
-    shadowRoot->setParentTreeScope(shadowHost.treeScope());
-    appendShadowRoot(*shadowRoot);
-    setNeedsDistributionRecalc();
-
-    shadowRoot->insertedInto(&shadowHost);
-    shadowHost.setChildNeedsStyleRecalc();
-    shadowHost.setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Shadow));
-
-    InspectorInstrumentation::didPushShadowRoot(&shadowHost, shadowRoot);
-
-    return *shadowRoot;
+    return m_elementShadow->oldestShadowRoot();
 }
 
-void ElementShadow::appendShadowRoot(ShadowRoot& shadowRoot)
+const InsertionPoint* ElementShadowV0::finalDestinationInsertionPointFor(const Node* key) const
 {
-    if (!m_shadowRoot) {
-        m_shadowRoot = &shadowRoot;
-        return;
-    }
-    ShadowRoot& youngest = youngestShadowRoot();
-    DCHECK(shadowRoot.type() == ShadowRootType::V0);
-    DCHECK(youngest.type() == ShadowRootType::V0);
-    youngest.setYoungerShadowRoot(shadowRoot);
-    shadowRoot.setOlderShadowRoot(youngest);
-}
-
-void ElementShadow::attach(const Node::AttachContext& context)
-{
-    Node::AttachContext childrenContext(context);
-    childrenContext.resolvedStyle = 0;
-
-    for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot()) {
-        if (root->needsAttach())
-            root->attachLayoutTree(childrenContext);
-    }
-}
-
-void ElementShadow::detach(const Node::AttachContext& context)
-{
-    Node::AttachContext childrenContext(context);
-    childrenContext.resolvedStyle = 0;
-
-    for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot())
-        root->detachLayoutTree(childrenContext);
-}
-
-void ElementShadow::setNeedsDistributionRecalc()
-{
-    if (m_needsDistributionRecalc)
-        return;
-    m_needsDistributionRecalc = true;
-    host().markAncestorsWithChildNeedsDistributionRecalc();
-    if (!isV1())
-        clearDistributionV0();
-}
-
-bool ElementShadow::hasSameStyles(const ElementShadow* other) const
-{
-    ShadowRoot* root = &youngestShadowRoot();
-    ShadowRoot* otherRoot = &other->youngestShadowRoot();
-    while (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
-{
-    DCHECK(!isV1());
     DCHECK(key);
     DCHECK(!key->needsDistributionRecalc());
     NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(key);
     return it == m_nodeToInsertionPoints.end() ? nullptr : it->value->last();
 }
 
-const DestinationInsertionPoints* ElementShadow::destinationInsertionPointsFor(const Node* key) const
+const DestinationInsertionPoints* ElementShadowV0::destinationInsertionPointsFor(const Node* key) const
 {
-    DCHECK(!isV1());
     DCHECK(key);
     DCHECK(!key->needsDistributionRecalc());
     NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(key);
     return it == m_nodeToInsertionPoints.end() ? nullptr : it->value;
 }
 
-void ElementShadow::distribute()
+void ElementShadowV0::distribute()
 {
-    if (isV1())
-        youngestShadowRoot().distributeV1();
-    else
-        distributeV0();
-}
-
-void ElementShadow::distributeV0()
-{
-    DCHECK(!isV1());
     HeapVector<Member<HTMLShadowElement>, 32> shadowInsertionPoints;
-    DistributionPool pool(host());
+    DistributionPool pool(m_elementShadow->host());
 
     for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         HTMLShadowElement* shadowInsertionPoint = 0;
         const HeapVector<Member<InsertionPoint>>& insertionPoints = root->descendantInsertionPoints();
         for (size_t i = 0; i < insertionPoints.size(); ++i) {
             InsertionPoint* point = insertionPoints[i];
             if (!point->isActive())
                 continue;
             if (isHTMLShadowElement(*point)) {
                 DCHECK(!shadowInsertionPoint);
@@ skipping 16 matching lines @@
         } else if (root->olderShadowRoot()->type() == root->type()) {
             // Only allow reprojecting older shadow roots between the same type to
             // disallow reprojecting UA elements into author shadows.
             DistributionPool olderShadowRootPool(*root->olderShadowRoot());
             olderShadowRootPool.distributeTo(shadowInsertionPoint, this);
             root->olderShadowRoot()->setShadowInsertionPointOfYoungerShadowRoot(shadowInsertionPoint);
         }
         if (ElementShadow* shadow = shadowWhereNodeCanBeDistributedForV0(*shadowInsertionPoint))
             shadow->setNeedsDistributionRecalc();
     }
-    InspectorInstrumentation::didPerformElementShadowDistribution(&host());
+    InspectorInstrumentation::didPerformElementShadowDistribution(const_cast<Element*>(&m_elementShadow->host()));
 }
 
-void ElementShadow::didDistributeNode(const Node* node, InsertionPoint* insertionPoint)
+void ElementShadowV0::didDistributeNode(const Node* node, InsertionPoint* insertionPoint)
 {
-    DCHECK(!isV1());
     NodeToDestinationInsertionPoints::AddResult result = m_nodeToInsertionPoints.add(node, nullptr);
     if (result.isNewEntry)
         result.storedValue->value = new DestinationInsertionPoints;
     result.storedValue->value->append(insertionPoint);
 }
 
-const SelectRuleFeatureSet& ElementShadow::ensureSelectFeatureSet()
+const SelectRuleFeatureSet& ElementShadowV0::ensureSelectFeatureSet()
 {
-    DCHECK(!isV1());
     if (!m_needsSelectFeatureSet)
         return m_selectFeatures;
 
     m_selectFeatures.clear();
-    for (ShadowRoot* root = &oldestShadowRoot(); root; root = root->youngerShadowRoot())
+    for (const ShadowRoot* root = &oldestShadowRoot(); root; root = root->youngerShadowRoot())
         collectSelectFeatureSetFrom(*root);
     m_needsSelectFeatureSet = false;
     return m_selectFeatures;
 }
 
-void ElementShadow::collectSelectFeatureSetFrom(ShadowRoot& root)
+void ElementShadowV0::collectSelectFeatureSetFrom(const ShadowRoot& root)
 {
-    DCHECK(!isV1());
     if (!root.containsShadowRoots() && !root.containsContentElements())
         return;
 
     for (Element& element : ElementTraversal::descendantsOf(root)) {
-        if (ElementShadow* shadow = element.shadow())
-            m_selectFeatures.add(shadow->ensureSelectFeatureSet());
+        if (ElementShadow* shadow = element.shadow()) {
+            if (!shadow->isV1())
+                m_selectFeatures.add(shadow->v0().ensureSelectFeatureSet());
+        }
         if (!isHTMLContentElement(element))
             continue;
         const CSSSelectorList& list = toHTMLContentElement(element).selectorList();
         m_selectFeatures.collectFeaturesFromSelectorList(list);
     }
 }
 
-void ElementShadow::willAffectSelector()
+void ElementShadowV0::willAffectSelector()
 {
-    DCHECK(!isV1());
-    for (ElementShadow* shadow = this; shadow; shadow = shadow->containingShadow()) {
-        if (shadow->needsSelectFeatureSet())
+    for (ElementShadow* shadow = m_elementShadow; shadow; shadow = shadow->containingShadow()) {
+        if (shadow->isV1() || shadow->v0().needsSelectFeatureSet())
             break;
-        shadow->setNeedsSelectFeatureSet();
+        shadow->v0().setNeedsSelectFeatureSet();
     }
-    setNeedsDistributionRecalc();
+    m_elementShadow->setNeedsDistributionRecalc();
 }
 
-void ElementShadow::clearDistributionV0()
+void ElementShadowV0::clearDistribution()
 {
-    DCHECK(!isV1());
     m_nodeToInsertionPoints.clear();
 
-    for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot())
+    for (ShadowRoot* root = &m_elementShadow->youngestShadowRoot(); root; root = root->olderShadowRoot())
         root->setShadowInsertionPointOfYoungerShadowRoot(nullptr);
 }
 
-DEFINE_TRACE(ElementShadow)
+DEFINE_TRACE(ElementShadowV0)
 {
+    visitor->trace(m_elementShadow);
     visitor->trace(m_nodeToInsertionPoints);
     visitor->trace(m_selectFeatures);
-    visitor->trace(m_shadowRoot);
 }
 
-DEFINE_TRACE_WRAPPERS(ElementShadow)
+DEFINE_TRACE_WRAPPERS(ElementShadowV0)
 {
-    visitor->traceWrappers(m_shadowRoot);
 }
 
 } // namespace blink