Clarify a role of Shadow DOM related functions

third_party/WebKit/Source/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 205 matching lines @@
     for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot())
         root->detachLayoutTree(childrenContext);
 }
 
 void ElementShadow::setNeedsDistributionRecalc()
 {
     if (m_needsDistributionRecalc)
         return;
     m_needsDistributionRecalc = true;
     host().markAncestorsWithChildNeedsDistributionRecalc();
-    clearDistribution();
+    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
 {
+    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()
 {
     if (isV1())
         youngestShadowRoot().distributeV1();
     else
         distributeV0();
 }
 
 void ElementShadow::distributeV0()
 {
+    DCHECK(!isV1());
     HeapVector<Member<HTMLShadowElement>, 32> shadowInsertionPoints;
     DistributionPool pool(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);
                 shadowInsertionPoint = toHTMLShadowElement(point);
                 shadowInsertionPoints.append(shadowInsertionPoint);
             } else {
                 pool.distributeTo(point, this);
-                if (ElementShadow* shadow = shadowWhereNodeCanBeDistributed(*point))
+                if (ElementShadow* shadow = shadowWhereNodeCanBeDistributedForV0(*point))
                     shadow->setNeedsDistributionRecalc();
             }
         }
     }
 
     for (size_t i = shadowInsertionPoints.size(); i > 0; --i) {
         HTMLShadowElement* shadowInsertionPoint = shadowInsertionPoints[i - 1];
         ShadowRoot* root = shadowInsertionPoint->containingShadowRoot();
         DCHECK(root);
         if (root->isOldest()) {
             pool.distributeTo(shadowInsertionPoint, this);
         } 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 = shadowWhereNodeCanBeDistributed(*shadowInsertionPoint))
+        if (ElementShadow* shadow = shadowWhereNodeCanBeDistributedForV0(*shadowInsertionPoint))
             shadow->setNeedsDistributionRecalc();
     }
     InspectorInstrumentation::didPerformElementShadowDistribution(&host());
 }
 
 void ElementShadow::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()
 {
+    DCHECK(!isV1());
     if (!m_needsSelectFeatureSet)
         return m_selectFeatures;
 
     m_selectFeatures.clear();
     for (ShadowRoot* root = &oldestShadowRoot(); root; root = root->youngerShadowRoot())
         collectSelectFeatureSetFrom(*root);
     m_needsSelectFeatureSet = false;
     return m_selectFeatures;
 }
 
 void ElementShadow::collectSelectFeatureSetFrom(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 (!isHTMLContentElement(element))
             continue;
         const CSSSelectorList& list = toHTMLContentElement(element).selectorList();
         m_selectFeatures.collectFeaturesFromSelectorList(list);
     }
 }
 
 void ElementShadow::willAffectSelector()
 {
+    DCHECK(!isV1());
     for (ElementShadow* shadow = this; shadow; shadow = shadow->containingShadow()) {
         if (shadow->needsSelectFeatureSet())
             break;
         shadow->setNeedsSelectFeatureSet();
     }
     setNeedsDistributionRecalc();
 }
 
-void ElementShadow::clearDistribution()
+void ElementShadow::clearDistributionV0()
 {
+    DCHECK(!isV1());
     m_nodeToInsertionPoints.clear();
 
     for (ShadowRoot* root = &youngestShadowRoot(); root; root = root->olderShadowRoot())
         root->setShadowInsertionPointOfYoungerShadowRoot(nullptr);
 }
 
 DEFINE_TRACE(ElementShadow)
 {
     visitor->trace(m_nodeToInsertionPoints);
     visitor->trace(m_selectFeatures);
     visitor->trace(m_shadowRoot);
 }
 
 DEFINE_TRACE_WRAPPERS(ElementShadow)
 {
     visitor->traceWrappers(m_shadowRoot);
 }
 
 } // namespace blink