Oilpan: move RenderObjects off heap.

Source/core/rendering/RenderBlockFlow.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003-2013 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ skipping 38 matching lines @@
 class LineWidth;
 class RenderMultiColumnFlowThread;
 class RenderMultiColumnSpannerPlaceholder;
 class LayoutRubyRun;
 template <class Run> class BidiRunList;
 
 class RenderBlockFlow : public RenderBlock {
 public:
     explicit RenderBlockFlow(ContainerNode*);
     virtual ~RenderBlockFlow();
-    virtual void trace(Visitor*) override;
 
     static RenderBlockFlow* createAnonymous(Document*);
 
     virtual bool isRenderBlockFlow() const override final { return true; }
 
     virtual void layoutBlock(bool relayoutChildren) override;
 
     virtual void computeOverflow(LayoutUnit oldClientAfterEdge, bool recomputeFloats = false) override;
 
     virtual void deleteLineBoxTree() override final;
@@ skipping 93 matching lines @@
     LayoutUnit startAlignedOffsetForLine(LayoutUnit position, bool shouldIndentText);
 
     void setStaticInlinePositionForChild(RenderBox&, LayoutUnit inlinePosition);
     void updateStaticInlinePositionForChild(RenderBox&, LayoutUnit logicalTop);
 
     static bool shouldSkipCreatingRunsForObject(RenderObject* obj)
     {
         return obj->isFloating() || (obj->isOutOfFlowPositioned() && !obj->style()->isOriginalDisplayInlineType() && !obj->container()->isRenderInline());
     }
 
-    RenderMultiColumnFlowThread* multiColumnFlowThread() const { return m_rareData ? m_rareData->m_multiColumnFlowThread.get() : 0; }
+    RenderMultiColumnFlowThread* multiColumnFlowThread() const { return m_rareData ? m_rareData->m_multiColumnFlowThread : 0; }
     void resetMultiColumnFlowThread()
     {
         if (m_rareData)
             m_rareData->m_multiColumnFlowThread = nullptr;
     }
 
     void addOverflowFromInlineChildren();
 
     // FIXME: This should be const to avoid a const_cast, but can modify child dirty bits and RenderCombineText
     void computeInlinePreferredLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth);
@@ skipping 194 matching lines @@
 
     private:
         LayoutUnit m_positiveMarginBefore;
         LayoutUnit m_negativeMarginBefore;
         LayoutUnit m_positiveMarginAfter;
         LayoutUnit m_negativeMarginAfter;
     };
     MarginValues marginValuesForChild(RenderBox& child) const;
 
     // Allocated only when some of these fields have non-default values
-    struct RenderBlockFlowRareData : public NoBaseWillBeGarbageCollected<RenderBlockFlowRareData> {
-        WTF_MAKE_NONCOPYABLE(RenderBlockFlowRareData); WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
+    struct RenderBlockFlowRareData {
+        WTF_MAKE_NONCOPYABLE(RenderBlockFlowRareData); WTF_MAKE_FAST_ALLOCATED;
     public:
         RenderBlockFlowRareData(const RenderBlockFlow* block)
             : m_margins(positiveMarginBeforeDefault(block), negativeMarginBeforeDefault(block), positiveMarginAfterDefault(block), negativeMarginAfterDefault(block))
             , m_paginationStrut(0)
             , m_multiColumnFlowThread(nullptr)
             , m_lineBreakToAvoidWidow(-1)
             , m_didBreakAtLineToAvoidWidow(false)
             , m_discardMarginBefore(false)
             , m_discardMarginAfter(false)
         {
         }
-        void trace(Visitor*);
 
         static LayoutUnit positiveMarginBeforeDefault(const RenderBlockFlow* block)
         {
             return std::max<LayoutUnit>(block->marginBefore(), 0);
         }
         static LayoutUnit negativeMarginBeforeDefault(const RenderBlockFlow* block)
         {
             return std::max<LayoutUnit>(-block->marginBefore(), 0);
         }
         static LayoutUnit positiveMarginAfterDefault(const RenderBlockFlow* block)
         {
             return std::max<LayoutUnit>(block->marginAfter(), 0);
         }
         static LayoutUnit negativeMarginAfterDefault(const RenderBlockFlow* block)
         {
             return std::max<LayoutUnit>(-block->marginAfter(), 0);
         }
 
         MarginValues m_margins;
         LayoutUnit m_paginationStrut;
 
-        RawPtrWillBeMember<RenderMultiColumnFlowThread> m_multiColumnFlowThread;
+        RenderMultiColumnFlowThread* m_multiColumnFlowThread;
 
         int m_lineBreakToAvoidWidow;
         bool m_didBreakAtLineToAvoidWidow : 1;
         bool m_discardMarginBefore : 1;
         bool m_discardMarginAfter : 1;
     };
     LayoutUnit marginOffsetForSelfCollapsingBlock();
 
     FloatingObjects* floatingObjects() { return m_floatingObjects.get(); }
 
@@ skipping 55 matching lines @@
     static bool s_canPropagateFloatIntoSibling;
 
     RenderBlockFlowRareData& ensureRareData();
 
     LayoutUnit m_paintInvalidationLogicalTop;
     LayoutUnit m_paintInvalidationLogicalBottom;
 
     virtual bool isSelfCollapsingBlock() const override;
 
 protected:
-    OwnPtrWillBeMember<RenderBlockFlowRareData> m_rareData;
+    OwnPtr<RenderBlockFlowRareData> m_rareData;
     OwnPtr<FloatingObjects> m_floatingObjects;
 
     friend class BreakingContext; // FIXME: It uses insertFloatingObject and positionNewFloatOnLine, if we move those out from the private scope/add a helper to LineBreaker, we can remove this friend
     friend class MarginInfo;
     friend class LineBreaker;
     friend class LineWidth; // needs to know FloatingObject
 
 // FIXME-BLOCKFLOW: These methods have implementations in
 // RenderBlockLineLayout. They should be moved to the proper header once the
 // line layout code is separated from RenderBlock and RenderBlockFlow.
@@ skipping 29 matching lines @@
 
 // END METHODS DEFINED IN RenderBlockLineLayout
 
 };
 
 DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderBlockFlow, isRenderBlockFlow());
 
 } // namespace blink
 
 #endif // RenderBlockFlow_h