Deduplicate part of RenderLayerScrollableArea/ScrollableArea.

sky/engine/platform/scroll/ScrollableArea.h

 /*
  * Copyright (C) 2008, 2011 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 43 matching lines @@
 
 class PLATFORM_EXPORT ScrollableArea {
     WTF_MAKE_NONCOPYABLE(ScrollableArea);
 public:
     static int pixelsPerLineStep();
     static float minFractionToStepWhenPaging();
     static int maxOverlapBetweenPages();
 
     // The window that hosts the ScrollView. The ScrollView will communicate scrolls and repaints to the
     // host window in the window's coordinate space.
-    virtual HostWindow* hostWindow() const { return 0; };
+    virtual HostWindow* hostWindow() const = 0;
 
     bool scroll(ScrollDirection, ScrollGranularity, float delta = 1);
     void scrollToOffsetWithoutAnimation(const FloatPoint&);
     void scrollToOffsetWithoutAnimation(ScrollbarOrientation, float offset);
 
     void programmaticallyScrollSmoothlyToOffset(const FloatPoint&);
 
     // Should be called when the scroll position changes externally, for example if the scroll layer position
     // is updated on the scrolling thread and we need to notify the main thread.
     void notifyScrollPositionChanged(const IntPoint&);
@@ skipping 19 matching lines @@
     void mouseEnteredContentArea() const;
     void mouseExitedContentArea() const;
     void mouseMovedInContentArea() const;
     void mouseEnteredScrollbar(Scrollbar*) const;
     void mouseExitedScrollbar(Scrollbar*) const;
     void contentAreaDidShow() const;
     void contentAreaDidHide() const;
 
     void finishCurrentScrollAnimations() const;
 
-    virtual void didAddScrollbar(Scrollbar*, ScrollbarOrientation);
-    virtual void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation);
+    void didAddScrollbar(Scrollbar*, ScrollbarOrientation);
+    void willRemoveScrollbar(Scrollbar*, ScrollbarOrientation);
 
-    virtual void contentsResized();
+    void contentsResized();
 
     bool hasOverlayScrollbars() const;
     void setScrollbarOverlayStyle(ScrollbarOverlayStyle);
     ScrollbarOverlayStyle scrollbarOverlayStyle() const { return static_cast<ScrollbarOverlayStyle>(m_scrollbarOverlayStyle); }
 
     // This getter will create a ScrollAnimator if it doesn't already exist.
     ScrollAnimator* scrollAnimator() const;
 
     // This getter will return null if the ScrollAnimator hasn't been created yet.
     ScrollAnimator* existingScrollAnimator() const { return m_animators ? m_animators->scrollAnimator.get() : 0; }
 
     ProgrammaticScrollAnimator* programmaticScrollAnimator() const;
     ProgrammaticScrollAnimator* existingProgrammaticScrollAnimator() const
     {
         return m_animators ? m_animators->programmaticScrollAnimator.get() : 0;
     }
 
     const IntPoint& scrollOrigin() const { return m_scrollOrigin; }
     bool scrollOriginChanged() const { return m_scrollOriginChanged; }
 
     // FIXME(bokan): Meaningless name, rename to isActiveFocus
     virtual bool isActive() const = 0;
     virtual int scrollSize(ScrollbarOrientation) const = 0;
-    virtual void invalidateScrollbar(Scrollbar*, const IntRect&);
+    void invalidateScrollbar(Scrollbar*, const IntRect&);
 
     // Convert points and rects between the scrollbar and its containing view.
     // The client needs to implement these in order to be aware of layout effects
     // like CSS transforms.
-    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const = 0;
-    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const = 0;
-    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const = 0;
-    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const = 0;
+    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const = 0;
+    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const = 0;
+    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const = 0;
+    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const = 0;
 
     virtual Scrollbar* horizontalScrollbar() const = 0;
     virtual Scrollbar* verticalScrollbar() const = 0;
 
     // scrollPosition is relative to the scrollOrigin. i.e. If the page is RTL
     // then scrollPosition will be negative.
     virtual IntPoint scrollPosition() const = 0;
     virtual IntPoint minimumScrollPosition() const = 0;
     virtual IntPoint maximumScrollPosition() const = 0;
 
-    virtual IntRect visibleContentRect(IncludeScrollbarsInRect = ExcludeScrollbars) const;
-    virtual int visibleHeight() const = 0;
-    virtual int visibleWidth() const = 0;
     virtual IntSize contentsSize() const = 0;
-    virtual IntSize overhangAmount() const { return IntSize(); }
-    virtual IntPoint lastKnownMousePosition() const { return IntPoint(); }
 
-    virtual bool shouldSuspendScrollAnimations() const { return true; }
-
-    // Returns the bounding box of this scrollable area, in the coordinate system of the enclosing scroll view.
-    virtual IntRect scrollableAreaBoundingBox() const = 0;
+    bool shouldSuspendScrollAnimations() const { return true; }
 
     // NOTE: Only called from Internals for testing.
     void setScrollOffsetFromInternals(const IntPoint&);
 
     IntPoint clampScrollPosition(const IntPoint&) const;
 
     // Let subclasses provide a way of asking for and servicing scroll
     // animations.
     bool scheduleAnimation();
     void serviceScrollAnimations(double monotonicTime);
 
     // Returns true if the GraphicsLayer tree needs to be rebuilt.
-    virtual bool updateAfterCompositingChange() { return false; }
+    virtual bool updateAfterCompositingChange() = 0;
 
     virtual bool userInputScrollable(ScrollbarOrientation) const = 0;
     virtual bool shouldPlaceVerticalScrollbarOnLeft() const = 0;
 
-    // Convenience functions
     int scrollPosition(ScrollbarOrientation orientation) { return orientation == HorizontalScrollbar ? scrollPosition().x() : scrollPosition().y(); }
     int minimumScrollPosition(ScrollbarOrientation orientation) { return orientation == HorizontalScrollbar ? minimumScrollPosition().x() : minimumScrollPosition().y(); }
     int maximumScrollPosition(ScrollbarOrientation orientation) { return orientation == HorizontalScrollbar ? maximumScrollPosition().x() : maximumScrollPosition().y(); }
     int clampScrollPosition(ScrollbarOrientation orientation, int pos)  { return std::max(std::min(pos, maximumScrollPosition(orientation)), minimumScrollPosition(orientation)); }
 
     bool hasVerticalBarDamage() const { return !m_verticalBarDamage.isEmpty(); }
     bool hasHorizontalBarDamage() const { return !m_horizontalBarDamage.isEmpty(); }
     const IntRect& verticalBarDamage() const { return m_verticalBarDamage; }
     const IntRect& horizontalBarDamage() const { return m_horizontalBarDamage; }
 
     void addScrollbarDamage(Scrollbar* scrollbar, const IntRect& rect)
     {
         if (scrollbar == horizontalScrollbar())
             m_horizontalBarDamage.unite(rect);
         else
             m_verticalBarDamage.unite(rect);
     }
 
     void resetScrollbarDamage()
     {
         m_verticalBarDamage = IntRect();
         m_horizontalBarDamage = IntRect();
     }
 
-    virtual GraphicsLayer* layerForContainer() const;
-    virtual GraphicsLayer* layerForScrolling() const { return 0; }
-    virtual GraphicsLayer* layerForHorizontalScrollbar() const { return 0; }
-    virtual GraphicsLayer* layerForVerticalScrollbar() const { return 0; }
+    GraphicsLayer* layerForContainer() const;
+    virtual GraphicsLayer* layerForScrolling() const = 0;
+    virtual GraphicsLayer* layerForHorizontalScrollbar() const = 0;
+    virtual GraphicsLayer* layerForVerticalScrollbar() const = 0;
     bool hasLayerForHorizontalScrollbar() const;
     bool hasLayerForVerticalScrollbar() const;
 
     void cancelProgrammaticScrollAnimation();
 
 protected:
     ScrollableArea();
     virtual ~ScrollableArea();
 
     void setScrollOrigin(const IntPoint&);
     void resetScrollOriginChanged() { m_scrollOriginChanged = false; }
 
     virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&) = 0;
 
 private:
     void scrollPositionChanged(const IntPoint&);
 
     // NOTE: Only called from the ScrollAnimator.
     friend class ScrollAnimator;
     void setScrollOffsetFromAnimation(const IntPoint&);
 
     // This function should be overriden by subclasses to perform the actual
     // scroll of the content.
     virtual void setScrollOffset(const IntPoint&) = 0;
 
-    virtual int lineStep(ScrollbarOrientation) const;
-    virtual int pageStep(ScrollbarOrientation) const;
-    virtual int documentStep(ScrollbarOrientation) const;
-    virtual float pixelStep(ScrollbarOrientation) const;
+    int lineStep(ScrollbarOrientation) const;
+    int documentStep(ScrollbarOrientation) const;
+    virtual int pageStep(ScrollbarOrientation) const = 0;
+    float pixelStep(ScrollbarOrientation) const;
 
     // Stores the paint invalidations for the scrollbars during layout.
     IntRect m_horizontalBarDamage;
     IntRect m_verticalBarDamage;
 
     struct ScrollableAreaAnimators {
         OwnPtr<ScrollAnimator> scrollAnimator;
         OwnPtr<ProgrammaticScrollAnimator> programmaticScrollAnimator;
     };
 
@@ skipping 19 matching lines @@
     // vertical-lr / ltr            NO                      NO
     // vertical-lr / rtl            NO                      YES
     // vertical-rl / ltr            YES                     NO
     // vertical-rl / rtl            YES                     YES
     IntPoint m_scrollOrigin;
 };
 
 } // namespace blink
 
 #endif // ScrollableArea_h