Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/dom/Range.h

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * License as published by the Free Software Foundation; either
@@ skipping 32 matching lines @@
 class Document;
 class DocumentFragment;
 class ExceptionState;
 class FloatQuad;
 class Node;
 class NodeWithIndex;
 class Text;
 
 class CORE_EXPORT Range final
 #ifndef NDEBUG
-    : public RefCountedWillBeGarbageCollectedFinalized<Range>
+    : public GarbageCollectedFinalized<Range>
 #else
-    : public RefCountedWillBeGarbageCollected<Range>
+    : public GarbageCollected<Range>
 #endif
     , public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
 public:
-    static PassRefPtrWillBeRawPtr<Range> create(Document&);
-    static PassRefPtrWillBeRawPtr<Range> create(Document&, Node* startContainer, int startOffset, Node* endContainer, int endOffset);
-    static PassRefPtrWillBeRawPtr<Range> create(Document&, const Position&, const Position&);
-    static PassRefPtrWillBeRawPtr<Range> createAdjustedToTreeScope(const TreeScope&, const Position&);
+    static RawPtr<Range> create(Document&);
+    static RawPtr<Range> create(Document&, Node* startContainer, int startOffset, Node* endContainer, int endOffset);
+    static RawPtr<Range> create(Document&, const Position&, const Position&);
+    static RawPtr<Range> createAdjustedToTreeScope(const TreeScope&, const Position&);
 #if !ENABLE(OILPAN) || !defined(NDEBUG)
     ~Range();
 #endif
     void dispose();
 
     Document& ownerDocument() const { ASSERT(m_ownerDocument); return *m_ownerDocument.get(); }
     Node* startContainer() const { return m_start.container(); }
     int startOffset() const { return m_start.offset(); }
     Node* endContainer() const { return m_end.container(); }
     int endOffset() const { return m_end.offset(); }
 
     bool collapsed() const { return m_start == m_end; }
     bool inDocument() const;
 
     Node* commonAncestorContainer() const;
     static Node* commonAncestorContainer(const Node* containerA, const Node* containerB);
-    void setStart(PassRefPtrWillBeRawPtr<Node> container, int offset, ExceptionState& = ASSERT_NO_EXCEPTION);
-    void setEnd(PassRefPtrWillBeRawPtr<Node> container, int offset, ExceptionState& = ASSERT_NO_EXCEPTION);
+    void setStart(RawPtr<Node> container, int offset, ExceptionState& = ASSERT_NO_EXCEPTION);
+    void setEnd(RawPtr<Node> container, int offset, ExceptionState& = ASSERT_NO_EXCEPTION);
     void collapse(bool toStart);
     bool isNodeFullyContained(Node&) const;
     bool isPointInRange(Node* refNode, int offset, ExceptionState&) const;
     short comparePoint(Node* refNode, int offset, ExceptionState&) const;
     enum CompareResults { NODE_BEFORE, NODE_AFTER, NODE_BEFORE_AND_AFTER, NODE_INSIDE };
     enum CompareHow { START_TO_START, START_TO_END, END_TO_END, END_TO_START };
     short compareBoundaryPoints(unsigned how, const Range* sourceRange, ExceptionState&) const;
     static short compareBoundaryPoints(Node* containerA, int offsetA, Node* containerB, int offsetB, ExceptionState&);
     static short compareBoundaryPoints(const RangeBoundaryPoint& boundaryA, const RangeBoundaryPoint& boundaryB, ExceptionState&);
     bool boundaryPointsValid() const;
     bool intersectsNode(Node* refNode, ExceptionState&);
     static bool intersectsNode(Node* refNode, const Position& start, const Position& end, ExceptionState&);
     void deleteContents(ExceptionState&);
-    PassRefPtrWillBeRawPtr<DocumentFragment> extractContents(ExceptionState&);
-    PassRefPtrWillBeRawPtr<DocumentFragment> cloneContents(ExceptionState&);
-    void insertNode(PassRefPtrWillBeRawPtr<Node>, ExceptionState&);
+    RawPtr<DocumentFragment> extractContents(ExceptionState&);
+    RawPtr<DocumentFragment> cloneContents(ExceptionState&);
+    void insertNode(RawPtr<Node>, ExceptionState&);
     String toString() const;
 
     String text() const;
 
-    PassRefPtrWillBeRawPtr<DocumentFragment> createContextualFragment(const String& html, ExceptionState&);
+    RawPtr<DocumentFragment> createContextualFragment(const String& html, ExceptionState&);
 
     void detach();
-    PassRefPtrWillBeRawPtr<Range> cloneRange() const;
+    RawPtr<Range> cloneRange() const;
 
     void setStartAfter(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
     void setEndBefore(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
     void setEndAfter(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
     void selectNode(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
     void selectNodeContents(Node*, ExceptionState&);
     static bool selectNodeContents(Node*, Position&, Position&);
-    void surroundContents(PassRefPtrWillBeRawPtr<Node>, ExceptionState&);
+    void surroundContents(RawPtr<Node>, ExceptionState&);
     void setStartBefore(Node*, ExceptionState& = ASSERT_NO_EXCEPTION);
 
     const Position startPosition() const { return m_start.toPosition(); }
     const Position endPosition() const { return m_end.toPosition(); }
     void setStart(const Position&, ExceptionState& = ASSERT_NO_EXCEPTION);
     void setEnd(const Position&, ExceptionState& = ASSERT_NO_EXCEPTION);
 
     Node* firstNode() const;
     Node* pastLastNode() const;
 
@@ skipping 36 matching lines @@
     explicit Range(Document&);
     Range(Document&, Node* startContainer, int startOffset, Node* endContainer, int endOffset);
 
     void setDocument(Document&);
 
     Node* checkNodeWOffset(Node*, int offset, ExceptionState&) const;
     void checkNodeBA(Node*, ExceptionState&) const;
     void checkExtractPrecondition(ExceptionState&);
 
     enum ActionType { DELETE_CONTENTS, EXTRACT_CONTENTS, CLONE_CONTENTS };
-    PassRefPtrWillBeRawPtr<DocumentFragment> processContents(ActionType, ExceptionState&);
-    static PassRefPtrWillBeRawPtr<Node> processContentsBetweenOffsets(ActionType, PassRefPtrWillBeRawPtr<DocumentFragment>, Node*, unsigned startOffset, unsigned endOffset, ExceptionState&);
-    static void processNodes(ActionType, WillBeHeapVector<RefPtrWillBeMember<Node>>&, PassRefPtrWillBeRawPtr<Node> oldContainer, PassRefPtrWillBeRawPtr<Node> newContainer, ExceptionState&);
+    RawPtr<DocumentFragment> processContents(ActionType, ExceptionState&);
+    static RawPtr<Node> processContentsBetweenOffsets(ActionType, RawPtr<DocumentFragment>, Node*, unsigned startOffset, unsigned endOffset, ExceptionState&);
+    static void processNodes(ActionType, HeapVector<Member<Node>>&, RawPtr<Node> oldContainer, RawPtr<Node> newContainer, ExceptionState&);
     enum ContentsProcessDirection { ProcessContentsForward, ProcessContentsBackward };
-    static PassRefPtrWillBeRawPtr<Node> processAncestorsAndTheirSiblings(ActionType, Node* container, ContentsProcessDirection, PassRefPtrWillBeRawPtr<Node> clonedContainer, Node* commonRoot, ExceptionState&);
+    static RawPtr<Node> processAncestorsAndTheirSiblings(ActionType, Node* container, ContentsProcessDirection, RawPtr<Node> clonedContainer, Node* commonRoot, ExceptionState&);
 
-    RefPtrWillBeMember<Document> m_ownerDocument; // Cannot be null.
+    Member<Document> m_ownerDocument; // Cannot be null.
     RangeBoundaryPoint m_start;
     RangeBoundaryPoint m_end;
 };
 
 CORE_EXPORT bool areRangesEqual(const Range*, const Range*);
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const blink::Range*);
 #endif
 
 #endif // Range_h