diff options
Diffstat (limited to 'Source/WebCore/page/scrolling/ScrollingCoordinator.h')
| -rw-r--r-- | Source/WebCore/page/scrolling/ScrollingCoordinator.h | 146 |
1 files changed, 91 insertions, 55 deletions
diff --git a/Source/WebCore/page/scrolling/ScrollingCoordinator.h b/Source/WebCore/page/scrolling/ScrollingCoordinator.h index 0e05d69fd..eb6dabf97 100644 --- a/Source/WebCore/page/scrolling/ScrollingCoordinator.h +++ b/Source/WebCore/page/scrolling/ScrollingCoordinator.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Apple Inc. All rights reserved. + * Copyright (C) 2011, 2015 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -23,15 +23,18 @@ * THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ScrollingCoordinator_h -#define ScrollingCoordinator_h +#pragma once +#include "EventTrackingRegions.h" #include "IntRect.h" #include "LayoutRect.h" #include "PlatformWheelEvent.h" -#include "RenderObject.h" +#include "ScrollSnapOffsetsInfo.h" #include "ScrollTypes.h" #include <wtf/Forward.h> +#include <wtf/ThreadSafeRefCounted.h> +#include <wtf/TypeCasts.h> +#include <wtf/Variant.h> #if ENABLE(ASYNC_SCROLLING) #include <wtf/HashMap.h> @@ -39,8 +42,8 @@ #include <wtf/Threading.h> #endif -#if PLATFORM(MAC) -#include <wtf/RetainPtr.h> +#if ENABLE(CSS_SCROLL_SNAP) +#include "AxisScrollSnapOffsets.h" #endif namespace WebCore { @@ -48,7 +51,7 @@ namespace WebCore { typedef unsigned SynchronousScrollingReasons; typedef uint64_t ScrollingNodeID; -enum ScrollingNodeType { ScrollingNode, FixedNode, StickyNode }; +enum ScrollingNodeType { FrameScrollingNode, OverflowScrollingNode, FixedNode, StickyNode }; class Document; class Frame; @@ -57,15 +60,17 @@ class GraphicsLayer; class Page; class Region; class ScrollableArea; +class TextStream; class ViewportConstraints; #if ENABLE(ASYNC_SCROLLING) class ScrollingTree; #endif -enum SetOrSyncScrollingLayerPosition { - SetScrollingLayerPosition, - SyncScrollingLayerPosition +enum class ScrollingLayerPositionAction { + Set, + SetApproximate, + Sync }; struct ScrollableAreaParameters { @@ -101,114 +106,145 @@ struct ScrollableAreaParameters { class ScrollingCoordinator : public ThreadSafeRefCounted<ScrollingCoordinator> { public: - static PassRefPtr<ScrollingCoordinator> create(Page*); + static Ref<ScrollingCoordinator> create(Page*); virtual ~ScrollingCoordinator(); - virtual void pageDestroyed(); + WEBCORE_EXPORT virtual void pageDestroyed(); virtual bool isAsyncScrollingCoordinator() const { return false; } virtual bool isRemoteScrollingCoordinator() const { return false; } // Return whether this scrolling coordinator handles scrolling for the given frame view. - bool coordinatesScrollingForFrameView(FrameView*) const; + virtual bool coordinatesScrollingForFrameView(const FrameView&) const; // Should be called whenever the given frame view has been laid out. - virtual void frameViewLayoutUpdated(FrameView*) { } + virtual void frameViewLayoutUpdated(FrameView&) { } - // Should be called whenever a wheel event handler is added or removed in the - // frame view's underlying document. - void frameViewWheelEventHandlerCountChanged(FrameView*); + using LayoutViewportOriginOrOverrideRect = WTF::Variant<std::optional<FloatPoint>, std::optional<FloatRect>>; + virtual void reconcileScrollingState(FrameView&, const FloatPoint&, const LayoutViewportOriginOrOverrideRect&, bool /* programmaticScroll */, bool /* inStableState*/, ScrollingLayerPositionAction) { } // Should be called whenever the slow repaint objects counter changes between zero and one. - void frameViewHasSlowRepaintObjectsDidChange(FrameView*); + void frameViewHasSlowRepaintObjectsDidChange(FrameView&); // Should be called whenever the set of fixed objects changes. - void frameViewFixedObjectsDidChange(FrameView*); + void frameViewFixedObjectsDidChange(FrameView&); + + // Called whenever the non-fast scrollable region changes for reasons other than layout. + virtual void frameViewEventTrackingRegionsChanged(FrameView&) { } // Should be called whenever the root layer for the given frame view changes. - virtual void frameViewRootLayerDidChange(FrameView*); + virtual 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; } -#if PLATFORM(MAC) +#if PLATFORM(COCOA) // Dispatched by the scrolling tree during handleWheelEvent. This is required as long as scrollbars are painted on the main thread. void handleWheelEventPhase(PlatformWheelEventPhase); #endif +#if ENABLE(WEB_REPLAY) + // Called when the page transitions between executing normally and deterministically. + void replaySessionStateDidChange(); +#endif + // Force all scroll layer position updates to happen on the main thread. - void setForceSynchronousScrollLayerPositionUpdates(bool); + WEBCORE_EXPORT void setForceSynchronousScrollLayerPositionUpdates(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 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&) { } + + struct ScrollingGeometry { + FloatSize scrollableAreaSize; + FloatSize contentSize; + FloatSize reachableContentSize; // Smaller than contentSize when overflow is hidden on one axis. + FloatPoint scrollPosition; + IntPoint scrollOrigin; +#if ENABLE(CSS_SCROLL_SNAP) + Vector<LayoutUnit> horizontalSnapOffsets; + Vector<LayoutUnit> verticalSnapOffsets; + Vector<ScrollOffsetRange<LayoutUnit>> horizontalSnapOffsetRanges; + Vector<ScrollOffsetRange<LayoutUnit>> verticalSnapOffsetRanges; + unsigned currentHorizontalSnapPointIndex; + unsigned currentVerticalSnapPointIndex; +#endif + }; + + virtual void updateFrameScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*scrolledContentsLayer*/, GraphicsLayer* /*counterScrollingLayer*/, GraphicsLayer* /*insetClipLayer*/, const ScrollingGeometry* = nullptr) { } + virtual void updateOverflowScrollingNode(ScrollingNodeID, GraphicsLayer* /*scrollLayer*/, GraphicsLayer* /*scrolledContentsLayer*/, const ScrollingGeometry* = nullptr) { } + virtual void reconcileViewportConstrainedLayerPositions(const LayoutRect&, ScrollingLayerPositionAction) { } virtual String scrollingStateTreeAsText() const; virtual bool isRubberBandInProgress() const { return false; } + virtual bool isScrollSnapInProgress() const { return false; } + virtual void updateScrollSnapPropertiesWithFrameView(const FrameView&) { } virtual void setScrollPinningBehavior(ScrollPinningBehavior) { } // Generated a unique id for scroll layers. ScrollingNodeID uniqueScrollLayerID(); enum MainThreadScrollingReasonFlags { - ForcedOnMainThread = 1 << 0, - HasSlowRepaintObjects = 1 << 1, - HasViewportConstrainedObjectsWithoutSupportingFixedLayers = 1 << 2, - HasNonLayerViewportConstrainedObjects = 1 << 3, - IsImageDocument = 1 << 4 + ForcedOnMainThread = 1 << 0, + HasSlowRepaintObjects = 1 << 1, + HasViewportConstrainedObjectsWithoutSupportingFixedLayers = 1 << 2, + HasNonLayerViewportConstrainedObjects = 1 << 3, + IsImageDocument = 1 << 4 }; - SynchronousScrollingReasons synchronousScrollingReasons() const; - bool shouldUpdateScrollLayerPositionSynchronously() const { return synchronousScrollingReasons(); } + SynchronousScrollingReasons synchronousScrollingReasons(const FrameView&) const; + bool shouldUpdateScrollLayerPositionSynchronously(const FrameView&) const; - virtual void willDestroyScrollableArea(ScrollableArea*) { } - virtual void scrollableAreaScrollLayerDidChange(ScrollableArea*) { } - virtual void scrollableAreaScrollbarLayerDidChange(ScrollableArea*, ScrollbarOrientation) { } - virtual void setLayerIsContainerForFixedPositionLayers(GraphicsLayer*, bool) { } + virtual void willDestroyScrollableArea(ScrollableArea&) { } + virtual void scrollableAreaScrollLayerDidChange(ScrollableArea&) { } + virtual void scrollableAreaScrollbarLayerDidChange(ScrollableArea&, ScrollbarOrientation) { } static String synchronousScrollingReasonsAsText(SynchronousScrollingReasons); String synchronousScrollingReasonsAsText() const; - Region computeNonFastScrollableRegion(const Frame*, const IntPoint& frameLocation) const; + EventTrackingRegions absoluteEventTrackingRegions() const; + virtual void updateExpectsWheelEventTestTriggerWithFrameView(const FrameView&) { } protected: explicit ScrollingCoordinator(Page*); -#if USE(ACCELERATED_COMPOSITING) - static GraphicsLayer* scrollLayerForScrollableArea(ScrollableArea*); - static GraphicsLayer* horizontalScrollbarLayerForScrollableArea(ScrollableArea*); - static GraphicsLayer* verticalScrollbarLayerForScrollableArea(ScrollableArea*); -#endif + static GraphicsLayer* scrollLayerForScrollableArea(ScrollableArea&); - unsigned computeCurrentWheelEventHandlerCount(); - GraphicsLayer* scrollLayerForFrameView(FrameView*); - GraphicsLayer* counterScrollingLayerForFrameView(FrameView*); - GraphicsLayer* headerLayerForFrameView(FrameView*); - GraphicsLayer* footerLayerForFrameView(FrameView*); + GraphicsLayer* scrollLayerForFrameView(FrameView&); + GraphicsLayer* counterScrollingLayerForFrameView(FrameView&); + GraphicsLayer* insetClipLayerForFrameView(FrameView&); + GraphicsLayer* rootContentLayerForFrameView(FrameView&); + GraphicsLayer* contentShadowLayerForFrameView(FrameView&); + GraphicsLayer* headerLayerForFrameView(FrameView&); + GraphicsLayer* footerLayerForFrameView(FrameView&); + + virtual void willCommitTree() { } Page* m_page; // FIXME: ideally this would be a reference but it gets nulled on async teardown. private: - virtual void recomputeWheelEventHandlerCountForFrameView(FrameView*) { } virtual void setSynchronousScrollingReasons(SynchronousScrollingReasons) { } - virtual bool hasVisibleSlowRepaintViewportConstrainedObjects(FrameView*) const; - void updateSynchronousScrollingReasons(); + virtual bool hasVisibleSlowRepaintViewportConstrainedObjects(const FrameView&) const; + void updateSynchronousScrollingReasons(const FrameView&); + + EventTrackingRegions absoluteEventTrackingRegionsForFrame(const Frame&) const; - bool m_forceSynchronousScrollLayerPositionUpdates; + bool m_forceSynchronousScrollLayerPositionUpdates { false }; }; -#define SCROLLING_COORDINATOR_TYPE_CASTS(ToValueTypeName, predicate) \ - TYPE_CASTS_BASE(ToValueTypeName, WebCore::ScrollingCoordinator, value, value->predicate, value.predicate) +WEBCORE_EXPORT TextStream& operator<<(TextStream&, ScrollingNodeType); +WEBCORE_EXPORT TextStream& operator<<(TextStream&, ScrollingLayerPositionAction); } // namespace WebCore -#endif // ScrollingCoordinator_h +#define SPECIALIZE_TYPE_TRAITS_SCROLLING_COORDINATOR(ToValueTypeName, predicate) \ +SPECIALIZE_TYPE_TRAITS_BEGIN(ToValueTypeName) \ + static bool isType(const WebCore::ScrollingCoordinator& value) { return value.predicate; } \ +SPECIALIZE_TYPE_TRAITS_END() |