Move the Widget hierarchy to the Oilpan heap.

Source/core/frame/FrameView.h

 /*
    Copyright (C) 1997 Martin Jones (mjones@kde.org)
              (C) 1998 Waldo Bastian (bastian@kde.org)
              (C) 1998, 1999 Torben Weis (weis@kde.org)
              (C) 1999 Lars Knoll (knoll@kde.org)
              (C) 1999 Antti Koivisto (koivisto@kde.org)
    Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
@@ skipping 45 matching lines @@
 class RenderBox;
 class RenderEmbeddedObject;
 class RenderObject;
 class RenderPart;
 class RenderScrollbarPart;
 class RenderView;
 struct CompositedSelectionBound;
 
 typedef unsigned long long DOMTimeStamp;
 
-// FIXME: Oilpan: move Widget (and thereby FrameView) to the heap.
 class FrameView final : public Widget, public ScrollableArea {
 public:
     friend class RenderView;
     friend class Internals;
 
-    static PassRefPtr<FrameView> create(LocalFrame*);
-    static PassRefPtr<FrameView> create(LocalFrame*, const IntSize& initialSize);
+    static PassRefPtrWillBeRawPtr<FrameView> create(LocalFrame*);
+    static PassRefPtrWillBeRawPtr<FrameView> create(LocalFrame*, const IntSize& initialSize);
 
     virtual ~FrameView();
 
     virtual void invalidateRect(const IntRect&) override;
     virtual void setFrameRect(const IntRect&) override;
 
     LocalFrame& frame() const
     {
         ASSERT(m_frame);
         return *m_frame;
     }
 
     Page* page() const;
 
     RenderView* renderView() const;
 
     void setCanHaveScrollbars(bool);
 
-    PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
+    PassRefPtrWillBeRawPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
 
     void setContentsSize(const IntSize&);
     IntPoint clampOffsetAtScale(const IntPoint& offset, float scale) const;
 
     void layout(bool allowSubtree = true);
     bool didFirstLayout() const;
     void scheduleRelayout();
     void scheduleRelayoutOfSubtree(RenderObject*);
     bool layoutPending() const;
     bool isInPerformLayout() const;
@@ skipping 119 matching lines @@
 
     void updateLayoutAndStyleForPainting();
     void updateLayoutAndStyleIfNeededRecursive();
 
     void invalidateTreeIfNeededRecursive();
 
     void incrementVisuallyNonEmptyCharacterCount(unsigned);
     void incrementVisuallyNonEmptyPixelCount(const IntSize&);
     void setIsVisuallyNonEmpty() { m_isVisuallyNonEmpty = true; }
     void enableAutoSizeMode(const IntSize& minSize, const IntSize& maxSize);
-    void disableAutoSizeMode() { m_autoSizeInfo.clear(); }
+    void disableAutoSizeMode() { disposeAutoSizeInfo(); }
 
     void forceLayout(bool allowSubtree = false);
     void forceLayoutForPagination(const FloatSize& pageSize, const FloatSize& originalPageSize, float maximumShrinkFactor);
 
     bool scrollToFragment(const KURL&);
     bool scrollToAnchor(const String&);
     void maintainScrollPositionAtAnchor(Node*);
     void scrollElementToRect(Element*, const IntRect&);
     void scrollContentsIfNeededRecursive();
 
@@ skipping 102 matching lines @@
     void scrollbarStyleChangedInternal();
     void notifyPageThatContentAreaWillPaintInternal() const;
 
     // The window that hosts the FrameView. The FrameView will communicate scrolls and repaints to the
     // host window in the window's coordinate space.
     HostWindow* hostWindow() const;
 
     // Returns a clip rect in host window coordinates. Used to clip the blit on a scroll.
     IntRect windowClipRect(IncludeScrollbarsInRect = ExcludeScrollbars) const;
 
+    typedef WillBeHeapHashSet<RefPtrWillBeMember<Widget> > ChildrenWidgetSet;
+
     // Functions for child manipulation and inspection.
-    const HashSet<RefPtr<Widget> >* children() const { return &m_children; }
-    void addChild(PassRefPtr<Widget>);
+    const ChildrenWidgetSet* children() const { return &m_children; }
+    void addChild(PassRefPtrWillBeRawPtr<Widget>);
     void removeChildInternal(Widget*);
 
     // If the scroll view does not use a native widget, then it will have cross-platform Scrollbars. These functions
     // can be used to obtain those scrollbars.
     virtual Scrollbar* horizontalScrollbar() const override { return m_horizontalScrollbar.get(); }
     virtual Scrollbar* verticalScrollbar() const override { return m_verticalScrollbar.get(); }
 
     void positionScrollbarLayers();
 
     // Functions for setting and retrieving the scrolling mode in each axis (horizontal/vertical). The mode has values of
@@ skipping 17 matching lines @@
 
     void setCanHaveScrollbarsInternal(bool);
     bool canHaveScrollbars() const { return horizontalScrollbarMode() != ScrollbarAlwaysOff || verticalScrollbarMode() != ScrollbarAlwaysOff; }
 
     // By default, paint events are clipped to the visible area.  If set to
     // false, paint events are no longer clipped.
     bool clipsPaintInvalidations() const { return m_clipsRepaints; }
     void setClipsRepaints(bool);
 
     // Overridden by FrameView to create custom CSS scrollbars if applicable.
-    PassRefPtr<Scrollbar> createScrollbarInternal(ScrollbarOrientation);
+    PassRefPtrWillBeRawPtr<Scrollbar> createScrollbarInternal(ScrollbarOrientation);
 
     // The visible content rect has a location that is the scrolled offset of the document. The width and height are the viewport width
     // and height. By default the scrollbars themselves are excluded from this rectangle, but an optional boolean argument allows them to be
     // included.
     virtual IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const override;
     IntSize visibleSize() const { return visibleContentRect().size(); }
 
     // visibleContentRect().size() is computed from unscaledVisibleContentSize() divided by the value of visibleContentScaleFactor.
     // For the main frame, visibleContentScaleFactor is equal to the page's pageScaleFactor; it's 1 otherwise.
     IntSize unscaledVisibleContentSize(IncludeScrollbarsInRect = ExcludeScrollbars) const;
@@ skipping 126 matching lines @@
     virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const override;
     virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const override;
     virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const override;
     virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const override;
 
     void calculateAndPaintOverhangAreas(GraphicsContext*, const IntRect& dirtyRect);
     void calculateAndPaintOverhangBackground(GraphicsContext*, const IntRect& dirtyRect);
 
     virtual bool isFrameView() const override { return true; }
 
+    virtual void trace(Visitor*) override;
+
 protected:
     bool scrollContentsFastPath(const IntSize& scrollDelta);
     void scrollContentsSlowPath(const IntRect& updateRect);
 
     bool isVerticalDocument() const;
     bool isFlippedDocument() const;
 
     // Prevents creation of scrollbars. Used to prevent drawing two sets of
     // overlay scrollbars in the case of the pinch viewport.
     bool scrollbarsDisabled() const;
@@ skipping 44 matching lines @@
         { }
     private:
         TemporaryChange<bool> m_scope;
     };
 
     bool scrollbarsDisabledInternal() const { return false; }
 
 private:
     explicit FrameView(LocalFrame*);
 
+    void dispose();
     void reset();
     void init();
 
     virtual void frameRectsChanged() override;
 
     friend class RenderPart;
 
     bool contentsInCompositedLayer() const;
 
     void applyOverflowToViewportAndSetRenderer(RenderObject*, ScrollbarMode& hMode, ScrollbarMode& vMode);
@@ skipping 50 matching lines @@
 
     void updateScrollCorner();
 
     FrameView* parentFrameView() const;
 
     AXObjectCache* axObjectCache() const;
     void removeFromAXObjectCache();
 
     void setLayoutSizeInternal(const IntSize&);
 
+    void disposeAutoSizeInfo();
+
     bool paintInvalidationIsAllowed() const
     {
         return !isInPerformLayout() || canInvalidatePaintDuringPerformLayout();
     }
 
     bool adjustScrollbarExistence(ComputeScrollbarExistenceOption = FirstPass);
     void adjustScrollbarOpacity();
     // FIXME(bokan): setScrollOffset, setScrollPosition, scrollTo, scrollToOffsetWithoutAnimation,
     // notifyScrollPositionChanged...there's too many ways to scroll this class. This needs
     // some cleanup.
     void setScrollOffsetFromUpdateScrollbars(const DoubleSize&);
 
     IntRect rectToCopyOnScroll() const;
 
     void calculateOverhangAreasForPainting(IntRect& horizontalOverhangRect, IntRect& verticalOverhangRect);
     void updateOverhangAreas();
 
     bool isFrameViewScrollbar(const Widget* child) const { return horizontalScrollbar() == child || verticalScrollbar() == child; }
 
     static double s_currentFrameTimeStamp; // used for detecting decoded resource thrash in the cache
     static bool s_inPaintContents;
 
     LayoutSize m_size;
 
     typedef WillBeHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > EmbeddedObjectSet;
-    WillBePersistentHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > m_partUpdateSet;
+    WillBeHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > m_partUpdateSet;
 
-    // FIXME: These are just "children" of the FrameView and should be RefPtr<Widget> instead.
-    WillBePersistentHeapHashSet<RefPtrWillBeMember<RenderPart> > m_parts;
+    // FIXME: These are just "children" of the FrameView and should be RefPtrWillBeMember<Widget> instead.
+    WillBeHeapHashSet<RefPtrWillBeMember<RenderPart> > m_parts;
 
-    // Oilpan: the use of a persistent back reference 'emulates' the
-    // RefPtr-cycle that is kept between the two objects non-Oilpan.
+    // The RefPtr cycle between LocalFrame and FrameView is broken
+    // when a LocalFrame is detached by FrameLoader::detachFromParent().
+    // It clears the LocalFrame's m_view reference via setView(nullptr).
     //
-    // That cycle is broken when a LocalFrame is detached by
-    // FrameLoader::detachFromParent(), it then clears its
-    // FrameView's m_frame reference by calling setView(nullptr).
-    RefPtrWillBePersistent<LocalFrame> m_frame;
+    // For Oilpan, Member reference cycles pose no problem, but
+    // LocalFrame's FrameView is also cleared by setView(). This additionally
+    // triggers FrameView::dispose(), which performs the operations
+    // that cannot be delayed until finalization time.
+    RefPtrWillBeMember<LocalFrame> m_frame;
 
     bool m_doFullPaintInvalidation;
 
     bool m_canHaveScrollbars;
     unsigned m_slowRepaintObjectCount;
 
     bool m_hasPendingLayout;
     RenderObject* m_layoutSubtreeRoot;
 
     bool m_layoutSchedulingEnabled;
@@ skipping 22 matching lines @@
 
     bool m_wasScrolledByUser;
     bool m_inProgrammaticScroll;
     bool m_safeToPropagateScrollToParent;
 
     double m_lastPaintTime;
 
     bool m_isTrackingPaintInvalidations; // Used for testing.
     Vector<IntRect> m_trackedPaintInvalidationRects;
 
-    RefPtrWillBePersistent<Node> m_nodeToDraw;
+    RefPtrWillBeMember<Node> m_nodeToDraw;
     PaintBehavior m_paintBehavior;
     bool m_isPainting;
 
     unsigned m_visuallyNonEmptyCharacterCount;
     unsigned m_visuallyNonEmptyPixelCount;
     bool m_isVisuallyNonEmpty;
     bool m_firstVisuallyNonEmptyLayoutCallbackPending;
 
-    RefPtrWillBePersistent<Node> m_maintainScrollPositionAnchor;
+    RefPtrWillBeMember<Node> m_maintainScrollPositionAnchor;
 
     // Renderer to hold our custom scroll corner.
-    RawPtrWillBePersistent<RenderScrollbarPart> m_scrollCorner;
+    RawPtrWillBeMember<RenderScrollbarPart> m_scrollCorner;
 
     OwnPtr<ScrollableAreaSet> m_scrollableAreas;
     OwnPtr<ResizerAreaSet> m_resizerAreas;
     OwnPtr<ViewportConstrainedObjectSet> m_viewportConstrainedObjects;
-    OwnPtr<FrameViewAutoSizeInfo> m_autoSizeInfo;
+    OwnPtrWillBeMember<FrameViewAutoSizeInfo> m_autoSizeInfo;
 
     float m_visibleContentScaleFactor;
     IntSize m_inputEventsOffsetForEmulation;
     float m_inputEventsScaleFactorForEmulation;
 
     IntSize m_layoutSize;
     bool m_layoutSizeFixedToFrameSize;
 
     Timer<FrameView> m_didScrollTimer;
 
     Vector<IntRect> m_tickmarks;
 
-    bool m_needsUpdateWidgetPositions;
     float m_topControlsViewportAdjustment;
 
-    RefPtr<Scrollbar> m_horizontalScrollbar;
-    RefPtr<Scrollbar> m_verticalScrollbar;
+    bool m_needsUpdateWidgetPositions;
+
+#if ENABLE(OILPAN) && ENABLE(ASSERT)
+    // Verified when finalizing.
+    bool m_hasBeenDisposed;
+#endif
+
+    RefPtrWillBeMember<Scrollbar> m_horizontalScrollbar;
+    RefPtrWillBeMember<Scrollbar> m_verticalScrollbar;
     ScrollbarMode m_horizontalScrollbarMode;
     ScrollbarMode m_verticalScrollbarMode;
 
     bool m_horizontalScrollbarLock;
     bool m_verticalScrollbarLock;
 
-    HashSet<RefPtr<Widget> > m_children;
+    ChildrenWidgetSet m_children;
 
     DoubleSize m_pendingScrollDelta;
     DoublePoint m_scrollPosition;
     DoublePoint m_cachedScrollPosition;
     IntSize m_contentsSize;
 
     int m_scrollbarsAvoidingResizer;
     bool m_scrollbarsSuppressed;
 
     bool m_inUpdateScrollbars;
@@ skipping 23 matching lines @@
     m_visuallyNonEmptyPixelCount += size.width() * size.height();
     // Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout
     static const unsigned visualPixelThreshold = 32 * 32;
     if (m_visuallyNonEmptyPixelCount > visualPixelThreshold)
         setIsVisuallyNonEmpty();
 }
 
 DEFINE_TYPE_CASTS(FrameView, Widget, widget, widget->isFrameView(), widget.isFrameView());
 
 class AllowPaintInvalidationScope {
+    STACK_ALLOCATED();
 public:
     explicit AllowPaintInvalidationScope(FrameView* view)
         : m_view(view)
         , m_originalValue(view ? view->canInvalidatePaintDuringPerformLayout() : false)
     {
         if (!m_view)
             return;
 
         m_view->setCanInvalidatePaintDuringPerformLayout(true);
     }
 
     ~AllowPaintInvalidationScope()
     {
         if (!m_view)
             return;
 
         m_view->setCanInvalidatePaintDuringPerformLayout(m_originalValue);
     }
+
 private:
-    FrameView* m_view;
+    RawPtrWillBeMember<FrameView> m_view;
     bool m_originalValue;
 };
 
 } // namespace blink
 
 #endif // FrameView_h