Oilpan: move editing objects to the heap.

Source/core/editing/EditCommand.h

 /*
  * Copyright (C) 2005, 2006, 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 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef EditCommand_h
 #define EditCommand_h
 
 #include "core/editing/EditAction.h"
 #include "core/editing/VisibleSelection.h"
+#include "platform/heap/Handle.h"
 
 #ifndef NDEBUG
 #include "wtf/HashSet.h"
 #endif
 
 namespace WebCore {
 
 class CompositeEditCommand;
 class Document;
 class Element;
 
-class EditCommand : public RefCounted<EditCommand> {
+class EditCommand : public RefCountedWillBeGarbageCollectedFinalized<EditCommand> {
 public:
     virtual ~EditCommand();
 
     void setParent(CompositeEditCommand*);
 
     virtual EditAction editingAction() const;
 
     const VisibleSelection& startingSelection() const { return m_startingSelection; }
     const VisibleSelection& endingSelection() const { return m_endingSelection; }
 
     virtual bool isSimpleEditCommand() const { return false; }
     virtual bool isCompositeEditCommand() const { return false; }
     bool isTopLevelCommand() const { return !m_parent; }
 
     virtual void doApply() = 0;
 
+    virtual void trace(Visitor*);
+
 protected:
     explicit EditCommand(Document&);
     EditCommand(Document*, const VisibleSelection&, const VisibleSelection&);
 
     Document& document() const { return *m_document.get(); }
     CompositeEditCommand* parent() const { return m_parent; }
     void setStartingSelection(const VisibleSelection&);
     void setStartingSelection(const VisiblePosition&);
     void setEndingSelection(const VisibleSelection&);
     void setEndingSelection(const VisiblePosition&);
 
 private:
-    RefPtr<Document> m_document;
+    RefPtrWillBeMember<Document> m_document;
     VisibleSelection m_startingSelection;
     VisibleSelection m_endingSelection;
     CompositeEditCommand* m_parent;

[haraken, 2014/05/26 02:36:12]

Shouldn't this be a Member, since CompositeEditCommand is now on the heap?

[sof, 2014/05/28 08:31:35]

Yes, now a Member. afaict, the command holding this parent object reference is
always stored in the command sequence on the parent itself, so it seems safe to
keep it raw pointer. But Member is preferable.

 };
 
 enum ShouldAssumeContentIsAlwaysEditable {
     AssumeContentIsAlwaysEditable,
     DoNotAssumeContentIsAlwaysEditable,
 };
 
 class SimpleEditCommand : public EditCommand {

[haraken, 2014/05/26 02:36:12]

Just to confirm: You don't need to define SimpleEditCommand::trace(), because
SimpleEditCommand doesn't have any members, and SimpleEditCommand::trace() is
redirected to EditCommand::trace(). Right?

(Ian was discussing this programming rule before, and I think your CL is
following Ian's conclusion.)

[sof, 2014/05/28 08:31:35]

That's the pattern I've tried to follow in this directory -- don't define
trace()s that merely redirect up the inheritance chain.

 public:
     virtual void doUnapply() = 0;
     virtual void doReapply(); // calls doApply()
 
 protected:
     explicit SimpleEditCommand(Document& document) : EditCommand(document) { }
 
 private:
     virtual bool isSimpleEditCommand() const OVERRIDE FINAL { return true; }
 };
 
 DEFINE_TYPE_CASTS(SimpleEditCommand, EditCommand, command, command->isSimpleEditCommand(), command.isSimpleEditCommand());
 
 } // namespace WebCore
 
 #endif // EditCommand_h