Oilpan: Move DOMEditor to the heap

Source/core/inspector/DOMEditor.h

Index: Source/core/inspector/DOMEditor.h
diff --git a/Source/core/inspector/DOMEditor.h b/Source/core/inspector/DOMEditor.h
index b0be0cf7d1934b408b173d91130eef0b4d17138c..e9b683baa0ee1f6ab2558178bdd046520452a4d9 100644
--- a/Source/core/inspector/DOMEditor.h
+++ b/Source/core/inspector/DOMEditor.h
@@ -31,6 +31,7 @@
 #ifndef DOMEditor_h
 #define DOMEditor_h
 
+#include "platform/heap/Handle.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
@@ -43,11 +44,13 @@ class Text;
 
 typedef String ErrorString;
 
-class DOMEditor {
-    WTF_MAKE_NONCOPYABLE(DOMEditor); WTF_MAKE_FAST_ALLOCATED;
+class DOMEditor FINAL : public NoBaseWillBeGarbageCollected<DOMEditor> {

[pfeldman, 2014/05/22 14:47:21]

What is the motivation of this change? DOMEditor is a simple non-refcounted
class with clear lifetime.

[haraken, 2014/05/22 20:19:31]

- InspectorHistory is moved to the heap.
- So if we keep DOMEditor off-heap, we need to use a
Persistent<InspectorHistory> for DOMEditor::m_history.
- However, we don't want to increase the number of persistent handles, it would
be better to move DOMEditor to the heap at the same time and use
Member<DOMEditor> for DOMEditor::m_history.

[pfeldman, 2014/05/22 20:43:25]

Why moving history to heap? Because some actions point to soon-to-be heap
objects?

I am a bit concerned with conversion of simple non-hierarchical data structures
with clear lifetime such as DOMEditor into the Oilpan heap. It makes it hard to
follow the ownership and track the new object lifetimes.

So we need to draw the line somewhere and I am not sure I know what the
guidelines / criteria for that is. Or do we want to move as much as possible
into heap? Would LocalFrame stay a regular object?

[haraken, 2014/05/22 21:21:57]

- We're currently moving the Node hierarchy to the heap.
- Because the Action hierarchy has a bunch of RefPtrs to the Node, we want to
move the Action hierarchy to the heap.
- Because InspectorHistory has a vector of Actions, we want to move
InspectorHistory to the heap.

If we don't move them to the heap at the same time, we need to use persistent
handles, which we want to avoid as much as possible.
In the end, we're planning to move:

- almost all RefCounted objects
- objects that have references to the RefCounted objects (Otherwise we need to
use persistent handles)
- strings and collections

to the heap.

The reason why we want to avoid persistent handles is that (1) persistent
handles are heavy in terms of both performance and memory and that (2)
persistent handles can cause leaks.

For example:

class A {
  Persistent<B> m_b;
};

class B : public GarbageCollectedFinalized<B> {
  OwnPtr<A> m_a;
};

will cause a cycle, so we need to move A to the heap at the same time:

class A : public GarbageCollected<A> {
  Member<B> m_b;
};

class B : public GarbageCollected<B> {
  Member<A> m_a;
};

+    WTF_MAKE_NONCOPYABLE(DOMEditor);
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
     explicit DOMEditor(InspectorHistory*);
-    ~DOMEditor();
+
+    void trace(Visitor*);
 
     bool insertBefore(Node* parentNode, PassRefPtr<Node>, Node* anchorNode, ExceptionState&);
     bool removeChild(Node* parentNode, Node*, ExceptionState&);
@@ -76,7 +79,7 @@ private:
     class ReplaceChildNodeAction;
     class SetNodeValueAction;
 
-    InspectorHistory* m_history;
+    RawPtrWillBeMember<InspectorHistory> m_history;
 };