Diff
Modified: trunk/Source/WebCore/ChangeLog (282748 => 282749)
--- trunk/Source/WebCore/ChangeLog 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/ChangeLog 2021-09-20 16:01:49 UTC (rev 282749)
@@ -1,3 +1,60 @@
+2021-09-20 Simon Fraser <simon.fra...@apple.com>
+
+ Have ScrollingMomentumCalculator work in terms of ScrollExtents
+ https://bugs.webkit.org/show_bug.cgi?id=230465
+
+ Reviewed by Wenson Hsieh.
+
+ ScrollAnimator gets min/max scroll offsets and the viewport size via a ScrollExtents
+ class. To ease a future transition of ScrollingMomentumCalculator to be a ScrollAnimator,
+ move ScrollingMomentumCalculator to use the same struct, which is modified to satisfy
+ the need to provide ScrollingMomentumCalculatorMac with the contents size.
+
+ * page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.h:
+ * page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.mm:
+ (WebCore::ScrollingTreeScrollingNodeDelegateMac::scrollExtents const):
+ (WebCore::ScrollingTreeScrollingNodeDelegateMac::scrollExtent const): Deleted.
+ (WebCore::ScrollingTreeScrollingNodeDelegateMac::viewportSize const): Deleted.
+ * platform/ScrollAnimation.h:
+ * platform/ScrollAnimationKinetic.cpp:
+ (WebCore::ScrollAnimationKinetic::startAnimatedScrollWithInitialVelocity):
+ * platform/ScrollAnimationSmooth.cpp:
+ (WebCore::ScrollAnimationSmooth::startOrRetargetAnimation):
+ (WebCore::ScrollAnimationSmooth::updateScrollExtents):
+ * platform/ScrollAnimator.cpp:
+ (WebCore::ScrollAnimator::scrollExtents const):
+ (WebCore::ScrollAnimator::scrollExtentsForAnimation):
+ (WebCore::ScrollAnimator::scrollExtent const): Deleted.
+ (WebCore::ScrollAnimator::viewportSize const): Deleted.
+ * platform/ScrollAnimator.h:
+ * platform/ScrollSnapAnimatorState.cpp:
+ (WebCore::ScrollSnapAnimatorState::transitionToSnapAnimationState):
+ (WebCore::ScrollSnapAnimatorState::transitionToGlideAnimationState):
+ (WebCore::ScrollSnapAnimatorState::setupAnimationForState):
+ (WebCore::ScrollSnapAnimatorState::targetOffsetForStartOffset const):
+ * platform/ScrollSnapAnimatorState.h:
+ * platform/ScrollTypes.h:
+ (WebCore::ScrollExtents::minimumScrollOffset const):
+ (WebCore::ScrollExtents::maximumScrollOffset const):
+ * platform/ScrollingEffectsController.cpp:
+ (WebCore::ScrollingEffectsController::setNearestScrollSnapIndexForAxisAndOffset):
+ (WebCore::ScrollingEffectsController::adjustScrollDestination):
+ * platform/ScrollingEffectsController.h:
+ * platform/ScrollingMomentumCalculator.cpp:
+ (WebCore::ScrollingMomentumCalculator::ScrollingMomentumCalculator):
+ (WebCore::ScrollingMomentumCalculator::predictedDestinationOffset):
+ (WebCore::ScrollingMomentumCalculator::create):
+ (WebCore::BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator):
+ * platform/ScrollingMomentumCalculator.h:
+ * platform/mac/ScrollingEffectsController.mm:
+ (WebCore::ScrollingEffectsController::statelessSnapTransitionTimerFired):
+ (WebCore::ScrollingEffectsController::processWheelEventForScrollSnap):
+ * platform/mac/ScrollingMomentumCalculatorMac.h:
+ * platform/mac/ScrollingMomentumCalculatorMac.mm:
+ (WebCore::ScrollingMomentumCalculator::create):
+ (WebCore::ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac):
+ (WebCore::ScrollingMomentumCalculatorMac::ensurePlatformMomentumCalculator):
+
2021-09-20 Marcos Caceres <mar...@marcosc.com>
Web Share permission policy "web-share" and "self" as the allowlist
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.h (282748 => 282749)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -92,13 +92,12 @@
bool scrollPositionIsNotRubberbandingEdge(const FloatPoint&) const;
void scrollControllerAnimationTimerFired();
- FloatPoint scrollOffset() const override;
- void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
- float pageScaleFactor() const override;
+ FloatPoint scrollOffset() const final;
+ void immediateScrollOnAxis(ScrollEventAxis, float delta) final;
+ float pageScaleFactor() const final;
void willStartScrollSnapAnimation() final;
void didStopScrollSnapAnimation() final;
- LayoutSize scrollExtent() const override;
- FloatSize viewportSize() const override;
+ ScrollExtents scrollExtents() const final;
void releaseReferencesToScrollerImpsOnTheMainThread();
Modified: trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.mm (282748 => 282749)
--- trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.mm 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeScrollingNodeDelegateMac.mm 2021-09-20 16:01:49 UTC (rev 282749)
@@ -415,16 +415,14 @@
scrollingNode().setScrollSnapInProgress(false);
}
-LayoutSize ScrollingTreeScrollingNodeDelegateMac::scrollExtent() const
+ScrollExtents ScrollingTreeScrollingNodeDelegateMac::scrollExtents() const
{
- return LayoutSize(totalContentsSize());
+ return {
+ scrollingNode().totalContentsSize(),
+ scrollingNode().scrollableAreaSize()
+ };
}
-FloatSize ScrollingTreeScrollingNodeDelegateMac::viewportSize() const
-{
- return scrollableAreaSize();
-}
-
void ScrollingTreeScrollingNodeDelegateMac::deferWheelEventTestCompletionForReason(WheelEventTestMonitor::ScrollableAreaIdentifier identifier, WheelEventTestMonitor::DeferReason reason) const
{
if (!scrollingTree().isMonitoringWheelEvents())
Modified: trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeScrollingNodeDelegateNicosia.cpp (282748 => 282749)
--- trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeScrollingNodeDelegateNicosia.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/page/scrolling/nicosia/ScrollingTreeScrollingNodeDelegateNicosia.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -215,9 +215,8 @@
ScrollExtents ScrollingTreeScrollingNodeDelegateNicosia::scrollExtentsForAnimation(ScrollAnimation&)
{
return {
- IntPoint(minimumScrollPosition()),
- IntPoint(maximumScrollPosition()),
- IntSize(scrollableAreaSize())
+ scrollingNode().totalContentsSize(),
+ scrollingNode().scrollableAreaSize()
};
}
Modified: trunk/Source/WebCore/platform/ScrollAnimation.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollAnimation.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollAnimation.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -34,12 +34,6 @@
class FloatPoint;
class ScrollAnimation;
-struct ScrollExtents {
- ScrollOffset minimumScrollOffset;
- ScrollOffset maximumScrollOffset;
- IntSize visibleSize;
-};
-
class ScrollAnimationClient {
public:
virtual ~ScrollAnimationClient() = default;
Modified: trunk/Source/WebCore/platform/ScrollAnimationKinetic.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollAnimationKinetic.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollAnimationKinetic.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -199,15 +199,15 @@
};
if (mayHScroll) {
- m_horizontalData = PerAxisData(extents.minimumScrollOffset.x(),
- extents.maximumScrollOffset.x(),
+ m_horizontalData = PerAxisData(extents.minimumScrollOffset().x(),
+ extents.maximumScrollOffset().x(),
initialOffset.x(), accumulateVelocity(velocity.x(), m_horizontalData));
} else
m_horizontalData = std::nullopt;
if (mayVScroll) {
- m_verticalData = PerAxisData(extents.minimumScrollOffset.y(),
- extents.maximumScrollOffset.y(),
+ m_verticalData = PerAxisData(extents.minimumScrollOffset().y(),
+ extents.maximumScrollOffset().y(),
initialOffset.y(), accumulateVelocity(velocity.y(), m_verticalData));
} else
m_verticalData = std::nullopt;
Modified: trunk/Source/WebCore/platform/ScrollAnimationSmooth.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollAnimationSmooth.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollAnimationSmooth.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -93,7 +93,7 @@
bool ScrollAnimationSmooth::startOrRetargetAnimation(const ScrollExtents& extents, const FloatPoint& destinationOffset)
{
- m_destinationOffset = destinationOffset.constrainedBetween(extents.minimumScrollOffset, extents.maximumScrollOffset);
+ m_destinationOffset = destinationOffset.constrainedBetween(extents.minimumScrollOffset(), extents.maximumScrollOffset());
bool needToScroll = m_startOffset != m_destinationOffset;
if (needToScroll && !isActive()) {
@@ -113,7 +113,7 @@
{
auto extents = m_client.scrollExtentsForAnimation(*this);
// FIXME: Ideally fix up m_startOffset so m_currentOffset doesn't go backwards.
- m_destinationOffset = m_destinationOffset.constrainedBetween(extents.minimumScrollOffset, extents.maximumScrollOffset);
+ m_destinationOffset = m_destinationOffset.constrainedBetween(extents.minimumScrollOffset(), extents.maximumScrollOffset());
}
Seconds ScrollAnimationSmooth::durationFromDistance(const FloatSize& delta) const
Modified: trunk/Source/WebCore/platform/ScrollAnimator.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollAnimator.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollAnimator.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -288,16 +288,14 @@
scrollToPositionWithoutAnimation(currentPosition() + deltaSize);
}
-LayoutSize ScrollAnimator::scrollExtent() const
+ScrollExtents ScrollAnimator::scrollExtents() const
{
- return m_scrollableArea.contentsSize();
+ return {
+ m_scrollableArea.totalContentsSize(),
+ m_scrollableArea.visibleSize()
+ };
}
-FloatSize ScrollAnimator::viewportSize() const
-{
- return m_scrollableArea.visibleSize();
-}
-
float ScrollAnimator::pageScaleFactor() const
{
return m_scrollableArea.pageScaleFactor();
@@ -400,11 +398,7 @@
ScrollExtents ScrollAnimator::scrollExtentsForAnimation(ScrollAnimation&)
{
- return {
- m_scrollableArea.minimumScrollOffset(),
- m_scrollableArea.maximumScrollOffset(),
- m_scrollableArea.visibleSize()
- };
+ return scrollExtents();
}
Modified: trunk/Source/WebCore/platform/ScrollAnimator.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollAnimator.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollAnimator.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -135,8 +135,7 @@
FloatPoint scrollOffset() const override;
void immediateScrollOnAxis(ScrollEventAxis, float delta) override;
float pageScaleFactor() const override;
- LayoutSize scrollExtent() const override;
- FloatSize viewportSize() const override;
+ ScrollExtents scrollExtents() const override;
#if PLATFORM(MAC)
void deferWheelEventTestCompletionForReason(WheelEventTestMonitor::ScrollableAreaIdentifier, WheelEventTestMonitor::DeferReason) const override;
void removeWheelEventTestCompletionDeferralForReason(WheelEventTestMonitor::ScrollableAreaIdentifier, WheelEventTestMonitor::DeferReason) const override;
Modified: trunk/Source/WebCore/platform/ScrollSnapAnimatorState.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollSnapAnimatorState.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollSnapAnimatorState.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -31,28 +31,28 @@
namespace WebCore {
-void ScrollSnapAnimatorState::transitionToSnapAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset)
+void ScrollSnapAnimatorState::transitionToSnapAnimationState(const ScrollExtents& scrollExtents, float pageScale, const FloatPoint& initialOffset)
{
- setupAnimationForState(ScrollSnapState::Snapping, contentSize, viewportSize, pageScale, initialOffset, { }, { });
+ setupAnimationForState(ScrollSnapState::Snapping, scrollExtents, pageScale, initialOffset, { }, { });
}
-void ScrollSnapAnimatorState::transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
+void ScrollSnapAnimatorState::transitionToGlideAnimationState(const ScrollExtents& scrollExtents, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
{
- setupAnimationForState(ScrollSnapState::Gliding, contentSize, viewportSize, pageScale, initialOffset, initialVelocity, initialDelta);
+ setupAnimationForState(ScrollSnapState::Gliding, scrollExtents, pageScale, initialOffset, initialVelocity, initialDelta);
}
-void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
+void ScrollSnapAnimatorState::setupAnimationForState(ScrollSnapState state, const ScrollExtents& scrollExtents, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta)
{
ASSERT(state == ScrollSnapState::Snapping || state == ScrollSnapState::Gliding);
if (m_currentState == state)
return;
- m_momentumCalculator = ScrollingMomentumCalculator::create(viewportSize, contentSize, initialOffset, initialDelta, initialVelocity);
+ m_momentumCalculator = ScrollingMomentumCalculator::create(scrollExtents, initialOffset, initialDelta, initialVelocity);
FloatPoint predictedScrollTarget { m_momentumCalculator->predictedDestinationOffset() };
float targetOffsetX, targetOffsetY;
- std::tie(targetOffsetX, m_activeSnapIndexX) = targetOffsetForStartOffset(ScrollEventAxis::Horizontal, viewportSize, contentSize.width() - viewportSize.width(), initialOffset.x(), predictedScrollTarget, pageScale, initialDelta.width());
- std::tie(targetOffsetY, m_activeSnapIndexY) = targetOffsetForStartOffset(ScrollEventAxis::Vertical, viewportSize, contentSize.height() - viewportSize.height(), initialOffset.y(), predictedScrollTarget, pageScale, initialDelta.height());
+ std::tie(targetOffsetX, m_activeSnapIndexX) = targetOffsetForStartOffset(ScrollEventAxis::Horizontal, scrollExtents, initialOffset.x(), predictedScrollTarget, pageScale, initialDelta.width());
+ std::tie(targetOffsetY, m_activeSnapIndexY) = targetOffsetForStartOffset(ScrollEventAxis::Vertical, scrollExtents, initialOffset.y(), predictedScrollTarget, pageScale, initialDelta.height());
m_momentumCalculator->setRetargetedScrollOffset({ targetOffsetX, targetOffsetY });
m_startTime = MonotonicTime::now();
m_currentState = state;
@@ -91,15 +91,18 @@
return m_momentumCalculator->scrollOffsetAfterElapsedTime(elapsedTime);
}
-std::pair<float, std::optional<unsigned>> ScrollSnapAnimatorState::targetOffsetForStartOffset(ScrollEventAxis axis, const FloatSize& viewportSize, float maxScrollOffset, float startOffset, FloatPoint predictedOffset, float pageScale, float initialDelta) const
+std::pair<float, std::optional<unsigned>> ScrollSnapAnimatorState::targetOffsetForStartOffset(ScrollEventAxis axis, const ScrollExtents& scrollExtents, float startOffset, FloatPoint predictedOffset, float pageScale, float initialDelta) const
{
+ auto minScrollOffset = (axis == ScrollEventAxis::Horizontal) ? scrollExtents.minimumScrollOffset().x() : scrollExtents.minimumScrollOffset().y();
+ auto maxScrollOffset = (axis == ScrollEventAxis::Horizontal) ? scrollExtents.maximumScrollOffset().x() : scrollExtents.maximumScrollOffset().y();
+
const auto& snapOffsets = m_snapOffsetsInfo.offsetsForAxis(axis);
if (snapOffsets.isEmpty())
- return std::make_pair(clampTo<float>(axis == ScrollEventAxis::Horizontal ? predictedOffset.x() : predictedOffset.y(), 0, maxScrollOffset), std::nullopt);
+ return std::make_pair(clampTo<float>(axis == ScrollEventAxis::Horizontal ? predictedOffset.x() : predictedOffset.y(), minScrollOffset, maxScrollOffset), std::nullopt);
LayoutPoint predictedLayoutOffset(predictedOffset.x() / pageScale, predictedOffset.y() / pageScale);
- auto [targetOffset, snapIndex] = m_snapOffsetsInfo.closestSnapOffset(axis, LayoutSize { viewportSize }, predictedLayoutOffset, initialDelta, LayoutUnit(startOffset / pageScale));
- return std::make_pair(pageScale * clampTo<float>(float { targetOffset }, 0, maxScrollOffset), snapIndex);
+ auto [targetOffset, snapIndex] = m_snapOffsetsInfo.closestSnapOffset(axis, LayoutSize { scrollExtents.viewportSize }, predictedLayoutOffset, initialDelta, LayoutUnit(startOffset / pageScale));
+ return std::make_pair(pageScale * clampTo<float>(float { targetOffset }, minScrollOffset, maxScrollOffset), snapIndex);
}
TextStream& operator<<(TextStream& ts, const ScrollSnapAnimatorState& state)
Modified: trunk/Source/WebCore/platform/ScrollSnapAnimatorState.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollSnapAnimatorState.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollSnapAnimatorState.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -47,6 +47,8 @@
UserInteraction
};
+struct ScrollExtents;
+
class ScrollSnapAnimatorState {
WTF_MAKE_FAST_ALLOCATED;
public:
@@ -76,15 +78,15 @@
FloatPoint currentAnimatedScrollOffset(MonotonicTime, bool& isAnimationComplete) const;
// State transition helpers.
- void transitionToSnapAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset);
- void transitionToGlideAnimationState(const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
+ void transitionToSnapAnimationState(const ScrollExtents&, float pageScale, const FloatPoint& initialOffset);
+ void transitionToGlideAnimationState(const ScrollExtents&, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
void transitionToUserInteractionState();
void transitionToDestinationReachedState();
private:
- std::pair<float, std::optional<unsigned>> targetOffsetForStartOffset(ScrollEventAxis, const FloatSize& viewportSize, float maxScrollOffset, float startOffset, FloatPoint predictedOffset, float pageScale, float initialDelta) const;
+ std::pair<float, std::optional<unsigned>> targetOffsetForStartOffset(ScrollEventAxis, const ScrollExtents&, float startOffset, FloatPoint predictedOffset, float pageScale, float initialDelta) const;
void teardownAnimationForState(ScrollSnapState);
- void setupAnimationForState(ScrollSnapState, const FloatSize& contentSize, const FloatSize& viewportSize, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
+ void setupAnimationForState(ScrollSnapState, const ScrollExtents&, float pageScale, const FloatPoint& initialOffset, const FloatSize& initialVelocity, const FloatSize& initialDelta);
ScrollSnapState m_currentState { ScrollSnapState::UserInteraction };
Modified: trunk/Source/WebCore/platform/ScrollTypes.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollTypes.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollTypes.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -268,6 +268,14 @@
WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, ScrollClamping);
WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, ScrollBehaviorForFixedElements);
+struct ScrollExtents {
+ FloatSize contentsSize;
+ FloatSize viewportSize;
+
+ FloatPoint minimumScrollOffset() const { return { }; }
+ FloatPoint maximumScrollOffset() const { return toFloatPoint(contentsSize - viewportSize).expandedTo({ 0, 0 }); }
+};
+
struct ScrollPositionChangeOptions {
ScrollType type;
ScrollClamping clamping = ScrollClamping::Clamped;
Modified: trunk/Source/WebCore/platform/ScrollingEffectsController.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollingEffectsController.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollingEffectsController.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -158,7 +158,7 @@
ScrollSnapAnimatorState& snapState = *m_scrollSnapState;
auto snapOffsets = snapState.snapOffsetsForAxis(axis);
- LayoutSize viewportSize(m_client.viewportSize().width(), m_client.viewportSize().height());
+ LayoutSize viewportSize(m_client.scrollExtents().viewportSize);
std::optional<unsigned> activeIndex;
if (snapOffsets.size())
activeIndex = snapState.snapOffsetInfo().closestSnapOffset(axis, viewportSize, layoutScrollOffset, 0).second;
@@ -184,13 +184,12 @@
std::optional<LayoutUnit> originalOffsetInLayoutUnits;
if (originalOffset)
originalOffsetInLayoutUnits = LayoutUnit(*originalOffset / scaleFactor);
- LayoutSize viewportSize(m_client.viewportSize().width(), m_client.viewportSize().height());
+ LayoutSize viewportSize(m_client.scrollExtents().viewportSize);
LayoutPoint layoutDestinationOffset(destinationOffset.x() / scaleFactor, destinationOffset.y() / scaleFactor);
LayoutUnit offset = snapState.snapOffsetInfo().closestSnapOffset(axis, viewportSize, layoutDestinationOffset, velocity, originalOffsetInLayoutUnits).first;
return offset * scaleFactor;
}
-
void ScrollingEffectsController::updateActiveScrollSnapIndexForClientOffset()
{
if (!usesScrollSnap())
Modified: trunk/Source/WebCore/platform/ScrollingEffectsController.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollingEffectsController.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollingEffectsController.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -111,8 +111,7 @@
virtual void willStartScrollSnapAnimation() { }
virtual void didStopScrollSnapAnimation() { }
virtual float pageScaleFactor() const = 0;
- virtual LayoutSize scrollExtent() const = 0;
- virtual FloatSize viewportSize() const = 0;
+ virtual ScrollExtents scrollExtents() const = 0;
};
class ScrollingEffectsController {
Modified: trunk/Source/WebCore/platform/ScrollingMomentumCalculator.cpp (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollingMomentumCalculator.cpp 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollingMomentumCalculator.cpp 2021-09-20 16:01:49 UTC (rev 282749)
@@ -42,12 +42,11 @@
return inertialScrollPredictionFactor * initialWheelDelta;
}
-ScrollingMomentumCalculator::ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
+ScrollingMomentumCalculator::ScrollingMomentumCalculator(const ScrollExtents& scrollExtents, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
: m_initialDelta(initialDelta)
, m_initialVelocity(initialVelocity)
, m_initialScrollOffset(initialOffset)
- , m_viewportSize(viewportSize)
- , m_contentSize(contentSize)
+ , m_scrollExtents(scrollExtents)
{
}
@@ -62,16 +61,19 @@
FloatPoint ScrollingMomentumCalculator::predictedDestinationOffset()
{
- float initialOffsetX = clampTo<float>(m_initialScrollOffset.x() + projectedInertialScrollDistance(m_initialDelta.width()), 0, m_contentSize.width() - m_viewportSize.width());
- float initialOffsetY = clampTo<float>(m_initialScrollOffset.y() + projectedInertialScrollDistance(m_initialDelta.height()), 0, m_contentSize.height() - m_viewportSize.height());
+ auto minScrollOffset = m_scrollExtents.minimumScrollOffset();
+ auto maxScrollOffset = m_scrollExtents.maximumScrollOffset();
+
+ float initialOffsetX = clampTo<float>(m_initialScrollOffset.x() + projectedInertialScrollDistance(m_initialDelta.width()), minScrollOffset.x(), maxScrollOffset.x());
+ float initialOffsetY = clampTo<float>(m_initialScrollOffset.y() + projectedInertialScrollDistance(m_initialDelta.height()), minScrollOffset.y(), maxScrollOffset.y());
return { initialOffsetX, initialOffsetY };
}
#if !PLATFORM(MAC)
-std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
+std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const ScrollExtents& scrollExtents, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
{
- return makeUnique<BasicScrollingMomentumCalculator>(viewportSize, contentSize, initialOffset, initialDelta, initialVelocity);
+ return makeUnique<BasicScrollingMomentumCalculator>(scrollExtents, initialOffset, initialDelta, initialVelocity);
}
void ScrollingMomentumCalculator::setPlatformMomentumScrollingPredictionEnabled(bool)
@@ -80,8 +82,8 @@
#endif
-BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
- : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, initialDelta, initialVelocity)
+BasicScrollingMomentumCalculator::BasicScrollingMomentumCalculator(const ScrollExtents& scrollExtents, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
+ : ScrollingMomentumCalculator(scrollExtents, initialOffset, initialDelta, initialVelocity)
{
}
Modified: trunk/Source/WebCore/platform/ScrollingMomentumCalculator.h (282748 => 282749)
--- trunk/Source/WebCore/platform/ScrollingMomentumCalculator.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/ScrollingMomentumCalculator.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -39,9 +39,9 @@
public:
WEBCORE_EXPORT static void setPlatformMomentumScrollingPredictionEnabled(bool);
- static std::unique_ptr<ScrollingMomentumCalculator> create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
+ static std::unique_ptr<ScrollingMomentumCalculator> create(const ScrollExtents&, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
- ScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
+ ScrollingMomentumCalculator(const ScrollExtents&, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
virtual ~ScrollingMomentumCalculator() = default;
virtual FloatPoint scrollOffsetAfterElapsedTime(Seconds) = 0;
@@ -56,8 +56,7 @@
FloatSize m_initialDelta;
FloatSize m_initialVelocity;
FloatPoint m_initialScrollOffset;
- FloatSize m_viewportSize;
- FloatSize m_contentSize;
+ ScrollExtents m_scrollExtents;
private:
std::optional<FloatPoint> m_retargetedScrollOffset;
@@ -65,7 +64,7 @@
class BasicScrollingMomentumCalculator final : public ScrollingMomentumCalculator {
public:
- BasicScrollingMomentumCalculator(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
+ BasicScrollingMomentumCalculator(const ScrollExtents&, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
private:
FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
Modified: trunk/Source/WebCore/platform/mac/ScrollingEffectsController.mm (282748 => 282749)
--- trunk/Source/WebCore/platform/mac/ScrollingEffectsController.mm 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/mac/ScrollingEffectsController.mm 2021-09-20 16:01:49 UTC (rev 282749)
@@ -666,7 +666,7 @@
if (!usesScrollSnap())
return;
- m_scrollSnapState->transitionToSnapAnimationState(m_client.scrollExtent(), m_client.viewportSize(), m_client.pageScaleFactor(), m_client.scrollOffset());
+ m_scrollSnapState->transitionToSnapAnimationState(m_client.scrollExtents(), m_client.pageScaleFactor(), m_client.scrollOffset());
startScrollSnapAnimation();
}
@@ -701,11 +701,11 @@
m_dragEndedScrollingVelocity = -wheelEvent.scrollingVelocity();
break;
case WheelEventStatus::UserScrollEnd:
- m_scrollSnapState->transitionToSnapAnimationState(m_client.scrollExtent(), m_client.viewportSize(), m_client.pageScaleFactor(), m_client.scrollOffset());
+ m_scrollSnapState->transitionToSnapAnimationState(m_client.scrollExtents(), m_client.pageScaleFactor(), m_client.scrollOffset());
startScrollSnapAnimation();
break;
case WheelEventStatus::MomentumScrollBegin:
- m_scrollSnapState->transitionToGlideAnimationState(m_client.scrollExtent(), m_client.viewportSize(), m_client.pageScaleFactor(), m_client.scrollOffset(), m_dragEndedScrollingVelocity, FloatSize(-wheelEvent.deltaX(), -wheelEvent.deltaY()));
+ m_scrollSnapState->transitionToGlideAnimationState(m_client.scrollExtents(), m_client.pageScaleFactor(), m_client.scrollOffset(), m_dragEndedScrollingVelocity, FloatSize(-wheelEvent.deltaX(), -wheelEvent.deltaY()));
m_dragEndedScrollingVelocity = { };
isMomentumScrolling = true;
break;
Modified: trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.h (282748 => 282749)
--- trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.h 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.h 2021-09-20 16:01:49 UTC (rev 282749)
@@ -34,7 +34,7 @@
class ScrollingMomentumCalculatorMac final : public ScrollingMomentumCalculator {
public:
- ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
+ ScrollingMomentumCalculatorMac(const ScrollExtents&, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity);
private:
FloatPoint scrollOffsetAfterElapsedTime(Seconds) final;
Modified: trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.mm (282748 => 282749)
--- trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.mm 2021-09-20 15:04:35 UTC (rev 282748)
+++ trunk/Source/WebCore/platform/mac/ScrollingMomentumCalculatorMac.mm 2021-09-20 16:01:49 UTC (rev 282749)
@@ -34,9 +34,9 @@
static bool gEnablePlatformMomentumScrollingPrediction = true;
-std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
+std::unique_ptr<ScrollingMomentumCalculator> ScrollingMomentumCalculator::create(const ScrollExtents& scrollExtents, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
{
- return makeUnique<ScrollingMomentumCalculatorMac>(viewportSize, contentSize, initialOffset, initialDelta, initialVelocity);
+ return makeUnique<ScrollingMomentumCalculatorMac>(scrollExtents, initialOffset, initialDelta, initialVelocity);
}
void ScrollingMomentumCalculator::setPlatformMomentumScrollingPredictionEnabled(bool enabled)
@@ -44,8 +44,8 @@
gEnablePlatformMomentumScrollingPrediction = enabled;
}
-ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const FloatSize& viewportSize, const FloatSize& contentSize, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
- : ScrollingMomentumCalculator(viewportSize, contentSize, initialOffset, initialDelta, initialVelocity)
+ScrollingMomentumCalculatorMac::ScrollingMomentumCalculatorMac(const ScrollExtents& scrollExtents, const FloatPoint& initialOffset, const FloatSize& initialDelta, const FloatSize& initialVelocity)
+ : ScrollingMomentumCalculator(scrollExtents, initialOffset, initialDelta, initialVelocity)
{
}
@@ -94,9 +94,9 @@
return m_platformMomentumCalculator.get();
NSPoint origin = m_initialScrollOffset;
- NSRect contentFrame = NSMakeRect(0, 0, m_contentSize.width(), m_contentSize.height());
+ NSRect contentFrame = NSMakeRect(0, 0, m_scrollExtents.contentsSize.width(), m_scrollExtents.contentsSize.height());
NSPoint velocity = NSMakePoint(m_initialVelocity.width(), m_initialVelocity.height());
- m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:velocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_viewportSize tolerance:NSMakeSize(1, 1)]);
+ m_platformMomentumCalculator = adoptNS([[_NSScrollingMomentumCalculator alloc] initWithInitialOrigin:origin velocity:velocity documentFrame:contentFrame constrainedClippingOrigin:NSZeroPoint clippingSize:m_scrollExtents.viewportSize tolerance:NSMakeSize(1, 1)]);
m_initialDestinationOrigin = [m_platformMomentumCalculator destinationOrigin];
return m_platformMomentumCalculator.get();
}
