Oilpan: move editing objects to the heap.

Source/core/dom/Position.h

 /*
  * Copyright (C) 2004, 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 33 matching lines @@
 class RenderObject;
 class Text;
 
 enum PositionMoveType {
     CodePoint,       // Move by a single code point.
     Character,       // Move to the next Unicode character break.
     BackwardDeletion // Subject to platform conventions.
 };
 
 class Position {
+    DISALLOW_ALLOCATION();
 public:
     enum AnchorType {
         PositionIsOffsetInAnchor,
         PositionIsBeforeAnchor,
         PositionIsAfterAnchor,
         PositionIsBeforeChildren,
         PositionIsAfterChildren,
     };
 
     Position()
         : m_offset(0)
         , m_anchorType(PositionIsOffsetInAnchor)
         , m_isLegacyEditingPosition(false)
     {
     }
 
     // For creating legacy editing positions: (Anchor type will be determined from editingIgnoresContent(node))
     class LegacyEditingOffset {
     public:
         int value() const { return m_offset; }
 
     private:
         explicit LegacyEditingOffset(int offset) : m_offset(offset) { }
 
-        friend Position createLegacyEditingPosition(PassRefPtr<Node>, int offset);
+        friend Position createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node>, int offset);
 
         int m_offset;
     };
-    Position(PassRefPtr<Node> anchorNode, LegacyEditingOffset);
+    Position(PassRefPtrWillBeRawPtr<Node> anchorNode, LegacyEditingOffset);
 
     // For creating before/after positions:
-    Position(PassRefPtr<Node> anchorNode, AnchorType);
+    Position(PassRefPtrWillBeRawPtr<Node> anchorNode, AnchorType);
     Position(PassRefPtrWillBeRawPtr<Text> textNode, unsigned offset);
 
     // For creating offset positions:
     // FIXME: This constructor should eventually go away. See bug 63040.
-    Position(PassRefPtr<Node> anchorNode, int offset, AnchorType);
+    Position(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset, AnchorType);
 
     AnchorType anchorType() const { return static_cast<AnchorType>(m_anchorType); }
 
     void clear() { m_anchorNode.clear(); m_offset = 0; m_anchorType = PositionIsOffsetInAnchor; m_isLegacyEditingPosition = false; }
 
     // These are always DOM compliant values.  Editing positions like [img, 0] (aka [img, before])
     // will return img->parentNode() and img->nodeIndex() from these functions.
     Node* containerNode() const; // NULL for a before/after position anchored to a node with no parent
     Text* containerText() const;
 
@@ skipping 29 matching lines @@
     Document* document() const { return m_anchorNode ? &m_anchorNode->document() : 0; }
     bool inDocument() const { return m_anchorNode && m_anchorNode->inDocument(); }
     Element* rootEditableElement() const
     {
         Node* container = containerNode();
         return container ? container->rootEditableElement() : 0;
     }
 
     // These should only be used for PositionIsOffsetInAnchor positions, unless
     // the position is a legacy editing position.
-    void moveToPosition(PassRefPtr<Node> anchorNode, int offset);
+    void moveToPosition(PassRefPtrWillBeRawPtr<Node> anchorNode, int offset);
     void moveToOffset(int offset);
 
     bool isNull() const { return !m_anchorNode; }
     bool isNotNull() const { return m_anchorNode; }
     bool isOrphan() const { return m_anchorNode && !m_anchorNode->inDocument(); }
 
     Element* element() const;
     PassRefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyle() const;
 
     // Move up or down the DOM by one position.
@@ skipping 45 matching lines @@
     static ContainerNode* findParent(const Node*);
 
     void debugPosition(const char* msg = "") const;
 
 #ifndef NDEBUG
     void formatForDebugger(char* buffer, unsigned length) const;
     void showAnchorTypeAndOffset() const;
     void showTreeForThis() const;
 #endif
 
+    void trace(Visitor*);
+
 private:
     int offsetForPositionAfterAnchor() const;
 
     int renderedOffset() const;
 
     Position previousCharacterPosition(EAffinity) const;
 
     static AnchorType anchorTypeForLegacyEditingPosition(Node* anchorNode, int offset);
 
     RefPtr<Node> m_anchorNode;

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

This should be RefPtrWillBeMember.

Ian: It'd be nice if the plugin could detects this kind of error when
non-Member/non-RawPtr is traced.

[zerny-chromium, 2014/05/26 07:51:08]

That might be a good check to have during the transition. After transition this
would be caught since it is disallowed to have Ref/Raw/Own ptrs to GC allocated
objects. I'll add it to the list.

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

Fixed.

     // m_offset can be the offset inside m_anchorNode, or if editingIgnoresContent(m_anchorNode)
     // returns true, then other places in editing will treat m_offset == 0 as "before the anchor"
     // and m_offset > 0 as "after the anchor node".  See parentAnchoredEquivalent for more info.
     int m_offset;
     unsigned m_anchorType : 3;
     bool m_isLegacyEditingPosition : 1;
 };
 
-inline Position createLegacyEditingPosition(PassRefPtr<Node> node, int offset)
+inline Position createLegacyEditingPosition(PassRefPtrWillBeRawPtr<Node> node, int offset)
 {
     return Position(node, Position::LegacyEditingOffset(offset));
 }
 
 inline bool operator==(const Position& a, const Position& b)
 {
     // FIXME: In <div><img></div> [div, 0] != [img, 0] even though most of the
     // editing code will treat them as identical.
     return a.anchorNode() == b.anchorNode() && a.deprecatedEditingOffset() == b.deprecatedEditingOffset() && a.anchorType() == b.anchorType();
 }
@@ skipping 74 matching lines @@
 
     int currentOffset = 0;
     for (Node* node = anchorNode->firstChild(); node && currentOffset < offset; node = node->nextSibling())
         currentOffset++;
 
 
     return offset < currentOffset;
 }
 
 class PositionWithAffinity {
+    DISALLOW_ALLOCATION();
 public:
     PositionWithAffinity()
         : m_affinity(DOWNSTREAM)
     {
     }
 
     PositionWithAffinity(const Position& position, EAffinity affinity = DOWNSTREAM)
         : m_position(position)
         , m_affinity(affinity)
     {
     }
 
     EAffinity affinity() const { return m_affinity; }
     const Position& position() const { return m_position; }
 
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(m_position);
+    }
+
 private:
     Position m_position;
     EAffinity m_affinity;
 };
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showTree(const WebCore::Position&);
 void showTree(const WebCore::Position*);
 #endif
 
 #endif // Position_h