Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/Editor.h

 /*
  * Copyright (C) 2006, 2007, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 41 matching lines @@
 class KillRing;
 class Pasteboard;
 class SpellChecker;
 class StylePropertySet;
 class TextEvent;
 class UndoStack;
 
 enum EditorCommandSource { CommandFromMenuOrKeyBinding, CommandFromDOM };
 enum EditorParagraphSeparator { EditorParagraphSeparatorIsDiv, EditorParagraphSeparatorIsP };
 
-class CORE_EXPORT Editor final : public NoBaseWillBeGarbageCollectedFinalized<Editor> {
-    USING_FAST_MALLOC_WILL_BE_REMOVED(Editor);
+class CORE_EXPORT Editor final : public GarbageCollectedFinalized<Editor> {
     WTF_MAKE_NONCOPYABLE(Editor);
 public:
-    static PassOwnPtrWillBeRawPtr<Editor> create(LocalFrame&);
+    static RawPtr<Editor> create(LocalFrame&);
     ~Editor();
 
     EditorClient& client() const;
 
     CompositeEditCommand* lastEditCommand() { return m_lastEditCommand.get(); }
 
     void handleKeyboardEvent(KeyboardEvent*);
     bool handleTextEvent(TextEvent*);
 
     bool canEdit() const;
@@ skipping 30 matching lines @@
     void clearLastEditCommand();
 
     bool deleteWithDirection(SelectionDirection, TextGranularity, bool killRing, bool isTypingAction);
     void deleteSelectionWithSmartDelete(bool smartDelete);
 
     void applyStyle(StylePropertySet*, EditAction = EditActionUnspecified);
     void applyParagraphStyle(StylePropertySet*, EditAction = EditActionUnspecified);
     void applyStyleToSelection(StylePropertySet*, EditAction);
     void applyParagraphStyleToSelection(StylePropertySet*, EditAction);
 
-    void appliedEditing(PassRefPtrWillBeRawPtr<CompositeEditCommand>);
-    void unappliedEditing(PassRefPtrWillBeRawPtr<EditCommandComposition>);
-    void reappliedEditing(PassRefPtrWillBeRawPtr<EditCommandComposition>);
+    void appliedEditing(RawPtr<CompositeEditCommand>);
+    void unappliedEditing(RawPtr<EditCommandComposition>);
+    void reappliedEditing(RawPtr<EditCommandComposition>);
 
     void setShouldStyleWithCSS(bool flag) { m_shouldStyleWithCSS = flag; }
     bool shouldStyleWithCSS() const { return m_shouldStyleWithCSS; }
 
     class CORE_EXPORT Command {
         STACK_ALLOCATED();
     public:
         Command();
-        Command(const EditorInternalCommand*, EditorCommandSource, PassRefPtrWillBeRawPtr<LocalFrame>);
+        Command(const EditorInternalCommand*, EditorCommandSource, RawPtr<LocalFrame>);
 
         bool execute(const String& parameter = String(), Event* triggeringEvent = nullptr) const;
         bool execute(Event* triggeringEvent) const;
 
         bool isSupported() const;
         bool isEnabled(Event* triggeringEvent = nullptr) const;
 
         TriState state(Event* triggeringEvent = nullptr) const;
         String value(Event* triggeringEvent = nullptr) const;
 
         bool isTextInsertion() const;
 
         // Returns 0 if this Command is not supported.
         int idForHistogram() const;
     private:
         LocalFrame& frame() const
         {
             ASSERT(m_frame);
             return *m_frame;
         }
 
         const EditorInternalCommand* m_command;
         EditorCommandSource m_source;
-        RefPtrWillBeMember<LocalFrame> m_frame;
+        Member<LocalFrame> m_frame;
     };
     Command createCommand(const String& commandName); // Command source is CommandFromMenuOrKeyBinding.
     Command createCommand(const String& commandName, EditorCommandSource);
 
     // |Editor::executeCommand| is implementation of |WebFrame::executeCommand|
     // rather than |Document::execCommand|.
     bool executeCommand(const String&);
     bool executeCommand(const String& commandName, const String& value);
 
     bool insertText(const String&, KeyboardEvent* triggeringEvent);
@@ skipping 25 matching lines @@
     VisibleSelection selectionForCommand(Event*);
 
     KillRing& killRing() const { return *m_killRing; }
 
     EditingBehavior behavior() const;
 
     EphemeralRange selectedRange();
 
     void addToKillRing(const EphemeralRange&);
 
-    void pasteAsFragment(PassRefPtrWillBeRawPtr<DocumentFragment>, bool smartReplace, bool matchStyle);
+    void pasteAsFragment(RawPtr<DocumentFragment>, bool smartReplace, bool matchStyle);
     void pasteAsPlainText(const String&, bool smartReplace);
 
     Element* findEventTargetFrom(const VisibleSelection&) const;
 
     bool findString(const String&, FindOptions);
 
-    PassRefPtrWillBeRawPtr<Range> findStringAndScrollToVisible(const String&, Range*, FindOptions);
-    PassRefPtrWillBeRawPtr<Range> findRangeOfString(const String& target, const EphemeralRange& referenceRange, FindOptions);
-    PassRefPtrWillBeRawPtr<Range> findRangeOfString(const String& target, const EphemeralRangeInFlatTree& referenceRange, FindOptions);
+    RawPtr<Range> findStringAndScrollToVisible(const String&, Range*, FindOptions);
+    RawPtr<Range> findRangeOfString(const String& target, const EphemeralRange& referenceRange, FindOptions);
+    RawPtr<Range> findRangeOfString(const String& target, const EphemeralRangeInFlatTree& referenceRange, FindOptions);
 
     const VisibleSelection& mark() const; // Mark, to be used as emacs uses it.
     void setMark(const VisibleSelection&);
 
     void computeAndSetTypingStyle(StylePropertySet* , EditAction = EditActionUnspecified);
 
     IntRect firstRectForRange(const EphemeralRange&) const;
     IntRect firstRectForRange(const Range*) const;
 
     void respondToChangedSelection(const VisibleSelection& oldSelection, FrameSelection::SetSelectionOptions);
 
     bool markedTextMatchesAreHighlighted() const;
     void setMarkedTextMatchesAreHighlighted(bool);
 
-    void replaceSelectionWithFragment(PassRefPtrWillBeRawPtr<DocumentFragment>, bool selectReplacement, bool smartReplace, bool matchStyle);
+    void replaceSelectionWithFragment(RawPtr<DocumentFragment>, bool selectReplacement, bool smartReplace, bool matchStyle);
     void replaceSelectionWithText(const String&, bool selectReplacement, bool smartReplace);
 
     // TODO(xiaochengh): Replace |bool| parameters by |enum|.
-    void replaceSelectionAfterDragging(PassRefPtrWillBeRawPtr<DocumentFragment>, bool smartReplace, bool plainText);
-    void moveSelectionAfterDragging(PassRefPtrWillBeRawPtr<DocumentFragment>, const Position&, bool smartInsert, bool smartDelete);
+    void replaceSelectionAfterDragging(RawPtr<DocumentFragment>, bool smartReplace, bool plainText);
+    void moveSelectionAfterDragging(RawPtr<DocumentFragment>, const Position&, bool smartInsert, bool smartDelete);
 
     EditorParagraphSeparator defaultParagraphSeparator() const { return m_defaultParagraphSeparator; }
     void setDefaultParagraphSeparator(EditorParagraphSeparator separator) { m_defaultParagraphSeparator = separator; }
 
     static void tidyUpHTMLStructure(Document&);
 
     class RevealSelectionScope {
         WTF_MAKE_NONCOPYABLE(RevealSelectionScope);
         STACK_ALLOCATED();
     public:
         explicit RevealSelectionScope(Editor*);
         ~RevealSelectionScope();
     private:
-        RawPtrWillBeMember<Editor> m_editor;
+        Member<Editor> m_editor;
     };
     friend class RevealSelectionScope;
 
     DECLARE_TRACE();
 
 private:
-    RawPtrWillBeMember<LocalFrame> m_frame;
-    RefPtrWillBeMember<CompositeEditCommand> m_lastEditCommand;
+    Member<LocalFrame> m_frame;
+    Member<CompositeEditCommand> m_lastEditCommand;
     int m_preventRevealSelection;
     bool m_shouldStartNewKillRingSequence;
     bool m_shouldStyleWithCSS;
     const OwnPtr<KillRing> m_killRing;
     VisibleSelection m_mark;
     bool m_areMarkedTextMatchesHighlighted;
     EditorParagraphSeparator m_defaultParagraphSeparator;
     bool m_overwriteModeEnabled;
 
     explicit Editor(LocalFrame&);
@@ skipping 48 matching lines @@
 
 inline bool Editor::markedTextMatchesAreHighlighted() const
 {
     return m_areMarkedTextMatchesHighlighted;
 }
 
 
 } // namespace blink
 
 #endif // Editor_h