Oilpan: make NodeTraversal iterators trace their references.

Source/core/dom/NodeTraversal.h

 /*
  * 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, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 84 matching lines @@
     template <class NodeType>
     static Node* traverseNextTemplate(NodeType&);
     template <class NodeType>
     static Node* traverseNextTemplate(NodeType&, const Node* stayWithin);
     template <class NodeType>
     static Node* childAtTemplate(NodeType&, unsigned);
 };
 
 template <class Iterator>
 class TraversalRange {
+    STACK_ALLOCATED();
 public:
     using StartNodeType = typename Iterator::StartNodeType;
     explicit TraversalRange(const StartNodeType* start) : m_start(start) { }
     Iterator begin() { return Iterator(m_start); }
     Iterator end() { return Iterator::end(); }
 private:
-    const StartNodeType* m_start;
+    RawPtrWillBeMember<const StartNodeType> m_start;
 };
 
 template <class TraversalNext>
 class TraversalIteratorBase {
+    STACK_ALLOCATED();
 public:
     using NodeType = typename TraversalNext::TraversalNodeType;
     NodeType& operator*() { return *m_current; }
     bool operator!=(const TraversalIteratorBase& rval) const { return m_current != rval.m_current ; }
 protected:
-    explicit TraversalIteratorBase(NodeType* current) : m_current(current) { };
-    NodeType* m_current;
+    explicit TraversalIteratorBase(NodeType* current) : m_current(current) { }
+
+    RawPtrWillBeMember<NodeType> m_current;
 };
 
 template <class TraversalNext>
 class TraversalChildrenIterator : public TraversalIteratorBase<TraversalNext> {
+    STACK_ALLOCATED();
 public:
     using StartNodeType = Node;
     using TraversalIteratorBase<TraversalNext>::m_current;
-    explicit TraversalChildrenIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)) { };
-    void operator++() { m_current = TraversalNext::nextSibling(*m_current); };
-    static TraversalChildrenIterator end() { return TraversalChildrenIterator(); };
+    explicit TraversalChildrenIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)) { }
+    void operator++() { m_current = TraversalNext::nextSibling(*m_current); }
+    static TraversalChildrenIterator end() { return TraversalChildrenIterator(); }
 private:
-    TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr) { };
+    TraversalChildrenIterator() : TraversalIteratorBase<TraversalNext>(nullptr) { }
 };
 
 template <class TraversalNext>
 class TraversalNextIterator : public TraversalIteratorBase<TraversalNext> {
+    STACK_ALLOCATED();
 public:
     using StartNodeType = typename TraversalNext::TraversalNodeType;
     using TraversalIteratorBase<TraversalNext>::m_current;
-    explicit TraversalNextIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(const_cast<StartNodeType*>(start)) { };
+    explicit TraversalNextIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(const_cast<StartNodeType*>(start)) { }
     void operator++() { m_current = TraversalNext::next(*m_current); }
-    static TraversalNextIterator end() { return TraversalNextIterator(nullptr); };
+    static TraversalNextIterator end() { return TraversalNextIterator(nullptr); }
 };
 
 template <class TraversalNext>
 class TraversalDescendantIterator : public TraversalIteratorBase<TraversalNext> {
+    STACK_ALLOCATED();
 public:
     using StartNodeType = Node;
     using TraversalIteratorBase<TraversalNext>::m_current;
-    explicit TraversalDescendantIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)), m_root(start) { };
+    explicit TraversalDescendantIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(TraversalNext::firstWithin(*start)), m_root(start) { }
     void operator++() { m_current = TraversalNext::next(*m_current, m_root); }
-    static TraversalDescendantIterator end() { return TraversalDescendantIterator(); };
+    static TraversalDescendantIterator end() { return TraversalDescendantIterator(); }
 private:
-    TraversalDescendantIterator() : TraversalIteratorBase<TraversalNext>(nullptr), m_root(nullptr) { };
-    const Node* m_root;
+    TraversalDescendantIterator() : TraversalIteratorBase<TraversalNext>(nullptr), m_root(nullptr) { }
+    RawPtrWillBeMember<const Node> m_root;
 };
 
 template <class TraversalNext>
 class TraversalInclusiveDescendantIterator : public TraversalIteratorBase<TraversalNext> {
+    STACK_ALLOCATED();
 public:
     using StartNodeType = typename TraversalNext::TraversalNodeType;
     using NodeType = typename TraversalNext::TraversalNodeType;
     using TraversalIteratorBase<TraversalNext>::m_current;
-    explicit TraversalInclusiveDescendantIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(const_cast<NodeType*>(start)), m_root(start) { };
+    explicit TraversalInclusiveDescendantIterator(const StartNodeType* start) : TraversalIteratorBase<TraversalNext>(const_cast<NodeType*>(start)), m_root(start) { }
     void operator++() { m_current = TraversalNext::next(*m_current, m_root); }
-    static TraversalInclusiveDescendantIterator end() { return TraversalInclusiveDescendantIterator(nullptr); };
+    static TraversalInclusiveDescendantIterator end() { return TraversalInclusiveDescendantIterator(nullptr); }
 private:
-    const StartNodeType* m_root;
+    RawPtrWillBeMember<const StartNodeType> m_root;
 };
 
 inline TraversalRange<TraversalChildrenIterator<NodeTraversal>> NodeTraversal::childrenOf(const Node& parent)
 {
     return TraversalRange<TraversalChildrenIterator<NodeTraversal>>(&parent);
 }
 
 inline TraversalRange<TraversalDescendantIterator<NodeTraversal>> NodeTraversal::descendantsOf(const Node& root)
 {
     return TraversalRange<TraversalDescendantIterator<NodeTraversal>>(&root);
@@ skipping 65 matching lines @@
 {
     Node* child = parent.firstChild();
     while (child && index--)
         child = child->nextSibling();
     return child;
 }
 
 } // namespace blink
 
 #endif