Oilpan: add transition types to shadow DOM supporting objects.

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 20 matching lines @@
 #include "core/css/StyleSheetList.h"
 #include "core/dom/ContainerNodeAlgorithms.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/shadow/ContentDistribution.h"
 #include "core/html/HTMLContentElement.h"
 #include "core/html/HTMLShadowElement.h"
 
 namespace WebCore {
 
-class DistributionPool {
+class DistributionPool FINAL {
+    STACK_ALLOCATED();
 public:
     explicit DistributionPool(const ContainerNode&);
     void clear();
     ~DistributionPool();
     void distributeTo(InsertionPoint*, ElementShadow*);
     void populateChildren(const ContainerNode&);
 
 private:
     void detachNonDistributedNodes();
-    Vector<Node*, 32> m_nodes;
+    WillBeHeapVector<RawPtrWillBeMember<Node>, 32> m_nodes;
     Vector<bool, 32> m_distributed;
 };
 
 inline DistributionPool::DistributionPool(const ContainerNode& parent)
 {
     populateChildren(parent);
 }
 
 inline void DistributionPool::clear()
 {
@@ skipping 170 matching lines @@
         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);
+    NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(const_cast<Node*>(key));

[haraken, 2014/05/12 13:38:35]

Remove const_cast.

[sof, 2014/05/12 21:57:19]

It was added for a reason. i.e., you run into resolution trouble without it, not
being able to convert a (const Node*) into a (Node*) when trying to convert the
incoming const pointer to the needed RawPtrWillBeMember<Node>. Trying to address
that by adding more RawPtr<> or Member<> constructors over const pointers is a
road to ruin.

If you instead use "const RawPtrWillBeMember<Node>" as the key type, that const
type cannot be handled by DefaultHash<> nor HashTraits<> readily.

This is the smallest I change I could come up with that worked. If you insist, I
can look into this some more.

[haraken, 2014/05/13 05:49:50]

Probably I'm misunderstanding, but won't the following work?

- Make m_nodeToInsertionPoint WillBeHeapHashMap<RawPtrWillBeMember<const Node>,
DestinationInsertionPoints>.

- Don't use const_cast here.

- Add RawPtr<> and Member<> constructors that does the conversion from const T*
to RawPtr<const T*> and Member<const T*>.

     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);
+    NodeToDestinationInsertionPoints::const_iterator it = m_nodeToInsertionPoints.find(const_cast<Node*>(key));
     return it == m_nodeToInsertionPoints.end() ? 0: &it->value;
 }
 
 void ElementShadow::distribute()
 {
     host()->setNeedsStyleRecalc(SubtreeStyleChange);
     Vector<HTMLShadowElement*, 32> shadowInsertionPoints;
     DistributionPool pool(*host());
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot()) {
         HTMLShadowElement* shadowInsertionPoint = 0;
-        const Vector<RefPtr<InsertionPoint> >& insertionPoints = root->descendantInsertionPoints();
+        const WillBeHeapVector<RefPtrWillBeMember<InsertionPoint> >& insertionPoints = root->descendantInsertionPoints();
         for (size_t i = 0; i < insertionPoints.size(); ++i) {
             InsertionPoint* point = insertionPoints[i].get();
             if (!point->isActive())
                 continue;
             if (isHTMLShadowElement(*point)) {
                 ASSERT(!shadowInsertionPoint);
                 shadowInsertionPoint = toHTMLShadowElement(point);
                 shadowInsertionPoints.append(shadowInsertionPoint);
             } else {
                 pool.distributeTo(point, this);
@@ skipping 16 matching lines @@
             olderShadowRootPool.distributeTo(shadowInsertionPoint, this);
             root->olderShadowRoot()->setShadowInsertionPointOfYoungerShadowRoot(shadowInsertionPoint);
         }
         if (ElementShadow* shadow = shadowWhereNodeCanBeDistributed(*shadowInsertionPoint))
             shadow->setNeedsDistributionRecalc();
     }
 }
 
 void ElementShadow::didDistributeNode(const Node* node, InsertionPoint* insertionPoint)
 {
-    NodeToDestinationInsertionPoints::AddResult result = m_nodeToInsertionPoints.add(node, DestinationInsertionPoints());
+    NodeToDestinationInsertionPoints::AddResult result = m_nodeToInsertionPoints.add(const_cast<Node*>(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())
@@ skipping 39 matching lines @@
 void ElementShadow::clearDistribution()
 {
     m_nodeToInsertionPoints.clear();
 
     for (ShadowRoot* root = youngestShadowRoot(); root; root = root->olderShadowRoot())
         root->setShadowInsertionPointOfYoungerShadowRoot(nullptr);
 }
 
 void ElementShadow::trace(Visitor* visitor)
 {
+    visitor->trace(m_nodeToInsertionPoints);
     // Shadow roots are linked with previous and next pointers which are traced.
     // It is therefore enough to trace one of the shadow roots here and the
     // rest will be traced from there.
     visitor->trace(m_shadowRoots.head());
 }
 
 } // namespace