Oilpan: Remove most WillBe types from the code base

third_party/WebKit/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 106 matching lines @@
 
 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:
-    RawPtrWillBeMember<const StartNodeType> m_start;
+    Member<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) { }
 
-    RawPtrWillBeMember<NodeType> m_current;
+    Member<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); }
@@ skipping 17 matching lines @@
 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) { }
     void operator++() { m_current = TraversalNext::next(*m_current, m_root); }
     static TraversalDescendantIterator end() { return TraversalDescendantIterator(); }
 private:
     TraversalDescendantIterator() : TraversalIteratorBase<TraversalNext>(nullptr), m_root(nullptr) { }
-    RawPtrWillBeMember<const Node> m_root;
+    Member<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) { }
     void operator++() { m_current = TraversalNext::next(*m_current, m_root); }
     static TraversalInclusiveDescendantIterator end() { return TraversalInclusiveDescendantIterator(nullptr); }
 private:
-    RawPtrWillBeMember<const StartNodeType> m_root;
+    Member<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