Fold ScrollingCoordinatorChromium into ScrollingCoordinator and devirtualize

Source/WebCore/page/scrolling/ScrollingCoordinator.h

Index: Source/WebCore/page/scrolling/ScrollingCoordinator.h
diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.h b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
index 2ecb46463b3cb1ef2c0756ce4ba6673fd8884988..382c6d7f20f43b97a9a29fe6dec18f1fe0ba377a 100644
--- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h
+++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.h
@@ -31,25 +31,15 @@
 #include "PlatformWheelEvent.h"
 #include "RenderObject.h"
 #include "ScrollTypes.h"
-#include "Timer.h"
-#include <wtf/Forward.h>
 
-#if ENABLE(THREADED_SCROLLING)
-#include <wtf/HashMap.h>
-#include <wtf/ThreadSafeRefCounted.h>
-#include <wtf/Threading.h>
-#endif
-
-#if PLATFORM(MAC)
-#include <wtf/RetainPtr.h>
-#endif
+namespace WebKit {
+class WebLayer;
+class WebScrollbarLayer;
+}
 
 namespace WebCore {
 
 typedef unsigned MainThreadScrollingReasons;
-typedef uint64_t ScrollingNodeID;
-
-enum ScrollingNodeType { ScrollingNode, FixedNode, StickyNode };
 
 class Document;
 class Frame;
@@ -60,31 +50,18 @@ class Region;
 class ScrollableArea;
 class ViewportConstraints;
 
-#if ENABLE(THREADED_SCROLLING)
-class ScrollingTree;
-#endif
-
-enum SetOrSyncScrollingLayerPosition {
-    SetScrollingLayerPosition,
-    SyncScrollingLayerPosition
-};
-
-class ScrollingCoordinator : public ThreadSafeRefCounted<ScrollingCoordinator> {
+class ScrollingCoordinator : public RefCounted<ScrollingCoordinator> {
 public:
     static PassRefPtr<ScrollingCoordinator> create(Page*);
-    virtual ~ScrollingCoordinator();
-
-    virtual void pageDestroyed();
+    ~ScrollingCoordinator();
 
-#if ENABLE(THREADED_SCROLLING)
-    virtual ScrollingTree* scrollingTree() const { return 0; }
-#endif
+    void pageDestroyed();
 
     // Return whether this scrolling coordinator handles scrolling for the given frame view.
     bool coordinatesScrollingForFrameView(FrameView*) const;
 
     // Should be called whenever the given frame view has been laid out.
-    virtual void frameViewLayoutUpdated(FrameView*) { }
+    void frameViewLayoutUpdated(FrameView*);
 
     // Should be called whenever a wheel event handler is added or removed in the 
     // frame view's underlying document.
@@ -97,64 +74,33 @@ public:
     void frameViewFixedObjectsDidChange(FrameView*);
 
     // Should be called whenever the root layer for the given frame view changes.
-    virtual void frameViewRootLayerDidChange(FrameView*);
+    void frameViewRootLayerDidChange(FrameView*);
 
     // Return whether this scrolling coordinator can keep fixed position layers fixed to their
     // containers while scrolling.
-    virtual bool supportsFixedPositionLayers() const { return false; }
+    bool supportsFixedPositionLayers() const { return true; }
 
-#if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN))
+#if OS(DARWIN)
     // Dispatched by the scrolling tree during handleWheelEvent. This is required as long as scrollbars are painted on the main thread.
     void handleWheelEventPhase(PlatformWheelEventPhase);
 #endif
 
-    // Force all scroll layer position updates to happen on the main thread.
-    void setForceMainThreadScrollLayerPositionUpdates(bool);
-
-    // These virtual functions are currently unique to the threaded scrolling architecture. 
-    // Their meaningful implementations are in ScrollingCoordinatorMac.
-    virtual void commitTreeStateIfNeeded() { }
-    virtual bool requestScrollPositionUpdate(FrameView*, const IntPoint&) { return false; }
-    virtual bool handleWheelEvent(FrameView*, const PlatformWheelEvent&) { return true; }
-    virtual ScrollingNodeID attachToStateTree(ScrollingNodeType, ScrollingNodeID newNodeID, ScrollingNodeID /*parentID*/) { return newNodeID; }
-    virtual void detachFromStateTree(ScrollingNodeID) { }
-    virtual void clearStateTree() { }
-    virtual void updateViewportConstrainedNode(ScrollingNodeID, const ViewportConstraints&, GraphicsLayer*) { }
-    virtual void updateScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*counterScrollingLayer*/) { }
-    virtual void syncChildPositions(const LayoutRect&) { }
-    virtual String scrollingStateTreeAsText() const;
-    virtual bool isRubberBandInProgress() const { return false; }
-    virtual bool rubberBandsAtBottom() const { return false; }
-    virtual void setRubberBandsAtBottom(bool) { }
-    virtual bool rubberBandsAtTop() const { return false; }
-    virtual void setRubberBandsAtTop(bool) { }
-
-    // Generated a unique id for scroll layers.
-    ScrollingNodeID uniqueScrollLayerID();
-
-    // Dispatched by the scrolling tree whenever the main frame scroll position changes.
-    void scheduleUpdateMainFrameScrollPosition(const IntPoint&, bool programmaticScroll, SetOrSyncScrollingLayerPosition);
-    void updateMainFrameScrollPosition(const IntPoint&, bool programmaticScroll, SetOrSyncScrollingLayerPosition);
-
     enum MainThreadScrollingReasonFlags {
-        ForcedOnMainThread = 1 << 0,
-        HasSlowRepaintObjects = 1 << 1,
-        HasViewportConstrainedObjectsWithoutSupportingFixedLayers = 1 << 2,
-        HasNonLayerViewportConstrainedObjects = 1 << 3,
-        IsImageDocument = 1 << 4
+        HasSlowRepaintObjects = 1 << 0,
+        HasViewportConstrainedObjectsWithoutSupportingFixedLayers = 1 << 1,
+        HasNonLayerViewportConstrainedObjects = 1 << 2,
+        IsImageDocument = 1 << 3
     };
 
     MainThreadScrollingReasons mainThreadScrollingReasons() const;
     bool shouldUpdateScrollLayerPositionOnMainThread() const { return mainThreadScrollingReasons() != 0; }
 
-    // These virtual functions are currently unique to Chromium's WebLayer approach. Their meaningful
-    // implementations are in ScrollingCoordinatorChromium.
-    virtual void willDestroyScrollableArea(ScrollableArea*) { }
-    virtual void scrollableAreaScrollLayerDidChange(ScrollableArea*) { }
-    virtual void scrollableAreaScrollbarLayerDidChange(ScrollableArea*, ScrollbarOrientation) { }
-    virtual void setLayerIsContainerForFixedPositionLayers(GraphicsLayer*, bool) { }
-    virtual void updateLayerPositionConstraint(RenderLayer*) { }
-    virtual void touchEventTargetRectsDidChange(const Document*) { }
+    void willDestroyScrollableArea(ScrollableArea*);
+    void scrollableAreaScrollLayerDidChange(ScrollableArea*);
+    void scrollableAreaScrollbarLayerDidChange(ScrollableArea*, ScrollbarOrientation);
+    void setLayerIsContainerForFixedPositionLayers(GraphicsLayer*, bool);
+    void updateLayerPositionConstraint(RenderLayer*);
+    void touchEventTargetRectsDidChange(const Document*);
 
 #if ENABLE(TOUCH_EVENT_TRACKING)
     void computeAbsoluteTouchEventTargetRects(const Document*, Vector<IntRect>&);
@@ -168,11 +114,9 @@ public:
 protected:
     explicit ScrollingCoordinator(Page*);
 
-#if USE(ACCELERATED_COMPOSITING)
     static GraphicsLayer* scrollLayerForScrollableArea(ScrollableArea*);
     static GraphicsLayer* horizontalScrollbarLayerForScrollableArea(ScrollableArea*);
     static GraphicsLayer* verticalScrollbarLayerForScrollableArea(ScrollableArea*);
-#endif
 
     unsigned computeCurrentWheelEventHandlerCount();
     GraphicsLayer* scrollLayerForFrameView(FrameView*);
@@ -181,20 +125,26 @@ protected:
     Page* m_page;
 
 private:
-    virtual void recomputeWheelEventHandlerCountForFrameView(FrameView*) { }
-    virtual void setShouldUpdateScrollLayerPositionOnMainThread(MainThreadScrollingReasons) { }
+    void recomputeWheelEventHandlerCountForFrameView(FrameView*);
+    void setShouldUpdateScrollLayerPositionOnMainThread(MainThreadScrollingReasons);
 
-    virtual bool hasVisibleSlowRepaintViewportConstrainedObjects(FrameView*) const;
+    bool hasVisibleSlowRepaintViewportConstrainedObjects(FrameView*) const;
     void updateShouldUpdateScrollLayerPositionOnMainThread();
     
-    void updateMainFrameScrollPositionTimerFired(Timer<ScrollingCoordinator>*);
+    static WebKit::WebLayer* scrollingWebLayerForScrollableArea(ScrollableArea*);
+
+    void setNonFastScrollableRegion(const Region&);
+    void setTouchEventTargetRects(const Vector<IntRect>&);
+    void setWheelEventHandlerCount(unsigned);
+
+    WebKit::WebScrollbarLayer* addWebScrollbarLayer(ScrollableArea*, ScrollbarOrientation, PassOwnPtr<WebKit::WebScrollbarLayer>);
+    WebKit::WebScrollbarLayer* getWebScrollbarLayer(ScrollableArea*, ScrollbarOrientation);
+    void removeWebScrollbarLayer(ScrollableArea*, ScrollbarOrientation);
 
-    Timer<ScrollingCoordinator> m_updateMainFrameScrollPositionTimer;
-    IntPoint m_scheduledUpdateScrollPosition;
-    bool m_scheduledUpdateIsProgrammaticScroll;
-    SetOrSyncScrollingLayerPosition m_scheduledScrollingLayerPositionAction;
+    typedef HashMap<ScrollableArea*, OwnPtr<WebKit::WebScrollbarLayer> > ScrollbarMap;
+    ScrollbarMap m_horizontalScrollbars;
+    ScrollbarMap m_verticalScrollbars;
 
-    bool m_forceMainThreadScrollLayerPositionUpdates;
 };
 
 } // namespace WebCore