Move painting code from FrameView to FramePainter.

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 186 matching lines @@
     bool safeToPropagateScrollToParent() const { return m_safeToPropagateScrollToParent; }
     void setSafeToPropagateScrollToParent(bool isSafe) { m_safeToPropagateScrollToParent = isSafe; }
 
     void addPart(RenderPart*);
     void removePart(RenderPart*);
 
     void updateWidgetPositions();
 
     void addPartToUpdate(RenderEmbeddedObject&);
 
-    void paintContents(GraphicsContext*, const IntRect& damageRect);
     void setPaintBehavior(PaintBehavior);
     PaintBehavior paintBehavior() const;
+    void setIsPainting(bool val) { m_isPainting = val; }
     bool isPainting() const;
+    void setLastPaintTime(double val) { m_lastPaintTime = val; }
     bool hasEverPainted() const { return m_lastPaintTime; }
     void setNodeToDraw(Node*);
-
-    void paintOverhangAreas(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);
-    void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
-    void paintScrollbar(GraphicsContext*, Scrollbar*, const IntRect&);
+    Node* nodeToDraw() { return m_nodeToDraw.get(); }
 
     Color documentBackgroundColor() const;
 
     static double currentFrameTimeStamp() { return s_currentFrameTimeStamp; }
+    void setCurrentFrameTimeStamp(double val) { s_currentFrameTimeStamp = val; }
 
     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);
@@ skipping 124 matching lines @@
 
     // Functions for child manipulation and inspection.
     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(); }
+    RenderScrollbarPart* scrollCorner() { return m_scrollCorner; }
 
     void positionScrollbarLayers();
 
     // Functions for setting and retrieving the scrolling mode in each axis (horizontal/vertical). The mode has values of
     // AlwaysOff, AlwaysOn, and Auto. AlwaysOff means never show a scrollbar, AlwaysOn means always show a scrollbar.
     // Auto means show a scrollbar only when one is needed.
     // Note that for platforms with native widgets, these modes are considered advisory. In other words the underlying native
     // widget may choose not to honor the requested modes.
     void setScrollbarModes(ScrollbarMode horizontalMode, ScrollbarMode verticalMode, bool horizontalLock = false, bool verticalLock = false);
     void setHorizontalScrollbarMode(ScrollbarMode mode, bool lock = false) { setScrollbarModes(mode, verticalScrollbarMode(), lock, verticalScrollbarLock()); }
@@ skipping 73 matching lines @@
 
     bool scroll(ScrollDirection, ScrollGranularity);
 
     // Scroll the actual contents of the view (either blitting or invalidating as needed).
     void scrollContents(const IntSize& scrollDelta);
 
     // This gives us a means of blocking painting on our scrollbars until the first layout has occurred.
     void setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress = false);
     bool scrollbarsSuppressed() const { return m_scrollbarsSuppressed; }
 
+    bool drawPanScrollIcon() { return m_shouldDrawPanScrollIcon; }
+
     IntPoint rootViewToContents(const IntPoint&) const;
     IntPoint contentsToRootView(const IntPoint&) const;
     IntRect rootViewToContents(const IntRect&) const;
     IntRect contentsToRootView(const IntRect&) const;
 
     // Event coordinates are assumed to be in the coordinate space of a window that contains
     // the entire widget hierarchy. It is up to the platform to decide what the precise definition
     // of containing window is. (For example on Mac it is the containing NSWindow.)
     IntPoint windowToContents(const IntPoint&) const;
     FloatPoint windowToContents(const FloatPoint&) const;
@@ skipping 36 matching lines @@
     {
         IntPoint newPoint = point;
         if (!isFrameViewScrollbar(child))
             newPoint = point + scrollOffset();
         newPoint.moveBy(-child->location());
         return newPoint;
     }
 
     // Widget override. Handles painting of the contents of the view as well as the scrollbars.
     virtual void paint(GraphicsContext*, const IntRect&) override;
-    void paintScrollbars(GraphicsContext*, const IntRect&);
+    void paintContents(GraphicsContext*, const IntRect& damageRect);
 
     // Widget overrides to ensure that our children's visibility status is kept up to date when we get shown and hidden.
     virtual void show() override;
     virtual void hide() override;
     virtual void setParentVisible(bool) override;
 
     // Pan scrolling.
     static const int noPanScrollRadius = 15;
     void addPanScrollIcon(const IntPoint&);
     void removePanScrollIcon();
     void paintPanScrollIcon(GraphicsContext*);
 
     bool isPointInScrollbarCorner(const IntPoint&);
     bool scrollbarCornerPresent() const;
     virtual IntRect scrollCornerRect() const override;
-    void paintScrollCornerInternal(GraphicsContext*, const IntRect& cornerRect);
-    void paintScrollbarInternal(GraphicsContext*, Scrollbar*, const IntRect&);
 
     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;
+    void notifyPageThatContentAreaWillPaint() const;
+    FrameView* parentFrameView() const;
+
+    void calculateOverhangAreasForPainting(IntRect& horizontalOverhangRect, IntRect& verticalOverhangRect);
 
 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;
 
     // NOTE: This should only be called by the overridden setScrollOffset from ScrollableArea.
     void scrollToInternal(const DoublePoint& newPosition);
 
     void contentRectangleForPaintInvalidationInternal(const IntRect&);
 
-    void paintOverhangAreasInternal(GraphicsContext*, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect);
-
     // These functions are used to create/destroy scrollbars.
     void setHasHorizontalScrollbar(bool);
     void setHasVerticalScrollbar(bool);
 
     void updateScrollCornerInternal();
     virtual void invalidateScrollCornerRect(const IntRect&) override;
 
     void scrollContentsIfNeeded();
     // Scroll the content by via the compositor.
     bool scrollContentsFastPathInternal(const IntSize& scrollDelta) { return true; }
@@ skipping 70 matching lines @@
     virtual IntPoint convertToContainingView(const IntPoint&) const override;
     virtual IntPoint convertFromContainingView(const IntPoint&) const override;
 
     void updateWidgetPositionsIfNeeded();
 
     bool wasViewportResized();
     void sendResizeEventIfNeeded();
 
     void updateScrollableAreaSet();
 
-    void notifyPageThatContentAreaWillPaint() const;
-
     void scheduleUpdateWidgetsIfNecessary();
     void updateWidgetsTimerFired(Timer<FrameView>*);
     bool updateWidgets();
 
     void scrollToAnchor();
     void scrollPositionChanged();
     void didScrollTimerFired(Timer<FrameView>*);
 
     void updateLayersAndCompositingAfterScrollIfNeeded();
 
     static bool computeCompositedSelectionBounds(LocalFrame&, CompositedSelectionBound& start, CompositedSelectionBound& end);
     void updateCompositedSelectionBoundsIfNeeded();
 
     bool hasCustomScrollbars() const;
     bool shouldUseCustomScrollbars(Element*& customScrollbarElement, LocalFrame*& customScrollbarFrame);
 
     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;
     WillBeHeapHashSet<RefPtrWillBeMember<RenderEmbeddedObject> > m_partUpdateSet;
 
     // FIXME: These are just "children" of the FrameView and should be RefPtrWillBeMember<Widget> instead.
     WillBeHeapHashSet<RefPtrWillBeMember<RenderPart> > m_parts;
 
     // The RefPtr cycle between LocalFrame and FrameView is broken
@@ skipping 100 matching lines @@
     DoublePoint m_scrollPosition;
     DoublePoint m_cachedScrollPosition;
     IntSize m_contentsSize;
 
     int m_scrollbarsAvoidingResizer;
     bool m_scrollbarsSuppressed;
 
     bool m_inUpdateScrollbars;
 
     IntPoint m_panScrollIconPoint;
-    bool m_drawPanScrollIcon;
+    bool m_shouldDrawPanScrollIcon;
 
     bool m_clipsRepaints;
 };
 
 inline void FrameView::incrementVisuallyNonEmptyCharacterCount(unsigned count)
 {
     if (m_isVisuallyNonEmpty)
         return;
     m_visuallyNonEmptyCharacterCount += count;
     // Use a threshold value to prevent very small amounts of visible content from triggering didFirstVisuallyNonEmptyLayout.
@@ skipping 38 matching lines @@
     }
 
 private:
     RawPtrWillBeMember<FrameView> m_view;
     bool m_originalValue;
 };
 
 } // namespace blink
 
 #endif // FrameView_h