Calculate paint invalidation rect for scrollbars

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 28 matching lines @@
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #ifndef PaintLayerScrollableArea_h
 #define PaintLayerScrollableArea_h
 
 #include "core/CoreExport.h"
 #include "core/layout/LayoutBox.h"
+#include "core/paint/PaintInvalidationCapableScrollableArea.h"
 #include "core/paint/PaintLayerFragment.h"
 #include "platform/heap/Handle.h"
-#include "platform/scroll/ScrollableArea.h"
 
 namespace blink {
 
 enum ResizerHitTestType {
     ResizerForPointer,
     ResizerForTouch
 };
 
 class PlatformEvent;
 class LayoutBox;
@@ skipping 28 matching lines @@
 //
 //
 // ***** OVERLAY SCROLLBARS *****
 // Overlay scrollbars are painted on top of the box's content. As such they
 // don't use any space in the box. Software overlay scrollbars are painted by
 // PaintLayerPainter::paintOverlayScrollbars after all content as part of a
 // separate tree traversal. The reason for this 2nd traversal is that they need
 // to be painted on top of everything. Hardware accelerated overlay scrollbars
 // are painted by their associated GraphicsLayer that sets the paint flag
 // PaintLayerPaintingOverlayScrollbars.
-class CORE_EXPORT PaintLayerScrollableArea final : public NoBaseWillBeGarbageCollectedFinalized<PaintLayerScrollableArea>, public ScrollableArea {
+class CORE_EXPORT PaintLayerScrollableArea final : public NoBaseWillBeGarbageCollectedFinalized<PaintLayerScrollableArea>, public PaintInvalidationCapableScrollableArea {
     USING_FAST_MALLOC_WILL_BE_REMOVED(PaintLayerScrollableArea);
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(PaintLayerScrollableArea);
     friend class Internals;
 
 private:
     class ScrollbarManager {
         DISALLOW_NEW();
 
         // Helper class to manage the life cycle of Scrollbar objects.  Some layout containers
         // (e.g., flexbox, table) run multi-pass layout on their children, applying different
@@ skipping 22 matching lines @@
         bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
         bool hasVerticalScrollbar() const { return verticalScrollbar(); }
 
         void setHasHorizontalScrollbar(bool hasScrollbar);
         void setHasVerticalScrollbar(bool hasScrollbar);
 
         DECLARE_TRACE();
 
     private:
         PassRefPtrWillBeRawPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
-        void destroyScrollbar(ScrollbarOrientation, bool invalidate = false);
+        void destroyScrollbar(ScrollbarOrientation);
 
     private:
         RawPtrWillBeMember<PaintLayerScrollableArea> m_scrollableArea;
 
         // The scrollbars associated with m_scrollableArea. Both can nullptr.
         RefPtrWillBeMember<Scrollbar> m_hBar;
         RefPtrWillBeMember<Scrollbar> m_vBar;
 
         unsigned m_canDetachScrollbars: 1;
         unsigned m_hBarIsAttached: 1;
@@ skipping 27 matching lines @@
     GraphicsLayer* layerForScrolling() const override;
 
     // GraphicsLayers for the scrolling components.
     //
     // Any function can return nullptr if they are not accelerated.
     GraphicsLayer* layerForHorizontalScrollbar() const override;
     GraphicsLayer* layerForVerticalScrollbar() const override;
     GraphicsLayer* layerForScrollCorner() const override;
 
     bool usesCompositedScrolling() const override;
-    void invalidateScrollbarRect(Scrollbar*, const IntRect&) override;
-    void invalidateScrollCornerRect(const IntRect&) override;
+    void scrollControlWasSetNeedsPaintInvalidation() override;
     bool shouldUseIntegerScrollOffset() const override;
     bool isActive() const override;
     bool isScrollCornerVisible() const override;
     IntRect scrollCornerRect() const override;
     IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const override;
     IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const override;
     IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const override;
     IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const override;
     int scrollSize(ScrollbarOrientation) const override;
     IntPoint scrollPosition() const override;
@@ skipping 51 matching lines @@
     void finalizeScrollDimensions(const DoubleSize& originalScrollOffset, bool autoHorizontalScrollBarChanged, bool autoVerticalScrollBarChanged);
 
     void updateAfterLayout();
     void updateAfterStyleChange(const ComputedStyle*);
     void updateAfterOverflowRecalc();
 
     bool updateAfterCompositingChange() override;
 
     bool hasScrollbar() const { return hasHorizontalScrollbar() || hasVerticalScrollbar(); }
 
-    LayoutScrollbarPart* scrollCorner() const { return m_scrollCorner; }
+    LayoutScrollbarPart* scrollCorner() const override { return m_scrollCorner; }
 
     void resize(const PlatformEvent&, const LayoutSize&);
     IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
 
     bool inResizeMode() const { return m_inResizeMode; }
     void setInResizeMode(bool inResizeMode) { m_inResizeMode = inResizeMode; }
 
     IntRect touchResizerCornerRect(const IntRect& bounds) const
     {
         return resizerCornerRect(bounds, ResizerForTouch);
@@ skipping 39 matching lines @@
     // These are used during compositing updates to determine if the overflow
     // controls need to be repositioned in the GraphicsLayer tree.
     void setTopmostScrollChild(PaintLayer*);
     PaintLayer* topmostScrollChild() const { ASSERT(!m_nextTopmostScrollChild); return m_topmostScrollChild; }
 
     IntRect resizerCornerRect(const IntRect&, ResizerHitTestType) const;
 
     LayoutBox& box() const;
     PaintLayer* layer() const;
 
-    LayoutScrollbarPart* resizer() { return m_resizer; }
+    LayoutScrollbarPart* resizer() const override { return m_resizer; }
 
     const IntPoint& cachedOverlayScrollbarOffset() { return m_cachedOverlayScrollbarOffset; }
     void setCachedOverlayScrollbarOffset(const IntPoint& offset) { m_cachedOverlayScrollbarOffset = offset; }
 
     IntRect rectForHorizontalScrollbar(const IntRect& borderBoxRect) const;
     IntRect rectForVerticalScrollbar(const IntRect& borderBoxRect) const;
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
@@ skipping 23 matching lines @@
 
     // See comments on isPointInResizeControl.
     void updateResizerAreaSet();
     void updateResizerStyle();
 
 
     void updateScrollableAreaSet(bool hasOverflow);
 
     void updateCompositingLayersAfterScroll();
 
+    // PaintInvalidationCapableScrollableArea
+    LayoutBox& boxForScrollControlPaintInvalidation() const { return box(); }
+
     PaintLayer& m_layer;
 
     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
     unsigned m_inResizeMode : 1;
     unsigned m_scrollsOverflow : 1;
 
     unsigned m_inOverflowRelayout : 1;
 
     PaintLayer* m_nextTopmostScrollChild;
     PaintLayer* m_topmostScrollChild;
@@ skipping 23 matching lines @@
     LayoutScrollbarPart* m_resizer;
 
 #if ENABLE(ASSERT)
     bool m_hasBeenDisposed;
 #endif
 };
 
 } // namespace blink
 
 #endif // LayerScrollableArea_h