From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- gfx/layers/apz/src/AsyncPanZoomController.cpp | 4030 +++++++++++++++++++++++++ 1 file changed, 4030 insertions(+) create mode 100644 gfx/layers/apz/src/AsyncPanZoomController.cpp (limited to 'gfx/layers/apz/src/AsyncPanZoomController.cpp') diff --git a/gfx/layers/apz/src/AsyncPanZoomController.cpp b/gfx/layers/apz/src/AsyncPanZoomController.cpp new file mode 100644 index 0000000000..102f282f37 --- /dev/null +++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp @@ -0,0 +1,4030 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et tw=80 : */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include // for fabsf, fabs, atan2 +#include // for uint32_t, uint64_t +#include // for int32_t +#include // for max, min +#include "AsyncPanZoomController.h" // for AsyncPanZoomController, etc +#include "Axis.h" // for AxisX, AxisY, Axis, etc +#include "CheckerboardEvent.h" // for CheckerboardEvent +#include "Compositor.h" // for Compositor +#include "FrameMetrics.h" // for FrameMetrics, etc +#include "GenericFlingAnimation.h" // for GenericFlingAnimation +#include "GestureEventListener.h" // for GestureEventListener +#include "HitTestingTreeNode.h" // for HitTestingTreeNode +#include "InputData.h" // for MultiTouchInput, etc +#include "InputBlockState.h" // for InputBlockState, TouchBlockState +#include "InputQueue.h" // for InputQueue +#include "Overscroll.h" // for OverscrollAnimation +#include "OverscrollHandoffState.h" // for OverscrollHandoffState +#include "Units.h" // for CSSRect, CSSPoint, etc +#include "UnitTransforms.h" // for TransformTo +#include "base/message_loop.h" // for MessageLoop +#include "base/task.h" // for NewRunnableMethod, etc +#include "gfxPrefs.h" // for gfxPrefs +#include "gfxTypes.h" // for gfxFloat +#include "LayersLogging.h" // for print_stderr +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/BasicEvents.h" // for Modifiers, MODIFIER_* +#include "mozilla/ClearOnShutdown.h" // for ClearOnShutdown +#include "mozilla/ComputedTimingFunction.h" // for ComputedTimingFunction +#include "mozilla/EventForwards.h" // for nsEventStatus_* +#include "mozilla/MouseEvents.h" // for WidgetWheelEvent +#include "mozilla/Preferences.h" // for Preferences +#include "mozilla/ReentrantMonitor.h" // for ReentrantMonitorAutoEnter, etc +#include "mozilla/RefPtr.h" // for RefPtr +#include "mozilla/StaticPtr.h" // for StaticAutoPtr +#include "mozilla/Telemetry.h" // for Telemetry +#include "mozilla/TimeStamp.h" // for TimeDuration, TimeStamp +#include "mozilla/dom/CheckerboardReportService.h" // for CheckerboardEventStorage + // note: CheckerboardReportService.h actually lives in gfx/layers/apz/util/ +#include "mozilla/dom/Touch.h" // for Touch +#include "mozilla/gfx/BasePoint.h" // for BasePoint +#include "mozilla/gfx/BaseRect.h" // for BaseRect +#include "mozilla/gfx/Point.h" // for Point, RoundedToInt, etc +#include "mozilla/gfx/Rect.h" // for RoundedIn +#include "mozilla/gfx/ScaleFactor.h" // for ScaleFactor +#include "mozilla/layers/APZCTreeManager.h" // for ScrollableLayerGuid +#include "mozilla/layers/APZThreadUtils.h" // for AssertOnControllerThread, etc +#include "mozilla/layers/AsyncCompositionManager.h" // for ViewTransform +#include "mozilla/layers/AxisPhysicsModel.h" // for AxisPhysicsModel +#include "mozilla/layers/AxisPhysicsMSDModel.h" // for AxisPhysicsMSDModel +#include "mozilla/layers/CompositorController.h" // for CompositorController +#include "mozilla/layers/LayerTransactionParent.h" // for LayerTransactionParent +#include "mozilla/layers/MetricsSharingController.h" // for MetricsSharingController +#include "mozilla/layers/ScrollInputMethods.h" // for ScrollInputMethod +#include "mozilla/mozalloc.h" // for operator new, etc +#include "mozilla/Unused.h" // for unused +#include "mozilla/FloatingPoint.h" // for FuzzyEquals* +#include "nsAlgorithm.h" // for clamped +#include "nsCOMPtr.h" // for already_AddRefed +#include "nsDebug.h" // for NS_WARNING +#include "nsIDOMWindowUtils.h" // for nsIDOMWindowUtils +#include "nsMathUtils.h" // for NS_hypot +#include "nsPoint.h" // for nsIntPoint +#include "nsStyleConsts.h" +#include "nsStyleStruct.h" // for nsTimingFunction +#include "nsTArray.h" // for nsTArray, nsTArray_Impl, etc +#include "nsThreadUtils.h" // for NS_IsMainThread +#include "nsViewportInfo.h" // for kViewportMinScale, kViewportMaxScale +#include "prsystem.h" // for PR_GetPhysicalMemorySize +#include "SharedMemoryBasic.h" // for SharedMemoryBasic +#include "ScrollSnap.h" // for ScrollSnapUtils +#include "WheelScrollAnimation.h" +#if defined(MOZ_WIDGET_ANDROID) +#include "AndroidAPZ.h" +#endif // defined(MOZ_WIDGET_ANDROID) + +#define ENABLE_APZC_LOGGING 0 +// #define ENABLE_APZC_LOGGING 1 + +#if ENABLE_APZC_LOGGING +# define APZC_LOG(...) printf_stderr("APZC: " __VA_ARGS__) +# define APZC_LOG_FM(fm, prefix, ...) \ + { std::stringstream ss; \ + ss << nsPrintfCString(prefix, __VA_ARGS__).get(); \ + AppendToString(ss, fm, ":", "", true); \ + APZC_LOG("%s\n", ss.str().c_str()); \ + } +#else +# define APZC_LOG(...) +# define APZC_LOG_FM(fm, prefix, ...) +#endif + +namespace mozilla { +namespace layers { + +typedef mozilla::layers::AllowedTouchBehavior AllowedTouchBehavior; +typedef GeckoContentController::APZStateChange APZStateChange; +typedef GeckoContentController::TapType TapType; +typedef mozilla::gfx::Point Point; +typedef mozilla::gfx::Matrix4x4 Matrix4x4; +using mozilla::gfx::PointTyped; + +// Choose between platform-specific implementations. +#ifdef MOZ_WIDGET_ANDROID +typedef WidgetOverscrollEffect OverscrollEffect; +typedef AndroidSpecificState PlatformSpecificState; +typedef AndroidFlingAnimation FlingAnimation; +#else +typedef GenericOverscrollEffect OverscrollEffect; +typedef PlatformSpecificStateBase PlatformSpecificState; // no extra state, just use the base class +typedef GenericFlingAnimation FlingAnimation; +#endif + +/** + * \page APZCPrefs APZ preferences + * + * The following prefs are used to control the behaviour of the APZC. + * The default values are provided in gfxPrefs.h. + * + * \li\b apz.allow_checkerboarding + * Pref that allows or disallows checkerboarding + * + * \li\b apz.allow_immediate_handoff + * If set to true, scroll can be handed off from one APZC to another within + * a single input block. If set to false, a single input block can only + * scroll one APZC. + * + * \li\b apz.axis_lock.mode + * The preferred axis locking style. See AxisLockMode for possible values. + * + * \li\b apz.axis_lock.lock_angle + * Angle from axis within which we stay axis-locked.\n + * Units: radians + * + * \li\b apz.axis_lock.breakout_threshold + * Distance in inches the user must pan before axis lock can be broken.\n + * Units: (real-world, i.e. screen) inches + * + * \li\b apz.axis_lock.breakout_angle + * Angle at which axis lock can be broken.\n + * Units: radians + * + * \li\b apz.axis_lock.direct_pan_angle + * If the angle from an axis to the line drawn by a pan move is less than + * this value, we can assume that panning can be done in the allowed direction + * (horizontal or vertical).\n + * Currently used only for touch-action css property stuff and was addded to + * keep behaviour consistent with IE.\n + * Units: radians + * + * \li\b apz.content_response_timeout + * Amount of time before we timeout response from content. For example, if + * content is being unruly/slow and we don't get a response back within this + * time, we will just pretend that content did not preventDefault any touch + * events we dispatched to it.\n + * Units: milliseconds + * + * \li\b apz.danger_zone_x + * \li\b apz.danger_zone_y + * When drawing high-res tiles, we drop down to drawing low-res tiles + * when we know we can't keep up with the scrolling. The way we determine + * this is by checking if we are entering the "danger zone", which is the + * boundary of the painted content. For example, if the painted content + * goes from y=0...1000 and the visible portion is y=250...750 then + * we're far from checkerboarding. If we get to y=490...990 though then we're + * only 10 pixels away from showing checkerboarding so we are probably in + * a state where we can't keep up with scrolling. The danger zone prefs specify + * how wide this margin is; in the above example a y-axis danger zone of 10 + * pixels would make us drop to low-res at y=490...990.\n + * This value is in layer pixels. + * + * \li\b apz.disable_for_scroll_linked_effects + * Setting this pref to true will disable APZ scrolling on documents where + * scroll-linked effects are detected. A scroll linked effect is detected if + * positioning or transform properties are updated inside a scroll event + * dispatch; we assume that such an update is in response to the scroll event + * and is therefore a scroll-linked effect which will be laggy with APZ + * scrolling. + * + * \li\b apz.displayport_expiry_ms + * While a scrollable frame is scrolling async, we set a displayport on it + * to make sure it is layerized. However this takes up memory, so once the + * scrolling stops we want to remove the displayport. This pref controls how + * long after scrolling stops the displayport is removed. A value of 0 will + * disable the expiry behavior entirely. + * Units: milliseconds + * + * \li\b apz.enlarge_displayport_when_clipped + * Pref that enables enlarging of the displayport along one axis when the + * generated displayport's size is beyond that of the scrollable rect on the + * opposite axis. + * + * \li\b apz.fling_accel_interval_ms + * The time that determines whether a second fling will be treated as + * accelerated. If two flings are started within this interval, the second one + * will be accelerated. Setting an interval of 0 means that acceleration will + * be disabled.\n + * Units: milliseconds + * + * \li\b apz.fling_accel_min_velocity + * The minimum velocity of the second fling for it to be considered for fling + * acceleration. + * Units: screen pixels per milliseconds + * + * \li\b apz.fling_accel_base_mult + * \li\b apz.fling_accel_supplemental_mult + * When applying an acceleration on a fling, the new computed velocity is + * (new_fling_velocity * base_mult) + (old_velocity * supplemental_mult). + * The base_mult and supplemental_mult multiplier values are controlled by + * these prefs. Note that "old_velocity" here is the initial velocity of the + * previous fling _after_ acceleration was applied to it (if applicable). + * + * \li\b apz.fling_curve_function_x1 + * \li\b apz.fling_curve_function_y1 + * \li\b apz.fling_curve_function_x2 + * \li\b apz.fling_curve_function_y2 + * \li\b apz.fling_curve_threshold_inches_per_ms + * These five parameters define a Bezier curve function and threshold used to + * increase the actual velocity relative to the user's finger velocity. When the + * finger velocity is below the threshold (or if the threshold is not positive), + * the velocity is used as-is. If the finger velocity exceeds the threshold + * velocity, then the function defined by the curve is applied on the part of + * the velocity that exceeds the threshold. Note that the upper bound of the + * velocity is still specified by the \b apz.max_velocity_inches_per_ms pref, and + * the function will smoothly curve the velocity from the threshold to the + * max. In general the function parameters chosen should define an ease-out + * curve in order to increase the velocity in this range, or an ease-in curve to + * decrease the velocity. A straight-line curve is equivalent to disabling the + * curve entirely by setting the threshold to -1. The max velocity pref must + * also be set in order for the curving to take effect, as it defines the upper + * bound of the velocity curve.\n + * The points (x1, y1) and (x2, y2) used as the two intermediate control points + * in the cubic bezier curve; the first and last points are (0,0) and (1,1).\n + * Some example values for these prefs can be found at\n + * https://dxr.mozilla.org/mozilla-central/rev/70e05c6832e831374604ac3ce7433971368dffe0/layout/style/nsStyleStruct.cpp#2729 + * + * \li\b apz.fling_friction + * Amount of friction applied during flings. This is used in the following + * formula: v(t1) = v(t0) * (1 - f)^(t1 - t0), where v(t1) is the velocity + * for a new sample, v(t0) is the velocity at the previous sample, f is the + * value of this pref, and (t1 - t0) is the amount of time, in milliseconds, + * that has elapsed between the two samples.\n + * NOTE: Not currently used in Android fling calculations. + * + * \li\b apz.fling_min_velocity_threshold + * Minimum velocity for a fling to actually kick off. If the user pans and lifts + * their finger such that the velocity is smaller than this amount, no fling + * is initiated.\n + * Units: screen pixels per millisecond + * + * \li\b apz.fling_stop_on_tap_threshold + * When flinging, if the velocity is above this number, then a tap on the + * screen will stop the fling without dispatching a tap to content. If the + * velocity is below this threshold a tap will also be dispatched. + * Note: when modifying this pref be sure to run the APZC gtests as some of + * them depend on the value of this pref.\n + * Units: screen pixels per millisecond + * + * \li\b apz.fling_stopped_threshold + * When flinging, if the velocity goes below this number, we just stop the + * animation completely. This is to prevent asymptotically approaching 0 + * velocity and rerendering unnecessarily.\n + * Units: screen pixels per millisecond.\n + * NOTE: Should not be set to anything + * other than 0.0 for Android except for tests to disable flings. + * + * \li\b apz.max_velocity_inches_per_ms + * Maximum velocity. Velocity will be capped at this value if a faster fling + * occurs. Negative values indicate unlimited velocity.\n + * Units: (real-world, i.e. screen) inches per millisecond + * + * \li\b apz.max_velocity_queue_size + * Maximum size of velocity queue. The queue contains last N velocity records. + * On touch end we calculate the average velocity in order to compensate + * touch/mouse drivers misbehaviour. + * + * \li\b apz.min_skate_speed + * Minimum amount of speed along an axis before we switch to "skate" multipliers + * rather than using the "stationary" multipliers.\n + * Units: CSS pixels per millisecond + * + * \li\b apz.overscroll.enabled + * Pref that enables overscrolling. If this is disabled, excess scroll that + * cannot be handed off is discarded. + * + * \li\b apz.overscroll.min_pan_distance_ratio + * The minimum ratio of the pan distance along one axis to the pan distance + * along the other axis needed to initiate overscroll along the first axis + * during panning. + * + * \li\b apz.overscroll.stretch_factor + * How much overscrolling can stretch content along an axis. + * The maximum stretch along an axis is a factor of (1 + kStretchFactor). + * (So if kStretchFactor is 0, you can't stretch at all; if kStretchFactor + * is 1, you can stretch at most by a factor of 2). + * + * \li\b apz.overscroll.spring_stiffness + * The stiffness of the spring used in the physics model for the overscroll + * animation. + * + * \li\b apz.overscroll.spring_friction + * The friction of the spring used in the physics model for the overscroll + * animation. + * Even though a realistic physics model would dictate that this be the same + * as \b apz.fling_friction, we allow it to be set to be something different, + * because in practice we want flings to skate smoothly (low friction), while + * we want the overscroll bounce-back to oscillate few times (high friction). + * + * \li\b apz.overscroll.stop_distance_threshold + * \li\b apz.overscroll.stop_velocity_threshold + * Thresholds for stopping the overscroll animation. When both the distance + * and the velocity fall below their thresholds, we stop oscillating.\n + * Units: screen pixels (for distance) + * screen pixels per millisecond (for velocity) + * + * \li\b apz.paint_skipping.enabled + * When APZ is scrolling and sending repaint requests to the main thread, often + * the main thread doesn't actually need to do a repaint. This pref allows the + * main thread to skip doing those repaints in cases where it doesn't need to. + * + * \li\b apz.record_checkerboarding + * Whether or not to record detailed info on checkerboarding events. + * + * \li\b apz.test.logging_enabled + * Enable logging of APZ test data (see bug 961289). + * + * \li\b apz.touch_move_tolerance + * See the description for apz.touch_start_tolerance below. This is a similar + * threshold, except it is used to suppress touchmove events from being delivered + * to content for NON-scrollable frames (or more precisely, for APZCs where + * ArePointerEventsConsumable returns false).\n + * Units: (real-world, i.e. screen) inches + * + * \li\b apz.touch_start_tolerance + * Constant describing the tolerance in distance we use, multiplied by the + * device DPI, before we start panning the screen. This is to prevent us from + * accidentally processing taps as touch moves, and from very short/accidental + * touches moving the screen. touchmove events are also not delivered to content + * within this distance on scrollable frames.\n + * Units: (real-world, i.e. screen) inches + * + * \li\b apz.velocity_bias + * How much to adjust the displayport in the direction of scrolling. This value + * is multiplied by the velocity and added to the displayport offset. + * + * \li\b apz.velocity_relevance_time_ms + * When computing a fling velocity from the most recently stored velocity + * information, only velocities within the most X milliseconds are used. + * This pref controls the value of X.\n + * Units: ms + * + * \li\b apz.x_skate_size_multiplier + * \li\b apz.y_skate_size_multiplier + * The multiplier we apply to the displayport size if it is skating (current + * velocity is above \b apz.min_skate_speed). We prefer to increase the size of + * the Y axis because it is more natural in the case that a user is reading a + * page page that scrolls up/down. Note that one, both or neither of these may be + * used at any instant.\n + * In general we want \b apz.[xy]_skate_size_multiplier to be smaller than the corresponding + * stationary size multiplier because when panning fast we would like to paint + * less and get faster, more predictable paint times. When panning slowly we + * can afford to paint more even though it's slower. + * + * \li\b apz.x_stationary_size_multiplier + * \li\b apz.y_stationary_size_multiplier + * The multiplier we apply to the displayport size if it is not skating (see + * documentation for the skate size multipliers above). + * + * \li\b apz.x_skate_highmem_adjust + * \li\b apz.y_skate_highmem_adjust + * On high memory systems, we adjust the displayport during skating + * to be larger so we can reduce checkerboarding. + * + * \li\b apz.zoom_animation_duration_ms + * This controls how long the zoom-to-rect animation takes.\n + * Units: ms + * + * \li\b apz.scale_repaint_delay_ms + * How long to delay between repaint requests during a scale. + * A negative number prevents repaint requests during a scale.\n + * Units: ms + * + */ + +/** + * Computed time function used for sampling frames of a zoom to animation. + */ +StaticAutoPtr gZoomAnimationFunction; + +/** + * Computed time function used for curving up velocity when it gets high. + */ +StaticAutoPtr gVelocityCurveFunction; + +/** + * The estimated duration of a paint for the purposes of calculating a new + * displayport, in milliseconds. + */ +static const double kDefaultEstimatedPaintDurationMs = 50; + +/** + * Returns true if this is a high memory system and we can use + * extra memory for a larger displayport to reduce checkerboarding. + */ +static bool gIsHighMemSystem = false; +static bool IsHighMemSystem() +{ + return gIsHighMemSystem; +} + +/** + * Is aAngle within the given threshold of the horizontal axis? + * @param aAngle an angle in radians in the range [0, pi] + * @param aThreshold an angle in radians in the range [0, pi/2] + */ +static bool IsCloseToHorizontal(float aAngle, float aThreshold) +{ + return (aAngle < aThreshold || aAngle > (M_PI - aThreshold)); +} + +// As above, but for the vertical axis. +static bool IsCloseToVertical(float aAngle, float aThreshold) +{ + return (fabs(aAngle - (M_PI / 2)) < aThreshold); +} + +// Counter used to give each APZC a unique id +static uint32_t sAsyncPanZoomControllerCount = 0; + +TimeStamp +AsyncPanZoomController::GetFrameTime() const +{ + APZCTreeManager* treeManagerLocal = GetApzcTreeManager(); + return treeManagerLocal ? treeManagerLocal->GetFrameTime() : TimeStamp::Now(); +} + +class MOZ_STACK_CLASS StateChangeNotificationBlocker { +public: + explicit StateChangeNotificationBlocker(AsyncPanZoomController* aApzc) + : mApzc(aApzc) + { + ReentrantMonitorAutoEnter lock(mApzc->mMonitor); + mInitialState = mApzc->mState; + mApzc->mNotificationBlockers++; + } + + ~StateChangeNotificationBlocker() + { + AsyncPanZoomController::PanZoomState newState; + { + ReentrantMonitorAutoEnter lock(mApzc->mMonitor); + mApzc->mNotificationBlockers--; + newState = mApzc->mState; + } + mApzc->DispatchStateChangeNotification(mInitialState, newState); + } + +private: + AsyncPanZoomController* mApzc; + AsyncPanZoomController::PanZoomState mInitialState; +}; + +class ZoomAnimation: public AsyncPanZoomAnimation { +public: + ZoomAnimation(CSSPoint aStartOffset, CSSToParentLayerScale2D aStartZoom, + CSSPoint aEndOffset, CSSToParentLayerScale2D aEndZoom) + : mTotalDuration(TimeDuration::FromMilliseconds(gfxPrefs::APZZoomAnimationDuration())) + , mStartOffset(aStartOffset) + , mStartZoom(aStartZoom) + , mEndOffset(aEndOffset) + , mEndZoom(aEndZoom) + {} + + virtual bool DoSample(FrameMetrics& aFrameMetrics, + const TimeDuration& aDelta) override + { + mDuration += aDelta; + double animPosition = mDuration / mTotalDuration; + + if (animPosition >= 1.0) { + aFrameMetrics.SetZoom(mEndZoom); + aFrameMetrics.SetScrollOffset(mEndOffset); + return false; + } + + // Sample the zoom at the current time point. The sampled zoom + // will affect the final computed resolution. + float sampledPosition = + gZoomAnimationFunction->GetValue(animPosition, + ComputedTimingFunction::BeforeFlag::Unset); + + // We scale the scrollOffset linearly with sampledPosition, so the zoom + // needs to scale inversely to match. + aFrameMetrics.SetZoom(CSSToParentLayerScale2D( + 1 / (sampledPosition / mEndZoom.xScale + (1 - sampledPosition) / mStartZoom.xScale), + 1 / (sampledPosition / mEndZoom.yScale + (1 - sampledPosition) / mStartZoom.yScale))); + + aFrameMetrics.SetScrollOffset(CSSPoint::FromUnknownPoint(gfx::Point( + mEndOffset.x * sampledPosition + mStartOffset.x * (1 - sampledPosition), + mEndOffset.y * sampledPosition + mStartOffset.y * (1 - sampledPosition) + ))); + + return true; + } + + virtual bool WantsRepaints() override + { + return false; + } + +private: + TimeDuration mDuration; + const TimeDuration mTotalDuration; + + // Old metrics from before we started a zoom animation. This is only valid + // when we are in the "ANIMATED_ZOOM" state. This is used so that we can + // interpolate between the start and end frames. We only use the + // |mViewportScrollOffset| and |mResolution| fields on this. + CSSPoint mStartOffset; + CSSToParentLayerScale2D mStartZoom; + + // Target metrics for a zoom to animation. This is only valid when we are in + // the "ANIMATED_ZOOM" state. We only use the |mViewportScrollOffset| and + // |mResolution| fields on this. + CSSPoint mEndOffset; + CSSToParentLayerScale2D mEndZoom; +}; + + +class SmoothScrollAnimation : public AsyncPanZoomAnimation { +public: + SmoothScrollAnimation(AsyncPanZoomController& aApzc, + const nsPoint &aInitialPosition, + const nsPoint &aInitialVelocity, + const nsPoint& aDestination, double aSpringConstant, + double aDampingRatio) + : mApzc(aApzc) + , mXAxisModel(aInitialPosition.x, aDestination.x, aInitialVelocity.x, + aSpringConstant, aDampingRatio) + , mYAxisModel(aInitialPosition.y, aDestination.y, aInitialVelocity.y, + aSpringConstant, aDampingRatio) + { + } + + /** + * Advances a smooth scroll simulation based on the time passed in |aDelta|. + * This should be called whenever sampling the content transform for this + * frame. Returns true if the smooth scroll should be advanced by one frame, + * or false if the smooth scroll has ended. + */ + bool DoSample(FrameMetrics& aFrameMetrics, const TimeDuration& aDelta) override { + nsPoint oneParentLayerPixel = + CSSPoint::ToAppUnits(ParentLayerPoint(1, 1) / aFrameMetrics.GetZoom()); + if (mXAxisModel.IsFinished(oneParentLayerPixel.x) && + mYAxisModel.IsFinished(oneParentLayerPixel.y)) { + // Set the scroll offset to the exact destination. If we allow the scroll + // offset to end up being a bit off from the destination, we can get + // artefacts like "scroll to the next snap point in this direction" + // scrolling to the snap point we're already supposed to be at. + aFrameMetrics.SetScrollOffset( + aFrameMetrics.CalculateScrollRange().ClampPoint( + CSSPoint::FromAppUnits(nsPoint(mXAxisModel.GetDestination(), + mYAxisModel.GetDestination())))); + return false; + } + + mXAxisModel.Simulate(aDelta); + mYAxisModel.Simulate(aDelta); + + CSSPoint position = CSSPoint::FromAppUnits(nsPoint(mXAxisModel.GetPosition(), + mYAxisModel.GetPosition())); + CSSPoint css_velocity = CSSPoint::FromAppUnits(nsPoint(mXAxisModel.GetVelocity(), + mYAxisModel.GetVelocity())); + + // Convert from points/second to points/ms + ParentLayerPoint velocity = ParentLayerPoint(css_velocity.x, css_velocity.y) / 1000.0f; + + // Keep the velocity updated for the Axis class so that any animations + // chained off of the smooth scroll will inherit it. + if (mXAxisModel.IsFinished(oneParentLayerPixel.x)) { + mApzc.mX.SetVelocity(0); + } else { + mApzc.mX.SetVelocity(velocity.x); + } + if (mYAxisModel.IsFinished(oneParentLayerPixel.y)) { + mApzc.mY.SetVelocity(0); + } else { + mApzc.mY.SetVelocity(velocity.y); + } + // If we overscroll, hand off to a fling animation that will complete the + // spring back. + CSSToParentLayerScale2D zoom = aFrameMetrics.GetZoom(); + ParentLayerPoint displacement = (position - aFrameMetrics.GetScrollOffset()) * zoom; + + ParentLayerPoint overscroll; + ParentLayerPoint adjustedOffset; + mApzc.mX.AdjustDisplacement(displacement.x, adjustedOffset.x, overscroll.x); + mApzc.mY.AdjustDisplacement(displacement.y, adjustedOffset.y, overscroll.y); + + aFrameMetrics.ScrollBy(adjustedOffset / zoom); + + // The smooth scroll may have caused us to reach the end of our scroll range. + // This can happen if either the layout.css.scroll-behavior.damping-ratio + // preference is set to less than 1 (underdamped) or if a smooth scroll + // inherits velocity from a fling gesture. + if (!IsZero(overscroll)) { + // Hand off a fling with the remaining momentum to the next APZC in the + // overscroll handoff chain. + + // We may have reached the end of the scroll range along one axis but + // not the other. In such a case we only want to hand off the relevant + // component of the fling. + if (FuzzyEqualsAdditive(overscroll.x, 0.0f, COORDINATE_EPSILON)) { + velocity.x = 0; + } else if (FuzzyEqualsAdditive(overscroll.y, 0.0f, COORDINATE_EPSILON)) { + velocity.y = 0; + } + + // To hand off the fling, we attempt to find a target APZC and start a new + // fling with the same velocity on that APZC. For simplicity, the actual + // overscroll of the current sample is discarded rather than being handed + // off. The compositor should sample animations sufficiently frequently + // that this is not noticeable. The target APZC is chosen by seeing if + // there is an APZC further in the handoff chain which is pannable; if + // there isn't, we take the new fling ourselves, entering an overscrolled + // state. + // Note: APZC is holding mMonitor, so directly calling + // HandleSmoothScrollOverscroll() (which acquires the tree lock) would violate + // the lock ordering. Instead we schedule HandleSmoothScrollOverscroll() to be + // called after mMonitor is released. + mDeferredTasks.AppendElement( + NewRunnableMethod(&mApzc, + &AsyncPanZoomController::HandleSmoothScrollOverscroll, + velocity)); + return false; + } + + return true; + } + + void SetDestination(const nsPoint& aNewDestination) { + mXAxisModel.SetDestination(static_cast(aNewDestination.x)); + mYAxisModel.SetDestination(static_cast(aNewDestination.y)); + } + + CSSPoint GetDestination() const { + return CSSPoint::FromAppUnits( + nsPoint(mXAxisModel.GetDestination(), mYAxisModel.GetDestination())); + } + + SmoothScrollAnimation* AsSmoothScrollAnimation() override { + return this; + } + +private: + AsyncPanZoomController& mApzc; + AxisPhysicsMSDModel mXAxisModel, mYAxisModel; +}; + +/*static*/ void +AsyncPanZoomController::InitializeGlobalState() +{ + static bool sInitialized = false; + if (sInitialized) + return; + sInitialized = true; + + MOZ_ASSERT(NS_IsMainThread()); + + gZoomAnimationFunction = new ComputedTimingFunction(); + gZoomAnimationFunction->Init( + nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE)); + ClearOnShutdown(&gZoomAnimationFunction); + gVelocityCurveFunction = new ComputedTimingFunction(); + gVelocityCurveFunction->Init( + nsTimingFunction(gfxPrefs::APZCurveFunctionX1(), + gfxPrefs::APZCurveFunctionY2(), + gfxPrefs::APZCurveFunctionX2(), + gfxPrefs::APZCurveFunctionY2())); + ClearOnShutdown(&gVelocityCurveFunction); + + uint64_t sysmem = PR_GetPhysicalMemorySize(); + uint64_t threshold = 1LL << 32; // 4 GB in bytes + gIsHighMemSystem = sysmem >= threshold; +} + +AsyncPanZoomController::AsyncPanZoomController(uint64_t aLayersId, + APZCTreeManager* aTreeManager, + const RefPtr& aInputQueue, + GeckoContentController* aGeckoContentController, + GestureBehavior aGestures) + : mLayersId(aLayersId), + mGeckoContentController(aGeckoContentController), + mRefPtrMonitor("RefPtrMonitor"), + // mTreeManager must be initialized before GetFrameTime() is called + mTreeManager(aTreeManager), + mFrameMetrics(mScrollMetadata.GetMetrics()), + mMonitor("AsyncPanZoomController"), + mLastContentPaintMetrics(mLastContentPaintMetadata.GetMetrics()), + mX(this), + mY(this), + mPanDirRestricted(false), + mZoomConstraints(false, false, + mFrameMetrics.GetDevPixelsPerCSSPixel() * kViewportMinScale / ParentLayerToScreenScale(1), + mFrameMetrics.GetDevPixelsPerCSSPixel() * kViewportMaxScale / ParentLayerToScreenScale(1)), + mLastSampleTime(GetFrameTime()), + mLastCheckerboardReport(GetFrameTime()), + mOverscrollEffect(MakeUnique(*this)), + mState(NOTHING), + mNotificationBlockers(0), + mInputQueue(aInputQueue), + mPinchPaintTimerSet(false), + mAPZCId(sAsyncPanZoomControllerCount++), + mSharedLock(nullptr), + mAsyncTransformAppliedToContent(false), + mCheckerboardEventLock("APZCBELock") +{ + if (aGestures == USE_GESTURE_DETECTOR) { + mGestureEventListener = new GestureEventListener(this); + } +} + +AsyncPanZoomController::~AsyncPanZoomController() +{ + MOZ_ASSERT(IsDestroyed()); +} + +PlatformSpecificStateBase* +AsyncPanZoomController::GetPlatformSpecificState() +{ + if (!mPlatformSpecificState) { + mPlatformSpecificState = MakeUnique(); + } + return mPlatformSpecificState.get(); +} + +already_AddRefed +AsyncPanZoomController::GetGeckoContentController() const { + MonitorAutoLock lock(mRefPtrMonitor); + RefPtr controller = mGeckoContentController; + return controller.forget(); +} + +already_AddRefed +AsyncPanZoomController::GetGestureEventListener() const { + MonitorAutoLock lock(mRefPtrMonitor); + RefPtr listener = mGestureEventListener; + return listener.forget(); +} + +const RefPtr& +AsyncPanZoomController::GetInputQueue() const { + return mInputQueue; +} + +void +AsyncPanZoomController::Destroy() +{ + APZThreadUtils::AssertOnCompositorThread(); + + CancelAnimation(CancelAnimationFlags::ScrollSnap); + + { // scope the lock + MonitorAutoLock lock(mRefPtrMonitor); + mGeckoContentController = nullptr; + mGestureEventListener = nullptr; + } + mParent = nullptr; + mTreeManager = nullptr; + + // Only send the release message if the SharedFrameMetrics has been created. + if (mMetricsSharingController && mSharedFrameMetricsBuffer) { + Unused << mMetricsSharingController->StopSharingMetrics(mFrameMetrics.GetScrollId(), mAPZCId); + } + + { // scope the lock + ReentrantMonitorAutoEnter lock(mMonitor); + mSharedFrameMetricsBuffer = nullptr; + delete mSharedLock; + mSharedLock = nullptr; + } +} + +bool +AsyncPanZoomController::IsDestroyed() const +{ + return mTreeManager == nullptr; +} + +/* static */ScreenCoord +AsyncPanZoomController::GetTouchStartTolerance() +{ + return (gfxPrefs::APZTouchStartTolerance() * APZCTreeManager::GetDPI()); +} + +/* static */AsyncPanZoomController::AxisLockMode AsyncPanZoomController::GetAxisLockMode() +{ + return static_cast(gfxPrefs::APZAxisLockMode()); +} + +bool +AsyncPanZoomController::ArePointerEventsConsumable(TouchBlockState* aBlock, uint32_t aTouchPoints) { + if (aTouchPoints == 0) { + // Cant' do anything with zero touch points + return false; + } + + // This logic is simplified, erring on the side of returning true + // if we're not sure. It's safer to pretend that we can consume the + // event and then not be able to than vice-versa. + // We could probably enhance this logic to determine things like "we're + // not pannable, so we can only zoom in, and the zoom is already maxed + // out, so we're not zoomable either" but no need for that at this point. + + bool pannable = aBlock->GetOverscrollHandoffChain()->CanBePanned(this); + bool zoomable = mZoomConstraints.mAllowZoom; + + pannable &= (aBlock->TouchActionAllowsPanningX() || aBlock->TouchActionAllowsPanningY()); + zoomable &= (aBlock->TouchActionAllowsPinchZoom()); + + // XXX once we fix bug 1031443, consumable should be assigned + // pannable || zoomable if aTouchPoints > 1. + bool consumable = (aTouchPoints == 1 ? pannable : zoomable); + if (!consumable) { + return false; + } + + return true; +} + +template +static CoordTyped GetAxisStart(AsyncDragMetrics::DragDirection aDir, const PointTyped& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.x; + } else { + return aValue.y; + } +} + +template +static CoordTyped GetAxisStart(AsyncDragMetrics::DragDirection aDir, const RectTyped& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.x; + } else { + return aValue.y; + } +} + +template +static IntCoordTyped GetAxisStart(AsyncDragMetrics::DragDirection aDir, const IntRectTyped& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.x; + } else { + return aValue.y; + } +} + +template +static IntCoordTyped GetAxisEnd(AsyncDragMetrics::DragDirection aDir, const IntRectTyped& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.x + aValue.width; + } else { + return aValue.y + aValue.height; + } +} + +template +static CoordTyped GetAxisSize(AsyncDragMetrics::DragDirection aDir, const RectTyped& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.width; + } else { + return aValue.height; + } +} + +template +static float GetAxisScale(AsyncDragMetrics::DragDirection aDir, const ScaleFactors2D& aValue) { + if (aDir == AsyncDragMetrics::HORIZONTAL) { + return aValue.xScale; + } else { + return aValue.yScale; + } +} + +nsEventStatus AsyncPanZoomController::HandleDragEvent(const MouseInput& aEvent, + const AsyncDragMetrics& aDragMetrics) +{ + if (!gfxPrefs::APZDragEnabled()) { + return nsEventStatus_eIgnore; + } + + if (!GetApzcTreeManager()) { + return nsEventStatus_eConsumeNoDefault; + } + + RefPtr node = + GetApzcTreeManager()->FindScrollNode(aDragMetrics); + if (!node) { + return nsEventStatus_eConsumeNoDefault; + } + + mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, + (uint32_t) ScrollInputMethod::ApzScrollbarDrag); + + ReentrantMonitorAutoEnter lock(mMonitor); + CSSPoint scrollFramePoint = aEvent.mLocalOrigin / GetFrameMetrics().GetZoom(); + // The scrollbar can be transformed with the frame but the pres shell + // resolution is only applied to the scroll frame. + CSSPoint scrollbarPoint = scrollFramePoint * mFrameMetrics.GetPresShellResolution(); + CSSRect cssCompositionBound = mFrameMetrics.CalculateCompositedRectInCssPixels(); + + CSSCoord mousePosition = GetAxisStart(aDragMetrics.mDirection, scrollbarPoint) - + CSSCoord(aDragMetrics.mScrollbarDragOffset) - + GetAxisStart(aDragMetrics.mDirection, cssCompositionBound) - + CSSCoord(GetAxisStart(aDragMetrics.mDirection, aDragMetrics.mScrollTrack)); + + CSSCoord scrollMax = CSSCoord(GetAxisEnd(aDragMetrics.mDirection, aDragMetrics.mScrollTrack)); + scrollMax -= node->GetScrollSize() / + GetAxisScale(aDragMetrics.mDirection, mFrameMetrics.GetZoom()) * + mFrameMetrics.GetPresShellResolution(); + + float scrollPercent = mousePosition / scrollMax; + + CSSCoord minScrollPosition = + GetAxisStart(aDragMetrics.mDirection, mFrameMetrics.GetScrollableRect().TopLeft()); + CSSCoord maxScrollPosition = + GetAxisSize(aDragMetrics.mDirection, mFrameMetrics.GetScrollableRect()) - + GetAxisSize(aDragMetrics.mDirection, cssCompositionBound); + CSSCoord scrollPosition = scrollPercent * maxScrollPosition; + + scrollPosition = std::max(scrollPosition, minScrollPosition); + scrollPosition = std::min(scrollPosition, maxScrollPosition); + + CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset(); + if (aDragMetrics.mDirection == AsyncDragMetrics::HORIZONTAL) { + scrollOffset.x = scrollPosition; + } else { + scrollOffset.y = scrollPosition; + } + mFrameMetrics.SetScrollOffset(scrollOffset); + ScheduleCompositeAndMaybeRepaint(); + UpdateSharedCompositorFrameMetrics(); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::HandleInputEvent(const InputData& aEvent, + const ScreenToParentLayerMatrix4x4& aTransformToApzc) { + APZThreadUtils::AssertOnControllerThread(); + + nsEventStatus rv = nsEventStatus_eIgnore; + + switch (aEvent.mInputType) { + case MULTITOUCH_INPUT: { + MultiTouchInput multiTouchInput = aEvent.AsMultiTouchInput(); + if (!multiTouchInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + RefPtr listener = GetGestureEventListener(); + if (listener) { + rv = listener->HandleInputEvent(multiTouchInput); + if (rv == nsEventStatus_eConsumeNoDefault) { + return rv; + } + } + + switch (multiTouchInput.mType) { + case MultiTouchInput::MULTITOUCH_START: rv = OnTouchStart(multiTouchInput); break; + case MultiTouchInput::MULTITOUCH_MOVE: rv = OnTouchMove(multiTouchInput); break; + case MultiTouchInput::MULTITOUCH_END: rv = OnTouchEnd(multiTouchInput); break; + case MultiTouchInput::MULTITOUCH_CANCEL: rv = OnTouchCancel(multiTouchInput); break; + default: NS_WARNING("Unhandled multitouch"); break; + } + break; + } + case PANGESTURE_INPUT: { + PanGestureInput panGestureInput = aEvent.AsPanGestureInput(); + if (!panGestureInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + switch (panGestureInput.mType) { + case PanGestureInput::PANGESTURE_MAYSTART: rv = OnPanMayBegin(panGestureInput); break; + case PanGestureInput::PANGESTURE_CANCELLED: rv = OnPanCancelled(panGestureInput); break; + case PanGestureInput::PANGESTURE_START: rv = OnPanBegin(panGestureInput); break; + case PanGestureInput::PANGESTURE_PAN: rv = OnPan(panGestureInput, true); break; + case PanGestureInput::PANGESTURE_END: rv = OnPanEnd(panGestureInput); break; + case PanGestureInput::PANGESTURE_MOMENTUMSTART: rv = OnPanMomentumStart(panGestureInput); break; + case PanGestureInput::PANGESTURE_MOMENTUMPAN: rv = OnPan(panGestureInput, false); break; + case PanGestureInput::PANGESTURE_MOMENTUMEND: rv = OnPanMomentumEnd(panGestureInput); break; + default: NS_WARNING("Unhandled pan gesture"); break; + } + break; + } + case MOUSE_INPUT: { + MouseInput mouseInput = aEvent.AsMouseInput(); + if (!mouseInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + // TODO Need to implement blocks to properly handle this. + //rv = HandleDragEvent(mouseInput, dragMetrics); + break; + } + case SCROLLWHEEL_INPUT: { + ScrollWheelInput scrollInput = aEvent.AsScrollWheelInput(); + if (!scrollInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + rv = OnScrollWheel(scrollInput); + break; + } + case PINCHGESTURE_INPUT: { + PinchGestureInput pinchInput = aEvent.AsPinchGestureInput(); + if (!pinchInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + rv = HandleGestureEvent(pinchInput); + break; + } + case TAPGESTURE_INPUT: { + TapGestureInput tapInput = aEvent.AsTapGestureInput(); + if (!tapInput.TransformToLocal(aTransformToApzc)) { + return rv; + } + + rv = HandleGestureEvent(tapInput); + break; + } + default: NS_WARNING("Unhandled input event type"); break; + } + + return rv; +} + +nsEventStatus AsyncPanZoomController::HandleGestureEvent(const InputData& aEvent) +{ + APZThreadUtils::AssertOnControllerThread(); + + nsEventStatus rv = nsEventStatus_eIgnore; + + switch (aEvent.mInputType) { + case PINCHGESTURE_INPUT: { + const PinchGestureInput& pinchGestureInput = aEvent.AsPinchGestureInput(); + switch (pinchGestureInput.mType) { + case PinchGestureInput::PINCHGESTURE_START: rv = OnScaleBegin(pinchGestureInput); break; + case PinchGestureInput::PINCHGESTURE_SCALE: rv = OnScale(pinchGestureInput); break; + case PinchGestureInput::PINCHGESTURE_END: rv = OnScaleEnd(pinchGestureInput); break; + default: NS_WARNING("Unhandled pinch gesture"); break; + } + break; + } + case TAPGESTURE_INPUT: { + const TapGestureInput& tapGestureInput = aEvent.AsTapGestureInput(); + switch (tapGestureInput.mType) { + case TapGestureInput::TAPGESTURE_LONG: rv = OnLongPress(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_LONG_UP: rv = OnLongPressUp(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_UP: rv = OnSingleTapUp(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_CONFIRMED: rv = OnSingleTapConfirmed(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_DOUBLE: rv = OnDoubleTap(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_SECOND: rv = OnSecondTap(tapGestureInput); break; + case TapGestureInput::TAPGESTURE_CANCEL: rv = OnCancelTap(tapGestureInput); break; + default: NS_WARNING("Unhandled tap gesture"); break; + } + break; + } + default: NS_WARNING("Unhandled input event"); break; + } + + return rv; +} + +void AsyncPanZoomController::HandleTouchVelocity(uint32_t aTimesampMs, float aSpeedY) +{ + mY.HandleTouchVelocity(aTimesampMs, aSpeedY); +} + +nsEventStatus AsyncPanZoomController::OnTouchStart(const MultiTouchInput& aEvent) { + APZC_LOG("%p got a touch-start in state %d\n", this, mState); + mPanDirRestricted = false; + ParentLayerPoint point = GetFirstTouchPoint(aEvent); + + switch (mState) { + case FLING: + case ANIMATING_ZOOM: + case SMOOTH_SCROLL: + case OVERSCROLL_ANIMATION: + case WHEEL_SCROLL: + case PAN_MOMENTUM: + MOZ_ASSERT(GetCurrentTouchBlock()); + GetCurrentTouchBlock()->GetOverscrollHandoffChain()->CancelAnimations(ExcludeOverscroll); + MOZ_FALLTHROUGH; + case NOTHING: { + mX.StartTouch(point.x, aEvent.mTime); + mY.StartTouch(point.y, aEvent.mTime); + if (RefPtr controller = GetGeckoContentController()) { + MOZ_ASSERT(GetCurrentTouchBlock()); + controller->NotifyAPZStateChange( + GetGuid(), APZStateChange::eStartTouch, + GetCurrentTouchBlock()->GetOverscrollHandoffChain()->CanBePanned(this)); + } + SetState(TOUCHING); + break; + } + case TOUCHING: + case PANNING: + case PANNING_LOCKED_X: + case PANNING_LOCKED_Y: + case PINCHING: + NS_WARNING("Received impossible touch in OnTouchStart"); + break; + default: + NS_WARNING("Unhandled case in OnTouchStart"); + break; + } + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnTouchMove(const MultiTouchInput& aEvent) { + APZC_LOG("%p got a touch-move in state %d\n", this, mState); + switch (mState) { + case FLING: + case SMOOTH_SCROLL: + case NOTHING: + case ANIMATING_ZOOM: + // May happen if the user double-taps and drags without lifting after the + // second tap. Ignore the move if this happens. + return nsEventStatus_eIgnore; + + case TOUCHING: { + ScreenCoord panThreshold = GetTouchStartTolerance(); + UpdateWithTouchAtDevicePoint(aEvent); + + if (PanDistance() < panThreshold) { + return nsEventStatus_eIgnore; + } + + MOZ_ASSERT(GetCurrentTouchBlock()); + if (gfxPrefs::TouchActionEnabled() && GetCurrentTouchBlock()->TouchActionAllowsPanningXY()) { + // User tries to trigger a touch behavior. If allowed touch behavior is vertical pan + // + horizontal pan (touch-action value is equal to AUTO) we can return ConsumeNoDefault + // status immediately to trigger cancel event further. It should happen independent of + // the parent type (whether it is scrolling or not). + StartPanning(aEvent); + return nsEventStatus_eConsumeNoDefault; + } + + return StartPanning(aEvent); + } + + case PANNING: + case PANNING_LOCKED_X: + case PANNING_LOCKED_Y: + case PAN_MOMENTUM: + TrackTouch(aEvent); + return nsEventStatus_eConsumeNoDefault; + + case PINCHING: + // The scale gesture listener should have handled this. + NS_WARNING("Gesture listener should have handled pinching in OnTouchMove."); + return nsEventStatus_eIgnore; + + case WHEEL_SCROLL: + case OVERSCROLL_ANIMATION: + // Should not receive a touch-move in the OVERSCROLL_ANIMATION state + // as touch blocks that begin in an overscrolled state cancel the + // animation. The same is true for wheel scroll animations. + NS_WARNING("Received impossible touch in OnTouchMove"); + break; + } + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnTouchEnd(const MultiTouchInput& aEvent) { + APZC_LOG("%p got a touch-end in state %d\n", this, mState); + + RefPtr controller = GetGeckoContentController(); + if (controller) { + controller->SetScrollingRootContent(false); + } + + OnTouchEndOrCancel(); + + // In case no touch behavior triggered previously we can avoid sending + // scroll events or requesting content repaint. This condition is added + // to make tests consistent - in case touch-action is NONE (and therefore + // no pans/zooms can be performed) we expected neither scroll or repaint + // events. + if (mState != NOTHING) { + ReentrantMonitorAutoEnter lock(mMonitor); + } + + switch (mState) { + case FLING: + // Should never happen. + NS_WARNING("Received impossible touch end in OnTouchEnd."); + MOZ_FALLTHROUGH; + case ANIMATING_ZOOM: + case SMOOTH_SCROLL: + case NOTHING: + // May happen if the user double-taps and drags without lifting after the + // second tap. Ignore if this happens. + return nsEventStatus_eIgnore; + + case TOUCHING: + // We may have some velocity stored on the axis from move events + // that were not big enough to trigger scrolling. Clear that out. + mX.SetVelocity(0); + mY.SetVelocity(0); + MOZ_ASSERT(GetCurrentTouchBlock()); + APZC_LOG("%p still has %u touch points active\n", this, + GetCurrentTouchBlock()->GetActiveTouchCount()); + // In cases where the user is panning, then taps the second finger without + // entering a pinch, we will arrive here when the second finger is lifted. + // However the first finger is still down so we want to remain in state + // TOUCHING. + if (GetCurrentTouchBlock()->GetActiveTouchCount() == 0) { + // It's possible we may be overscrolled if the user tapped during a + // previous overscroll pan. Make sure to snap back in this situation. + // An ancestor APZC could be overscrolled instead of this APZC, so + // walk the handoff chain as well. + GetCurrentTouchBlock()->GetOverscrollHandoffChain()->SnapBackOverscrolledApzc(this); + // SnapBackOverscrolledApzc() will put any APZC it causes to snap back + // into the OVERSCROLL_ANIMATION state. If that's not us, since we're + // done TOUCHING enter the NOTHING state. + if (mState != OVERSCROLL_ANIMATION) { + SetState(NOTHING); + } + } + return nsEventStatus_eIgnore; + + case PANNING: + case PANNING_LOCKED_X: + case PANNING_LOCKED_Y: + case PAN_MOMENTUM: + { + MOZ_ASSERT(GetCurrentTouchBlock()); + GetCurrentTouchBlock()->GetOverscrollHandoffChain()->FlushRepaints(); + mX.EndTouch(aEvent.mTime); + mY.EndTouch(aEvent.mTime); + ParentLayerPoint flingVelocity = GetVelocityVector(); + // Clear our velocities; if DispatchFling() gives the fling to us, + // the fling velocity gets *added* to our existing velocity in + // AcceptFling(). + mX.SetVelocity(0); + mY.SetVelocity(0); + // Clear our state so that we don't stay in the PANNING state + // if DispatchFling() gives the fling to somone else. However, + // don't send the state change notification until we've determined + // what our final state is to avoid notification churn. + StateChangeNotificationBlocker blocker(this); + SetState(NOTHING); + + APZC_LOG("%p starting a fling animation if %f >= %f\n", this, + flingVelocity.Length().value, gfxPrefs::APZFlingMinVelocityThreshold()); + + if (flingVelocity.Length() < gfxPrefs::APZFlingMinVelocityThreshold()) { + return nsEventStatus_eConsumeNoDefault; + } + + // Make a local copy of the tree manager pointer and check that it's not + // null before calling DispatchFling(). This is necessary because Destroy(), + // which nulls out mTreeManager, could be called concurrently. + if (APZCTreeManager* treeManagerLocal = GetApzcTreeManager()) { + FlingHandoffState handoffState{flingVelocity, + GetCurrentTouchBlock()->GetOverscrollHandoffChain(), + false /* not handoff */, + GetCurrentTouchBlock()->GetScrolledApzc()}; + treeManagerLocal->DispatchFling(this, handoffState); + } + return nsEventStatus_eConsumeNoDefault; + } + case PINCHING: + SetState(NOTHING); + // Scale gesture listener should have handled this. + NS_WARNING("Gesture listener should have handled pinching in OnTouchEnd."); + return nsEventStatus_eIgnore; + + case WHEEL_SCROLL: + case OVERSCROLL_ANIMATION: + // Should not receive a touch-end in the OVERSCROLL_ANIMATION state + // as touch blocks that begin in an overscrolled state cancel the + // animation. The same is true for WHEEL_SCROLL. + NS_WARNING("Received impossible touch in OnTouchEnd"); + break; + } + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnTouchCancel(const MultiTouchInput& aEvent) { + APZC_LOG("%p got a touch-cancel in state %d\n", this, mState); + OnTouchEndOrCancel(); + CancelAnimationAndGestureState(); + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnScaleBegin(const PinchGestureInput& aEvent) { + APZC_LOG("%p got a scale-begin in state %d\n", this, mState); + + mPinchPaintTimerSet = false; + // Note that there may not be a touch block at this point, if we received the + // PinchGestureEvent directly from widget code without any touch events. + if (HasReadyTouchBlock() && !GetCurrentTouchBlock()->TouchActionAllowsPinchZoom()) { + return nsEventStatus_eIgnore; + } + + // For platforms that don't support APZ zooming, dispatch a message to the + // content controller, it may want to do something else with this gesture. + if (!gfxPrefs::APZAllowZooming()) { + if (RefPtr controller = GetGeckoContentController()) { + controller->NotifyPinchGesture(aEvent.mType, GetGuid(), 0, aEvent.modifiers); + } + } + + SetState(PINCHING); + mX.SetVelocity(0); + mY.SetVelocity(0); + mLastZoomFocus = aEvent.mLocalFocusPoint - mFrameMetrics.GetCompositionBounds().TopLeft(); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnScale(const PinchGestureInput& aEvent) { + APZC_LOG("%p got a scale in state %d\n", this, mState); + + if (HasReadyTouchBlock() && !GetCurrentTouchBlock()->TouchActionAllowsPinchZoom()) { + return nsEventStatus_eIgnore; + } + + if (mState != PINCHING) { + return nsEventStatus_eConsumeNoDefault; + } + + if (!gfxPrefs::APZAllowZooming()) { + if (RefPtr controller = GetGeckoContentController()) { + controller->NotifyPinchGesture(aEvent.mType, GetGuid(), + ViewAs(aEvent.mCurrentSpan - aEvent.mPreviousSpan, + PixelCastJustification::LayoutDeviceIsParentLayerForRCDRSF), + aEvent.modifiers); + } + } + + // Only the root APZC is zoomable, and the root APZC is not allowed to have + // different x and y scales. If it did, the calculations in this function + // would have to be adjusted (as e.g. it would no longer be valid to take + // the minimum or maximum of the ratios of the widths and heights of the + // page rect and the composition bounds). + MOZ_ASSERT(mFrameMetrics.IsRootContent()); + MOZ_ASSERT(mFrameMetrics.GetZoom().AreScalesSame()); + + { + ReentrantMonitorAutoEnter lock(mMonitor); + + CSSToParentLayerScale userZoom = mFrameMetrics.GetZoom().ToScaleFactor(); + ParentLayerPoint focusPoint = aEvent.mLocalFocusPoint - mFrameMetrics.GetCompositionBounds().TopLeft(); + CSSPoint cssFocusPoint = focusPoint / mFrameMetrics.GetZoom(); + + ParentLayerPoint focusChange = mLastZoomFocus - focusPoint; + mLastZoomFocus = focusPoint; + // If displacing by the change in focus point will take us off page bounds, + // then reduce the displacement such that it doesn't. + focusChange.x -= mX.DisplacementWillOverscrollAmount(focusChange.x); + focusChange.y -= mY.DisplacementWillOverscrollAmount(focusChange.y); + ScrollBy(focusChange / userZoom); + + // If the span is zero or close to it, we don't want to process this zoom + // change because we're going to get wonky numbers for the spanRatio. So + // let's bail out here. Note that we do this after the focus-change-scroll + // above, so that if we have a pinch with zero span but changing focus, + // such as generated by some Synaptics touchpads on Windows, we still + // scroll properly. + float prevSpan = aEvent.mPreviousSpan; + if (fabsf(prevSpan) <= EPSILON || fabsf(aEvent.mCurrentSpan) <= EPSILON) { + // We might have done a nonzero ScrollBy above, so update metrics and + // repaint/recomposite + ScheduleCompositeAndMaybeRepaint(); + UpdateSharedCompositorFrameMetrics(); + return nsEventStatus_eConsumeNoDefault; + } + float spanRatio = aEvent.mCurrentSpan / aEvent.mPreviousSpan; + + // When we zoom in with focus, we can zoom too much towards the boundaries + // that we actually go over them. These are the needed displacements along + // either axis such that we don't overscroll the boundaries when zooming. + CSSPoint neededDisplacement; + + CSSToParentLayerScale realMinZoom = mZoomConstraints.mMinZoom; + CSSToParentLayerScale realMaxZoom = mZoomConstraints.mMaxZoom; + realMinZoom.scale = std::max(realMinZoom.scale, + mFrameMetrics.GetCompositionBounds().width / mFrameMetrics.GetScrollableRect().width); + realMinZoom.scale = std::max(realMinZoom.scale, + mFrameMetrics.GetCompositionBounds().height / mFrameMetrics.GetScrollableRect().height); + if (realMaxZoom < realMinZoom) { + realMaxZoom = realMinZoom; + } + + bool doScale = (spanRatio > 1.0 && userZoom < realMaxZoom) || + (spanRatio < 1.0 && userZoom > realMinZoom); + + if (!mZoomConstraints.mAllowZoom) { + doScale = false; + } + + if (doScale) { + spanRatio = clamped(spanRatio, + realMinZoom.scale / userZoom.scale, + realMaxZoom.scale / userZoom.scale); + + // Note that the spanRatio here should never put us into OVERSCROLL_BOTH because + // up above we clamped it. + neededDisplacement.x = -mX.ScaleWillOverscrollAmount(spanRatio, cssFocusPoint.x); + neededDisplacement.y = -mY.ScaleWillOverscrollAmount(spanRatio, cssFocusPoint.y); + + ScaleWithFocus(spanRatio, cssFocusPoint); + + if (neededDisplacement != CSSPoint()) { + ScrollBy(neededDisplacement); + } + + // We don't want to redraw on every scale, so throttle it. + if (!mPinchPaintTimerSet) { + const int delay = gfxPrefs::APZScaleRepaintDelay(); + if (delay >= 0) { + if (RefPtr controller = GetGeckoContentController()) { + mPinchPaintTimerSet = true; + controller->PostDelayedTask( + NewRunnableMethod(this, + &AsyncPanZoomController::DoDelayedRequestContentRepaint), + delay); + } + } + } + + UpdateSharedCompositorFrameMetrics(); + } + + // We did a ScrollBy call above even if we didn't do a scale, so we + // should composite for that. + ScheduleComposite(); + } + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnScaleEnd(const PinchGestureInput& aEvent) { + APZC_LOG("%p got a scale-end in state %d\n", this, mState); + + mPinchPaintTimerSet = false; + + if (HasReadyTouchBlock() && !GetCurrentTouchBlock()->TouchActionAllowsPinchZoom()) { + return nsEventStatus_eIgnore; + } + + if (!gfxPrefs::APZAllowZooming()) { + if (RefPtr controller = GetGeckoContentController()) { + controller->NotifyPinchGesture(aEvent.mType, GetGuid(), 0, aEvent.modifiers); + } + } + + SetState(NOTHING); + + { + ReentrantMonitorAutoEnter lock(mMonitor); + ScheduleComposite(); + RequestContentRepaint(); + UpdateSharedCompositorFrameMetrics(); + } + + // Non-negative focus point would indicate that one finger is still down + if (aEvent.mLocalFocusPoint.x != -1 && aEvent.mLocalFocusPoint.y != -1) { + mPanDirRestricted = false; + mX.StartTouch(aEvent.mLocalFocusPoint.x, aEvent.mTime); + mY.StartTouch(aEvent.mLocalFocusPoint.y, aEvent.mTime); + SetState(TOUCHING); + } else { + // Otherwise, handle the fingers being lifted. + ReentrantMonitorAutoEnter lock(mMonitor); + + // We can get into a situation where we are overscrolled at the end of a + // pinch if we go into overscroll with a two-finger pan, and then turn + // that into a pinch by increasing the span sufficiently. In such a case, + // there is no snap-back animation to get us out of overscroll, so we need + // to get out of it somehow. + // Moreover, in cases of scroll handoff, the overscroll can be on an APZC + // further up in the handoff chain rather than on the current APZC, so + // we need to clear overscroll along the entire handoff chain. + if (HasReadyTouchBlock()) { + GetCurrentTouchBlock()->GetOverscrollHandoffChain()->ClearOverscroll(); + } else { + ClearOverscroll(); + } + // Along with clearing the overscroll, we also want to snap to the nearest + // snap point as appropriate. + ScrollSnap(); + } + + return nsEventStatus_eConsumeNoDefault; +} + +bool +AsyncPanZoomController::ConvertToGecko(const ScreenIntPoint& aPoint, LayoutDevicePoint* aOut) +{ + if (APZCTreeManager* treeManagerLocal = GetApzcTreeManager()) { + ScreenToScreenMatrix4x4 transformScreenToGecko = + treeManagerLocal->GetScreenToApzcTransform(this) + * treeManagerLocal->GetApzcToGeckoTransform(this); + + Maybe layoutPoint = UntransformBy( + transformScreenToGecko, aPoint); + if (!layoutPoint) { + return false; + } + + *aOut = LayoutDevicePoint(ViewAs(*layoutPoint, + PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent)); + return true; + } + return false; +} + +static bool +AllowsScrollingMoreThanOnePage(double aMultiplier) +{ + const int32_t kMinAllowPageScroll = + EventStateManager::MIN_MULTIPLIER_VALUE_ALLOWING_OVER_ONE_PAGE_SCROLL; + return Abs(aMultiplier) >= kMinAllowPageScroll; +} + +ParentLayerPoint +AsyncPanZoomController::GetScrollWheelDelta(const ScrollWheelInput& aEvent) const +{ + ParentLayerSize scrollAmount; + ParentLayerSize pageScrollSize; + + { + // Grab the lock to access the frame metrics. + ReentrantMonitorAutoEnter lock(mMonitor); + LayoutDeviceIntSize scrollAmountLD = mScrollMetadata.GetLineScrollAmount(); + LayoutDeviceIntSize pageScrollSizeLD = mScrollMetadata.GetPageScrollAmount(); + scrollAmount = scrollAmountLD / + mFrameMetrics.GetDevPixelsPerCSSPixel() * mFrameMetrics.GetZoom(); + pageScrollSize = pageScrollSizeLD / + mFrameMetrics.GetDevPixelsPerCSSPixel() * mFrameMetrics.GetZoom(); + } + + ParentLayerPoint delta; + switch (aEvent.mDeltaType) { + case ScrollWheelInput::SCROLLDELTA_LINE: { + delta.x = aEvent.mDeltaX * scrollAmount.width; + delta.y = aEvent.mDeltaY * scrollAmount.height; + break; + } + case ScrollWheelInput::SCROLLDELTA_PAGE: { + delta.x = aEvent.mDeltaX * pageScrollSize.width; + delta.y = aEvent.mDeltaY * pageScrollSize.height; + break; + } + case ScrollWheelInput::SCROLLDELTA_PIXEL: { + delta = ToParentLayerCoordinates(ScreenPoint(aEvent.mDeltaX, aEvent.mDeltaY), aEvent.mOrigin); + break; + } + default: + MOZ_ASSERT_UNREACHABLE("unexpected scroll delta type"); + } + + // Apply user-set multipliers. + delta.x *= aEvent.mUserDeltaMultiplierX; + delta.y *= aEvent.mUserDeltaMultiplierY; + + // For the conditions under which we allow system scroll overrides, see + // EventStateManager::DeltaAccumulator::ComputeScrollAmountForDefaultAction + // and WheelTransaction::OverrideSystemScrollSpeed. Note that we do *not* + // restrict this to the root content, see bug 1217715 for discussion on this. + if (gfxPrefs::MouseWheelHasRootScrollDeltaOverride() && + !aEvent.IsCustomizedByUserPrefs() && + aEvent.mDeltaType == ScrollWheelInput::SCROLLDELTA_LINE && + aEvent.mAllowToOverrideSystemScrollSpeed) { + delta.x = WidgetWheelEvent::ComputeOverriddenDelta(delta.x, false); + delta.y = WidgetWheelEvent::ComputeOverriddenDelta(delta.y, true); + } + + // If this is a line scroll, and this event was part of a scroll series, then + // it might need extra acceleration. See WheelHandlingHelper.cpp. + if (aEvent.mDeltaType == ScrollWheelInput::SCROLLDELTA_LINE && + aEvent.mScrollSeriesNumber > 0) + { + int32_t start = gfxPrefs::MouseWheelAccelerationStart(); + if (start >= 0 && aEvent.mScrollSeriesNumber >= uint32_t(start)) { + int32_t factor = gfxPrefs::MouseWheelAccelerationFactor(); + if (factor > 0) { + delta.x = ComputeAcceleratedWheelDelta(delta.x, aEvent.mScrollSeriesNumber, factor); + delta.y = ComputeAcceleratedWheelDelta(delta.y, aEvent.mScrollSeriesNumber, factor); + } + } + } + + // We shouldn't scroll more than one page at once except when the + // user preference is large. + if (!AllowsScrollingMoreThanOnePage(aEvent.mUserDeltaMultiplierX) && + Abs(delta.x) > pageScrollSize.width) { + delta.x = (delta.x >= 0) + ? pageScrollSize.width + : -pageScrollSize.width; + } + if (!AllowsScrollingMoreThanOnePage(aEvent.mUserDeltaMultiplierY) && + Abs(delta.y) > pageScrollSize.height) { + delta.y = (delta.y >= 0) + ? pageScrollSize.height + : -pageScrollSize.height; + } + + return delta; +} + +// Return whether or not the underlying layer can be scrolled on either axis. +bool +AsyncPanZoomController::CanScroll(const InputData& aEvent) const +{ + ParentLayerPoint delta; + if (aEvent.mInputType == SCROLLWHEEL_INPUT) { + delta = GetScrollWheelDelta(aEvent.AsScrollWheelInput()); + } else if (aEvent.mInputType == PANGESTURE_INPUT) { + const PanGestureInput& panInput = aEvent.AsPanGestureInput(); + delta = ToParentLayerCoordinates(panInput.UserMultipliedPanDisplacement(), panInput.mPanStartPoint); + } + if (!delta.x && !delta.y) { + return false; + } + + return CanScrollWithWheel(delta); +} + +bool +AsyncPanZoomController::CanScrollWithWheel(const ParentLayerPoint& aDelta) const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + if (mX.CanScroll(aDelta.x)) { + return true; + } + if (mY.CanScroll(aDelta.y) && mScrollMetadata.AllowVerticalScrollWithWheel()) { + return true; + } + return false; +} + +bool +AsyncPanZoomController::CanScroll(Layer::ScrollDirection aDirection) const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + switch (aDirection) { + case Layer::HORIZONTAL: return mX.CanScroll(); + case Layer::VERTICAL: return mY.CanScroll(); + default: MOZ_ASSERT(false); return false; + } +} + +bool +AsyncPanZoomController::AllowScrollHandoffInCurrentBlock() const +{ + bool result = mInputQueue->AllowScrollHandoff(); + if (!gfxPrefs::APZAllowImmediateHandoff()) { + if (InputBlockState* currentBlock = GetCurrentInputBlock()) { + // Do not allow handoff beyond the first APZC to scroll. + if (currentBlock->GetScrolledApzc() == this) { + result = false; + } + } + } + return result; +} + +void AsyncPanZoomController::DoDelayedRequestContentRepaint() +{ + if (!IsDestroyed() && mPinchPaintTimerSet) { + ReentrantMonitorAutoEnter lock(mMonitor); + RequestContentRepaint(); + } + mPinchPaintTimerSet = false; +} + +static ScrollInputMethod +ScrollInputMethodForWheelDeltaType(ScrollWheelInput::ScrollDeltaType aDeltaType) +{ + switch (aDeltaType) { + case ScrollWheelInput::SCROLLDELTA_LINE: { + return ScrollInputMethod::ApzWheelLine; + } + case ScrollWheelInput::SCROLLDELTA_PAGE: { + return ScrollInputMethod::ApzWheelPage; + } + case ScrollWheelInput::SCROLLDELTA_PIXEL: { + return ScrollInputMethod::ApzWheelPixel; + } + default: + MOZ_ASSERT_UNREACHABLE("unexpected scroll delta type"); + return ScrollInputMethod::ApzWheelLine; + } +} + +nsEventStatus AsyncPanZoomController::OnScrollWheel(const ScrollWheelInput& aEvent) +{ + ParentLayerPoint delta = GetScrollWheelDelta(aEvent); + APZC_LOG("%p got a scroll-wheel with delta %s\n", this, Stringify(delta).c_str()); + + if ((delta.x || delta.y) && !CanScrollWithWheel(delta)) { + // We can't scroll this apz anymore, so we simply drop the event. + if (mInputQueue->GetActiveWheelTransaction() && + gfxPrefs::MouseScrollTestingEnabled()) { + if (RefPtr controller = GetGeckoContentController()) { + controller->NotifyMozMouseScrollEvent( + mFrameMetrics.GetScrollId(), + NS_LITERAL_STRING("MozMouseScrollFailed")); + } + } + return nsEventStatus_eConsumeNoDefault; + } + + if (delta.x == 0 && delta.y == 0) { + // Avoid spurious state changes and unnecessary work + return nsEventStatus_eIgnore; + } + + mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, + (uint32_t) ScrollInputMethodForWheelDeltaType(aEvent.mDeltaType)); + + + switch (aEvent.mScrollMode) { + case ScrollWheelInput::SCROLLMODE_INSTANT: { + + // Wheel events from "clicky" mouse wheels trigger scroll snapping to the + // next snap point. Check for this, and adjust the delta to take into + // account the snap point. + CSSPoint startPosition = mFrameMetrics.GetScrollOffset(); + MaybeAdjustDeltaForScrollSnapping(aEvent, delta, startPosition); + + ScreenPoint distance = ToScreenCoordinates( + ParentLayerPoint(fabs(delta.x), fabs(delta.y)), aEvent.mLocalOrigin); + + CancelAnimation(); + + MOZ_ASSERT(mInputQueue->GetCurrentWheelBlock()); + OverscrollHandoffState handoffState( + *mInputQueue->GetCurrentWheelBlock()->GetOverscrollHandoffChain(), + distance, + ScrollSource::Wheel); + ParentLayerPoint startPoint = aEvent.mLocalOrigin; + ParentLayerPoint endPoint = aEvent.mLocalOrigin - delta; + CallDispatchScroll(startPoint, endPoint, handoffState); + + SetState(NOTHING); + + // The calls above handle their own locking; moreover, + // ToScreenCoordinates() and CallDispatchScroll() can grab the tree lock. + ReentrantMonitorAutoEnter lock(mMonitor); + RequestContentRepaint(); + + break; + } + + case ScrollWheelInput::SCROLLMODE_SMOOTH: { + // The lock must be held across the entire update operation, so the + // compositor doesn't end the animation before we get a chance to + // update it. + ReentrantMonitorAutoEnter lock(mMonitor); + + // Perform scroll snapping if appropriate. + CSSPoint startPosition = mFrameMetrics.GetScrollOffset(); + // If we're already in a wheel scroll or smooth scroll animation, + // the delta is applied to its destination, not to the current + // scroll position. Take this into account when finding a snap point. + if (mState == WHEEL_SCROLL) { + startPosition = mAnimation->AsWheelScrollAnimation()->GetDestination(); + } else if (mState == SMOOTH_SCROLL) { + startPosition = mAnimation->AsSmoothScrollAnimation()->GetDestination(); + } + if (MaybeAdjustDeltaForScrollSnapping(aEvent, delta, startPosition)) { + // If we're scroll snapping, use a smooth scroll animation to get + // the desired physics. Note that SmoothScrollTo() will re-use an + // existing smooth scroll animation if there is one. + APZC_LOG("%p wheel scrolling to snap point %s\n", this, Stringify(startPosition).c_str()); + SmoothScrollTo(startPosition); + break; + } + + // Otherwise, use a wheel scroll animation, also reusing one if possible. + if (mState != WHEEL_SCROLL) { + CancelAnimation(); + SetState(WHEEL_SCROLL); + + nsPoint initialPosition = CSSPoint::ToAppUnits(mFrameMetrics.GetScrollOffset()); + StartAnimation(new WheelScrollAnimation( + *this, initialPosition, aEvent.mDeltaType)); + } + + nsPoint deltaInAppUnits = + CSSPoint::ToAppUnits(delta / mFrameMetrics.GetZoom()); + // Cast velocity from ParentLayerPoints/ms to CSSPoints/ms then convert to + // appunits/second + nsPoint velocity = + CSSPoint::ToAppUnits(CSSPoint(mX.GetVelocity(), mY.GetVelocity())) * 1000.0f; + + WheelScrollAnimation* animation = mAnimation->AsWheelScrollAnimation(); + animation->Update(aEvent.mTimeStamp, deltaInAppUnits, nsSize(velocity.x, velocity.y)); + break; + } + + case ScrollWheelInput::SCROLLMODE_SENTINEL: { + MOZ_ASSERT_UNREACHABLE("Invalid ScrollMode."); + break; + } + } + + return nsEventStatus_eConsumeNoDefault; +} + +void +AsyncPanZoomController::NotifyMozMouseScrollEvent(const nsString& aString) const +{ + RefPtr controller = GetGeckoContentController(); + if (!controller) { + return; + } + + controller->NotifyMozMouseScrollEvent(mFrameMetrics.GetScrollId(), aString); +} + +nsEventStatus AsyncPanZoomController::OnPanMayBegin(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-maybegin in state %d\n", this, mState); + + mX.StartTouch(aEvent.mLocalPanStartPoint.x, aEvent.mTime); + mY.StartTouch(aEvent.mLocalPanStartPoint.y, aEvent.mTime); + MOZ_ASSERT(GetCurrentPanGestureBlock()); + GetCurrentPanGestureBlock()->GetOverscrollHandoffChain()->CancelAnimations(); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnPanCancelled(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-cancelled in state %d\n", this, mState); + + mX.CancelGesture(); + mY.CancelGesture(); + + return nsEventStatus_eConsumeNoDefault; +} + + +nsEventStatus AsyncPanZoomController::OnPanBegin(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-begin in state %d\n", this, mState); + + if (mState == SMOOTH_SCROLL) { + // SMOOTH_SCROLL scrolls are cancelled by pan gestures. + CancelAnimation(); + } + + mX.StartTouch(aEvent.mLocalPanStartPoint.x, aEvent.mTime); + mY.StartTouch(aEvent.mLocalPanStartPoint.y, aEvent.mTime); + + if (GetAxisLockMode() == FREE) { + SetState(PANNING); + return nsEventStatus_eConsumeNoDefault; + } + + float dx = aEvent.mPanDisplacement.x, dy = aEvent.mPanDisplacement.y; + + if (dx || dy) { + double angle = atan2(dy, dx); // range [-pi, pi] + angle = fabs(angle); // range [0, pi] + HandlePanning(angle); + } else { + SetState(PANNING); + } + + // Call into OnPan in order to process any delta included in this event. + OnPan(aEvent, true); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnPan(const PanGestureInput& aEvent, bool aFingersOnTouchpad) { + APZC_LOG("%p got a pan-pan in state %d\n", this, mState); + + if (mState == SMOOTH_SCROLL) { + if (!aFingersOnTouchpad) { + // When a SMOOTH_SCROLL scroll is being processed on a frame, mouse + // wheel and trackpad momentum scroll position updates will not cancel the + // SMOOTH_SCROLL scroll animations, enabling scripts that depend on + // them to be responsive without forcing the user to wait for the momentum + // scrolling to completely stop. + return nsEventStatus_eConsumeNoDefault; + } + + // SMOOTH_SCROLL scrolls are cancelled by pan gestures. + CancelAnimation(); + } + + if (mState == NOTHING) { + // This event block was interrupted by something else. If the user's fingers + // are still on on the touchpad we want to resume scrolling, otherwise we + // ignore the rest of the scroll gesture. + if (!aFingersOnTouchpad) { + return nsEventStatus_eConsumeNoDefault; + } + // Resume / restart the pan. + // PanBegin will call back into this function with mState == PANNING. + return OnPanBegin(aEvent); + } + + // Note that there is a multiplier that applies onto the "physical" pan + // displacement (how much the user's fingers moved) that produces the "logical" + // pan displacement (how much the page should move). For some of the code + // below it makes more sense to use the physical displacement rather than + // the logical displacement, and vice-versa. + ScreenPoint physicalPanDisplacement = aEvent.mPanDisplacement; + ParentLayerPoint logicalPanDisplacement = aEvent.UserMultipliedLocalPanDisplacement(); + + // We need to update the axis velocity in order to get a useful display port + // size and position. We need to do so even if this is a momentum pan (i.e. + // aFingersOnTouchpad == false); in that case the "with touch" part is not + // really appropriate, so we may want to rethink this at some point. + mX.UpdateWithTouchAtDevicePoint(aEvent.mLocalPanStartPoint.x, logicalPanDisplacement.x, aEvent.mTime); + mY.UpdateWithTouchAtDevicePoint(aEvent.mLocalPanStartPoint.y, logicalPanDisplacement.y, aEvent.mTime); + + HandlePanningUpdate(physicalPanDisplacement); + + mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, + (uint32_t) ScrollInputMethod::ApzPanGesture); + + ScreenPoint panDistance(fabs(physicalPanDisplacement.x), fabs(physicalPanDisplacement.y)); + MOZ_ASSERT(GetCurrentPanGestureBlock()); + OverscrollHandoffState handoffState( + *GetCurrentPanGestureBlock()->GetOverscrollHandoffChain(), + panDistance, + ScrollSource::Wheel); + + // Create fake "touch" positions that will result in the desired scroll motion. + // Note that the pan displacement describes the change in scroll position: + // positive displacement values mean that the scroll position increases. + // However, an increase in scroll position means that the scrolled contents + // are moved to the left / upwards. Since our simulated "touches" determine + // the motion of the scrolled contents, not of the scroll position, they need + // to move in the opposite direction of the pan displacement. + ParentLayerPoint startPoint = aEvent.mLocalPanStartPoint; + ParentLayerPoint endPoint = aEvent.mLocalPanStartPoint - logicalPanDisplacement; + CallDispatchScroll(startPoint, endPoint, handoffState); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnPanEnd(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-end in state %d\n", this, mState); + + // Call into OnPan in order to process any delta included in this event. + OnPan(aEvent, true); + + mX.EndTouch(aEvent.mTime); + mY.EndTouch(aEvent.mTime); + + // Drop any velocity on axes where we don't have room to scroll anyways + // (in this APZC, or an APZC further in the handoff chain). + // This ensures that we don't enlarge the display port unnecessarily. + MOZ_ASSERT(GetCurrentPanGestureBlock()); + RefPtr overscrollHandoffChain = + GetCurrentPanGestureBlock()->GetOverscrollHandoffChain(); + if (!overscrollHandoffChain->CanScrollInDirection(this, Layer::HORIZONTAL)) { + mX.SetVelocity(0); + } + if (!overscrollHandoffChain->CanScrollInDirection(this, Layer::VERTICAL)) { + mY.SetVelocity(0); + } + + SetState(NOTHING); + RequestContentRepaint(); + + if (!aEvent.mFollowedByMomentum) { + ScrollSnap(); + } + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnPanMomentumStart(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-momentumstart in state %d\n", this, mState); + + if (mState == SMOOTH_SCROLL) { + // SMOOTH_SCROLL scrolls are cancelled by pan gestures. + CancelAnimation(); + } + + SetState(PAN_MOMENTUM); + ScrollSnapToDestination(); + + // Call into OnPan in order to process any delta included in this event. + OnPan(aEvent, false); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnPanMomentumEnd(const PanGestureInput& aEvent) { + APZC_LOG("%p got a pan-momentumend in state %d\n", this, mState); + + // Call into OnPan in order to process any delta included in this event. + OnPan(aEvent, false); + + // We need to reset the velocity to zero. We don't really have a "touch" + // here because the touch has already ended long before the momentum + // animation started, but I guess it doesn't really matter for now. + mX.CancelGesture(); + mY.CancelGesture(); + SetState(NOTHING); + + RequestContentRepaint(); + + return nsEventStatus_eConsumeNoDefault; +} + +nsEventStatus AsyncPanZoomController::OnLongPress(const TapGestureInput& aEvent) { + APZC_LOG("%p got a long-press in state %d\n", this, mState); + RefPtr controller = GetGeckoContentController(); + if (controller) { + LayoutDevicePoint geckoScreenPoint; + if (ConvertToGecko(aEvent.mPoint, &geckoScreenPoint)) { + TouchBlockState* touch = GetCurrentTouchBlock(); + if (!touch) { + APZC_LOG("%p dropping long-press because some non-touch block interrupted it\n", this); + return nsEventStatus_eIgnore; + } + if (touch->IsDuringFastFling()) { + APZC_LOG("%p dropping long-press because of fast fling\n", this); + return nsEventStatus_eIgnore; + } + uint64_t blockId = GetInputQueue()->InjectNewTouchBlock(this); + controller->HandleTap(TapType::eLongTap, geckoScreenPoint, aEvent.modifiers, GetGuid(), blockId); + return nsEventStatus_eConsumeNoDefault; + } + } + return nsEventStatus_eIgnore; +} + +nsEventStatus AsyncPanZoomController::OnLongPressUp(const TapGestureInput& aEvent) { + APZC_LOG("%p got a long-tap-up in state %d\n", this, mState); + return GenerateSingleTap(TapType::eLongTapUp, aEvent.mPoint, aEvent.modifiers); +} + +nsEventStatus AsyncPanZoomController::GenerateSingleTap(TapType aType, + const ScreenIntPoint& aPoint, mozilla::Modifiers aModifiers) { + RefPtr controller = GetGeckoContentController(); + if (controller) { + LayoutDevicePoint geckoScreenPoint; + if (ConvertToGecko(aPoint, &geckoScreenPoint)) { + TouchBlockState* touch = GetCurrentTouchBlock(); + // |touch| may be null in the case where this function is + // invoked by GestureEventListener on a timeout. In that case we already + // verified that the single tap is allowed so we let it through. + // XXX there is a bug here that in such a case the touch block that + // generated this tap will not get its mSingleTapOccurred flag set. + // See https://bugzilla.mozilla.org/show_bug.cgi?id=1256344#c6 + if (touch) { + if (touch->IsDuringFastFling()) { + APZC_LOG("%p dropping single-tap because it was during a fast-fling\n", this); + return nsEventStatus_eIgnore; + } + touch->SetSingleTapOccurred(); + } + // Because this may be being running as part of APZCTreeManager::ReceiveInputEvent, + // calling controller->HandleTap directly might mean that content receives + // the single tap message before the corresponding touch-up. To avoid that we + // schedule the singletap message to run on the next spin of the event loop. + // See bug 965381 for the issue this was causing. + RefPtr runnable = + NewRunnableMethod(controller, + &GeckoContentController::HandleTap, + aType, geckoScreenPoint, + aModifiers, GetGuid(), + touch ? touch->GetBlockId() : 0); + + controller->PostDelayedTask(runnable.forget(), 0); + return nsEventStatus_eConsumeNoDefault; + } + } + return nsEventStatus_eIgnore; +} + +void AsyncPanZoomController::OnTouchEndOrCancel() { + if (RefPtr controller = GetGeckoContentController()) { + MOZ_ASSERT(GetCurrentTouchBlock()); + controller->NotifyAPZStateChange( + GetGuid(), APZStateChange::eEndTouch, GetCurrentTouchBlock()->SingleTapOccurred()); + } +} + +nsEventStatus AsyncPanZoomController::OnSingleTapUp(const TapGestureInput& aEvent) { + APZC_LOG("%p got a single-tap-up in state %d\n", this, mState); + // If mZoomConstraints.mAllowDoubleTapZoom is true we wait for a call to OnSingleTapConfirmed before + // sending event to content + MOZ_ASSERT(GetCurrentTouchBlock()); + if (!(mZoomConstraints.mAllowDoubleTapZoom && GetCurrentTouchBlock()->TouchActionAllowsDoubleTapZoom())) { + return GenerateSingleTap(TapType::eSingleTap, aEvent.mPoint, aEvent.modifiers); + } + return nsEventStatus_eIgnore; +} + +nsEventStatus AsyncPanZoomController::OnSingleTapConfirmed(const TapGestureInput& aEvent) { + APZC_LOG("%p got a single-tap-confirmed in state %d\n", this, mState); + return GenerateSingleTap(TapType::eSingleTap, aEvent.mPoint, aEvent.modifiers); +} + +nsEventStatus AsyncPanZoomController::OnDoubleTap(const TapGestureInput& aEvent) { + APZC_LOG("%p got a double-tap in state %d\n", this, mState); + RefPtr controller = GetGeckoContentController(); + if (controller) { + MOZ_ASSERT(GetCurrentTouchBlock()); + if (mZoomConstraints.mAllowDoubleTapZoom && GetCurrentTouchBlock()->TouchActionAllowsDoubleTapZoom()) { + LayoutDevicePoint geckoScreenPoint; + if (ConvertToGecko(aEvent.mPoint, &geckoScreenPoint)) { + controller->HandleTap(TapType::eDoubleTap, geckoScreenPoint, + aEvent.modifiers, GetGuid(), GetCurrentTouchBlock()->GetBlockId()); + } + } + return nsEventStatus_eConsumeNoDefault; + } + return nsEventStatus_eIgnore; +} + +nsEventStatus AsyncPanZoomController::OnSecondTap(const TapGestureInput& aEvent) +{ + APZC_LOG("%p got a second-tap in state %d\n", this, mState); + return GenerateSingleTap(TapType::eSecondTap, aEvent.mPoint, aEvent.modifiers); +} + +nsEventStatus AsyncPanZoomController::OnCancelTap(const TapGestureInput& aEvent) { + APZC_LOG("%p got a cancel-tap in state %d\n", this, mState); + // XXX: Implement this. + return nsEventStatus_eIgnore; +} + + +ScreenToParentLayerMatrix4x4 AsyncPanZoomController::GetTransformToThis() const { + if (APZCTreeManager* treeManagerLocal = GetApzcTreeManager()) { + return treeManagerLocal->GetScreenToApzcTransform(this); + } + return ScreenToParentLayerMatrix4x4(); +} + +ScreenPoint AsyncPanZoomController::ToScreenCoordinates(const ParentLayerPoint& aVector, + const ParentLayerPoint& aAnchor) const { + return TransformVector(GetTransformToThis().Inverse(), aVector, aAnchor); +} + +// TODO: figure out a good way to check the w-coordinate is positive and return the result +ParentLayerPoint AsyncPanZoomController::ToParentLayerCoordinates(const ScreenPoint& aVector, + const ScreenPoint& aAnchor) const { + return TransformVector(GetTransformToThis(), aVector, aAnchor); +} + +bool AsyncPanZoomController::Contains(const ScreenIntPoint& aPoint) const +{ + ScreenToParentLayerMatrix4x4 transformToThis = GetTransformToThis(); + Maybe point = UntransformBy(transformToThis, aPoint); + if (!point) { + return false; + } + + ParentLayerIntRect cb; + { + ReentrantMonitorAutoEnter lock(mMonitor); + GetFrameMetrics().GetCompositionBounds().ToIntRect(&cb); + } + return cb.Contains(*point); +} + +ScreenCoord AsyncPanZoomController::PanDistance() const { + ParentLayerPoint panVector; + ParentLayerPoint panStart; + { + ReentrantMonitorAutoEnter lock(mMonitor); + panVector = ParentLayerPoint(mX.PanDistance(), mY.PanDistance()); + panStart = PanStart(); + } + return ToScreenCoordinates(panVector, panStart).Length(); +} + +ParentLayerPoint AsyncPanZoomController::PanStart() const { + return ParentLayerPoint(mX.PanStart(), mY.PanStart()); +} + +const ParentLayerPoint AsyncPanZoomController::GetVelocityVector() const { + return ParentLayerPoint(mX.GetVelocity(), mY.GetVelocity()); +} + +void AsyncPanZoomController::SetVelocityVector(const ParentLayerPoint& aVelocityVector) { + mX.SetVelocity(aVelocityVector.x); + mY.SetVelocity(aVelocityVector.y); +} + +void AsyncPanZoomController::HandlePanningWithTouchAction(double aAngle) { + // Handling of cross sliding will need to be added in this method after touch-action released + // enabled by default. + MOZ_ASSERT(GetCurrentTouchBlock()); + if (GetCurrentTouchBlock()->TouchActionAllowsPanningXY()) { + if (mX.CanScrollNow() && mY.CanScrollNow()) { + if (IsCloseToHorizontal(aAngle, gfxPrefs::APZAxisLockAngle())) { + mY.SetAxisLocked(true); + SetState(PANNING_LOCKED_X); + } else if (IsCloseToVertical(aAngle, gfxPrefs::APZAxisLockAngle())) { + mX.SetAxisLocked(true); + SetState(PANNING_LOCKED_Y); + } else { + SetState(PANNING); + } + } else if (mX.CanScrollNow() || mY.CanScrollNow()) { + SetState(PANNING); + } else { + SetState(NOTHING); + } + } else if (GetCurrentTouchBlock()->TouchActionAllowsPanningX()) { + // Using bigger angle for panning to keep behavior consistent + // with IE. + if (IsCloseToHorizontal(aAngle, gfxPrefs::APZAllowedDirectPanAngle())) { + mY.SetAxisLocked(true); + SetState(PANNING_LOCKED_X); + mPanDirRestricted = true; + } else { + // Don't treat these touches as pan/zoom movements since 'touch-action' value + // requires it. + SetState(NOTHING); + } + } else if (GetCurrentTouchBlock()->TouchActionAllowsPanningY()) { + if (IsCloseToVertical(aAngle, gfxPrefs::APZAllowedDirectPanAngle())) { + mX.SetAxisLocked(true); + SetState(PANNING_LOCKED_Y); + mPanDirRestricted = true; + } else { + SetState(NOTHING); + } + } else { + SetState(NOTHING); + } + if (!IsInPanningState()) { + // If we didn't enter a panning state because touch-action disallowed it, + // make sure to clear any leftover velocity from the pre-threshold + // touchmoves. + mX.SetVelocity(0); + mY.SetVelocity(0); + } +} + +void AsyncPanZoomController::HandlePanning(double aAngle) { + ReentrantMonitorAutoEnter lock(mMonitor); + MOZ_ASSERT(GetCurrentInputBlock()); + RefPtr overscrollHandoffChain = + GetCurrentInputBlock()->GetOverscrollHandoffChain(); + bool canScrollHorizontal = !mX.IsAxisLocked() && + overscrollHandoffChain->CanScrollInDirection(this, Layer::HORIZONTAL); + bool canScrollVertical = !mY.IsAxisLocked() && + overscrollHandoffChain->CanScrollInDirection(this, Layer::VERTICAL); + + if (!canScrollHorizontal || !canScrollVertical) { + SetState(PANNING); + } else if (IsCloseToHorizontal(aAngle, gfxPrefs::APZAxisLockAngle())) { + mY.SetAxisLocked(true); + if (canScrollHorizontal) { + SetState(PANNING_LOCKED_X); + } + } else if (IsCloseToVertical(aAngle, gfxPrefs::APZAxisLockAngle())) { + mX.SetAxisLocked(true); + if (canScrollVertical) { + SetState(PANNING_LOCKED_Y); + } + } else { + SetState(PANNING); + } +} + +void AsyncPanZoomController::HandlePanningUpdate(const ScreenPoint& aPanDistance) { + // If we're axis-locked, check if the user is trying to break the lock + if (GetAxisLockMode() == STICKY && !mPanDirRestricted) { + + double angle = atan2(aPanDistance.y, aPanDistance.x); // range [-pi, pi] + angle = fabs(angle); // range [0, pi] + + float breakThreshold = gfxPrefs::APZAxisBreakoutThreshold() * APZCTreeManager::GetDPI(); + + if (fabs(aPanDistance.x) > breakThreshold || fabs(aPanDistance.y) > breakThreshold) { + if (mState == PANNING_LOCKED_X) { + if (!IsCloseToHorizontal(angle, gfxPrefs::APZAxisBreakoutAngle())) { + mY.SetAxisLocked(false); + SetState(PANNING); + } + } else if (mState == PANNING_LOCKED_Y) { + if (!IsCloseToVertical(angle, gfxPrefs::APZAxisBreakoutAngle())) { + mX.SetAxisLocked(false); + SetState(PANNING); + } + } + } + } +} + +nsEventStatus AsyncPanZoomController::StartPanning(const MultiTouchInput& aEvent) { + ReentrantMonitorAutoEnter lock(mMonitor); + + ParentLayerPoint point = GetFirstTouchPoint(aEvent); + float dx = mX.PanDistance(point.x); + float dy = mY.PanDistance(point.y); + + double angle = atan2(dy, dx); // range [-pi, pi] + angle = fabs(angle); // range [0, pi] + + if (gfxPrefs::TouchActionEnabled()) { + HandlePanningWithTouchAction(angle); + } else { + if (GetAxisLockMode() == FREE) { + SetState(PANNING); + } else { + HandlePanning(angle); + } + } + + if (IsInPanningState()) { + if (RefPtr controller = GetGeckoContentController()) { + controller->NotifyAPZStateChange(GetGuid(), APZStateChange::eStartPanning); + } + return nsEventStatus_eConsumeNoDefault; + } + // Don't consume an event that didn't trigger a panning. + return nsEventStatus_eIgnore; +} + +void AsyncPanZoomController::UpdateWithTouchAtDevicePoint(const MultiTouchInput& aEvent) { + ParentLayerPoint point = GetFirstTouchPoint(aEvent); + mX.UpdateWithTouchAtDevicePoint(point.x, 0, aEvent.mTime); + mY.UpdateWithTouchAtDevicePoint(point.y, 0, aEvent.mTime); +} + +bool AsyncPanZoomController::AttemptScroll(ParentLayerPoint& aStartPoint, + ParentLayerPoint& aEndPoint, + OverscrollHandoffState& aOverscrollHandoffState) { + + // "start - end" rather than "end - start" because e.g. moving your finger + // down (*positive* direction along y axis) causes the vertical scroll offset + // to *decrease* as the page follows your finger. + ParentLayerPoint displacement = aStartPoint - aEndPoint; + + ParentLayerPoint overscroll; // will be used outside monitor block + + // If the direction of panning is reversed within the same input block, + // a later event in the block could potentially scroll an APZC earlier + // in the handoff chain, than an earlier event in the block (because + // the earlier APZC was scrolled to its extent in the original direction). + // We want to disallow this. + bool scrollThisApzc = false; + if (InputBlockState* block = GetCurrentInputBlock()) { + scrollThisApzc = !block->GetScrolledApzc() || block->IsDownchainOfScrolledApzc(this); + } + + if (scrollThisApzc) { + ReentrantMonitorAutoEnter lock(mMonitor); + + ParentLayerPoint adjustedDisplacement; + bool forceVerticalOverscroll = + (aOverscrollHandoffState.mScrollSource == ScrollSource::Wheel && + !mScrollMetadata.AllowVerticalScrollWithWheel()); + bool yChanged = mY.AdjustDisplacement(displacement.y, adjustedDisplacement.y, overscroll.y, + forceVerticalOverscroll); + bool xChanged = mX.AdjustDisplacement(displacement.x, adjustedDisplacement.x, overscroll.x); + + if (xChanged || yChanged) { + ScheduleComposite(); + } + + if (!IsZero(adjustedDisplacement)) { + ScrollBy(adjustedDisplacement / mFrameMetrics.GetZoom()); + if (CancelableBlockState* block = GetCurrentInputBlock()) { + if (block->AsTouchBlock() && (block->GetScrolledApzc() != this)) { + RefPtr controller = GetGeckoContentController(); + if (controller) { + controller->SetScrollingRootContent(IsRootContent()); + } + } + block->SetScrolledApzc(this); + } + ScheduleCompositeAndMaybeRepaint(); + UpdateSharedCompositorFrameMetrics(); + } + + // Adjust the start point to reflect the consumed portion of the scroll. + aStartPoint = aEndPoint + overscroll; + } else { + overscroll = displacement; + } + + // If we consumed the entire displacement as a normal scroll, great. + if (IsZero(overscroll)) { + return true; + } + + if (AllowScrollHandoffInCurrentBlock()) { + // If there is overscroll, first try to hand it off to an APZC later + // in the handoff chain to consume (either as a normal scroll or as + // overscroll). + // Note: "+ overscroll" rather than "- overscroll" because "overscroll" + // is what's left of "displacement", and "displacement" is "start - end". + ++aOverscrollHandoffState.mChainIndex; + CallDispatchScroll(aStartPoint, aEndPoint, aOverscrollHandoffState); + + overscroll = aStartPoint - aEndPoint; + if (IsZero(overscroll)) { + return true; + } + } + + // If there is no APZC later in the handoff chain that accepted the + // overscroll, try to accept it ourselves. We only accept it if we + // are pannable. + APZC_LOG("%p taking overscroll during panning\n", this); + OverscrollForPanning(overscroll, aOverscrollHandoffState.mPanDistance); + aStartPoint = aEndPoint + overscroll; + + return IsZero(overscroll); +} + +void AsyncPanZoomController::OverscrollForPanning(ParentLayerPoint& aOverscroll, + const ScreenPoint& aPanDistance) { + // Only allow entering overscroll along an axis if the pan distance along + // that axis is greater than the pan distance along the other axis by a + // configurable factor. If we are already overscrolled, don't check this. + if (!IsOverscrolled()) { + if (aPanDistance.x < gfxPrefs::APZMinPanDistanceRatio() * aPanDistance.y) { + aOverscroll.x = 0; + } + if (aPanDistance.y < gfxPrefs::APZMinPanDistanceRatio() * aPanDistance.x) { + aOverscroll.y = 0; + } + } + + OverscrollBy(aOverscroll); +} + +void AsyncPanZoomController::OverscrollBy(ParentLayerPoint& aOverscroll) { + if (!gfxPrefs::APZOverscrollEnabled()) { + return; + } + + ReentrantMonitorAutoEnter lock(mMonitor); + // Do not go into overscroll in a direction in which we have no room to + // scroll to begin with. + bool xCanScroll = mX.CanScroll(); + bool yCanScroll = mY.CanScroll(); + bool xConsumed = FuzzyEqualsAdditive(aOverscroll.x, 0.0f, COORDINATE_EPSILON); + bool yConsumed = FuzzyEqualsAdditive(aOverscroll.y, 0.0f, COORDINATE_EPSILON); + + bool shouldOverscrollX = xCanScroll && !xConsumed; + bool shouldOverscrollY = yCanScroll && !yConsumed; + + mOverscrollEffect->ConsumeOverscroll(aOverscroll, shouldOverscrollX, shouldOverscrollY); +} + +RefPtr AsyncPanZoomController::BuildOverscrollHandoffChain() { + if (APZCTreeManager* treeManagerLocal = GetApzcTreeManager()) { + return treeManagerLocal->BuildOverscrollHandoffChain(this); + } + + // This APZC IsDestroyed(). To avoid callers having to special-case this + // scenario, just build a 1-element chain containing ourselves. + OverscrollHandoffChain* result = new OverscrollHandoffChain; + result->Add(this); + return result; +} + +void AsyncPanZoomController::AcceptFling(FlingHandoffState& aHandoffState) { + ReentrantMonitorAutoEnter lock(mMonitor); + + // We may have a pre-existing velocity for whatever reason (for example, + // a previously handed off fling). We don't want to clobber that. + APZC_LOG("%p accepting fling with velocity %s\n", this, + Stringify(aHandoffState.mVelocity).c_str()); + if (mX.CanScroll()) { + mX.SetVelocity(mX.GetVelocity() + aHandoffState.mVelocity.x); + aHandoffState.mVelocity.x = 0; + } + if (mY.CanScroll()) { + mY.SetVelocity(mY.GetVelocity() + aHandoffState.mVelocity.y); + aHandoffState.mVelocity.y = 0; + } + + // If there's a scroll snap point near the predicted fling destination, + // scroll there using a smooth scroll animation. Otherwise, start a + // fling animation. + ScrollSnapToDestination(); + if (mState != SMOOTH_SCROLL) { + SetState(FLING); + FlingAnimation *fling = new FlingAnimation(*this, + GetPlatformSpecificState(), + aHandoffState.mChain, + aHandoffState.mIsHandoff, + aHandoffState.mScrolledApzc); + StartAnimation(fling); + } +} + +bool AsyncPanZoomController::AttemptFling(FlingHandoffState& aHandoffState) { + // If we are pannable, take over the fling ourselves. + if (IsPannable()) { + AcceptFling(aHandoffState); + return true; + } + + return false; +} + +void AsyncPanZoomController::HandleFlingOverscroll(const ParentLayerPoint& aVelocity, + const RefPtr& aOverscrollHandoffChain, + const RefPtr& aScrolledApzc) { + APZCTreeManager* treeManagerLocal = GetApzcTreeManager(); + if (treeManagerLocal) { + FlingHandoffState handoffState{aVelocity, + aOverscrollHandoffChain, + true /* handoff */, + aScrolledApzc}; + treeManagerLocal->DispatchFling(this, handoffState); + if (!IsZero(handoffState.mVelocity) && IsPannable() && gfxPrefs::APZOverscrollEnabled()) { + mOverscrollEffect->HandleFlingOverscroll(handoffState.mVelocity); + } + } +} + +void AsyncPanZoomController::HandleSmoothScrollOverscroll(const ParentLayerPoint& aVelocity) { + // We must call BuildOverscrollHandoffChain from this deferred callback + // function in order to avoid a deadlock when acquiring the tree lock. + HandleFlingOverscroll(aVelocity, BuildOverscrollHandoffChain(), nullptr); +} + +void AsyncPanZoomController::SmoothScrollTo(const CSSPoint& aDestination) { + if (mState == SMOOTH_SCROLL && mAnimation) { + APZC_LOG("%p updating destination on existing animation\n", this); + RefPtr animation( + static_cast(mAnimation.get())); + animation->SetDestination(CSSPoint::ToAppUnits(aDestination)); + } else { + CancelAnimation(); + SetState(SMOOTH_SCROLL); + nsPoint initialPosition = CSSPoint::ToAppUnits(mFrameMetrics.GetScrollOffset()); + // Cast velocity from ParentLayerPoints/ms to CSSPoints/ms then convert to + // appunits/second + nsPoint initialVelocity = CSSPoint::ToAppUnits(CSSPoint(mX.GetVelocity(), + mY.GetVelocity())) * 1000.0f; + nsPoint destination = CSSPoint::ToAppUnits(aDestination); + + StartAnimation(new SmoothScrollAnimation(*this, + initialPosition, initialVelocity, + destination, + gfxPrefs::ScrollBehaviorSpringConstant(), + gfxPrefs::ScrollBehaviorDampingRatio())); + } +} + +void AsyncPanZoomController::StartOverscrollAnimation(const ParentLayerPoint& aVelocity) { + SetState(OVERSCROLL_ANIMATION); + StartAnimation(new OverscrollAnimation(*this, aVelocity)); +} + +void AsyncPanZoomController::CallDispatchScroll(ParentLayerPoint& aStartPoint, + ParentLayerPoint& aEndPoint, + OverscrollHandoffState& aOverscrollHandoffState) { + // Make a local copy of the tree manager pointer and check if it's not + // null before calling DispatchScroll(). This is necessary because + // Destroy(), which nulls out mTreeManager, could be called concurrently. + APZCTreeManager* treeManagerLocal = GetApzcTreeManager(); + if (!treeManagerLocal) { + return; + } + treeManagerLocal->DispatchScroll(this, + aStartPoint, aEndPoint, + aOverscrollHandoffState); +} + +void AsyncPanZoomController::TrackTouch(const MultiTouchInput& aEvent) { + ParentLayerPoint prevTouchPoint(mX.GetPos(), mY.GetPos()); + ParentLayerPoint touchPoint = GetFirstTouchPoint(aEvent); + + ScreenPoint panDistance = ToScreenCoordinates( + ParentLayerPoint(mX.PanDistance(touchPoint.x), + mY.PanDistance(touchPoint.y)), + PanStart()); + HandlePanningUpdate(panDistance); + + UpdateWithTouchAtDevicePoint(aEvent); + + if (prevTouchPoint != touchPoint) { + mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS, + (uint32_t) ScrollInputMethod::ApzTouch); + MOZ_ASSERT(GetCurrentTouchBlock()); + OverscrollHandoffState handoffState( + *GetCurrentTouchBlock()->GetOverscrollHandoffChain(), + panDistance, + ScrollSource::Touch); + CallDispatchScroll(prevTouchPoint, touchPoint, handoffState); + } +} + +ParentLayerPoint AsyncPanZoomController::GetFirstTouchPoint(const MultiTouchInput& aEvent) { + return ((SingleTouchData&)aEvent.mTouches[0]).mLocalScreenPoint; +} + +void AsyncPanZoomController::StartAnimation(AsyncPanZoomAnimation* aAnimation) +{ + ReentrantMonitorAutoEnter lock(mMonitor); + mAnimation = aAnimation; + mLastSampleTime = GetFrameTime(); + ScheduleComposite(); +} + +void AsyncPanZoomController::CancelAnimation(CancelAnimationFlags aFlags) { + ReentrantMonitorAutoEnter lock(mMonitor); + APZC_LOG("%p running CancelAnimation in state %d\n", this, mState); + SetState(NOTHING); + mAnimation = nullptr; + // Since there is no animation in progress now the axes should + // have no velocity either. If we are dropping the velocity from a non-zero + // value we should trigger a repaint as the displayport margins are dependent + // on the velocity and the last repaint request might not have good margins + // any more. + bool repaint = !IsZero(GetVelocityVector()); + mX.SetVelocity(0); + mY.SetVelocity(0); + mX.SetAxisLocked(false); + mY.SetAxisLocked(false); + // Setting the state to nothing and cancelling the animation can + // preempt normal mechanisms for relieving overscroll, so we need to clear + // overscroll here. + if (!(aFlags & ExcludeOverscroll) && IsOverscrolled()) { + ClearOverscroll(); + repaint = true; + } + // Similar to relieving overscroll, we also need to snap to any snap points + // if appropriate. + if (aFlags & CancelAnimationFlags::ScrollSnap) { + ScrollSnap(); + } + if (repaint) { + RequestContentRepaint(); + ScheduleComposite(); + UpdateSharedCompositorFrameMetrics(); + } +} + +void AsyncPanZoomController::ClearOverscroll() { + ReentrantMonitorAutoEnter lock(mMonitor); + mX.ClearOverscroll(); + mY.ClearOverscroll(); +} + +void AsyncPanZoomController::SetCompositorController(CompositorController* aCompositorController) +{ + mCompositorController = aCompositorController; +} + +void AsyncPanZoomController::SetMetricsSharingController(MetricsSharingController* aMetricsSharingController) +{ + mMetricsSharingController = aMetricsSharingController; +} + +void AsyncPanZoomController::AdjustScrollForSurfaceShift(const ScreenPoint& aShift) +{ + ReentrantMonitorAutoEnter lock(mMonitor); + CSSPoint adjustment = + ViewAs(aShift, PixelCastJustification::ScreenIsParentLayerForRoot) + / mFrameMetrics.GetZoom(); + APZC_LOG("%p adjusting scroll position by %s for surface shift\n", + this, Stringify(adjustment).c_str()); + CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset(); + scrollOffset.y = mY.ClampOriginToScrollableRect(scrollOffset.y + adjustment.y); + scrollOffset.x = mX.ClampOriginToScrollableRect(scrollOffset.x + adjustment.x); + mFrameMetrics.SetScrollOffset(scrollOffset); + ScheduleCompositeAndMaybeRepaint(); + UpdateSharedCompositorFrameMetrics(); +} + +void AsyncPanZoomController::ScrollBy(const CSSPoint& aOffset) { + mFrameMetrics.ScrollBy(aOffset); +} + +void AsyncPanZoomController::ScaleWithFocus(float aScale, + const CSSPoint& aFocus) { + mFrameMetrics.ZoomBy(aScale); + // We want to adjust the scroll offset such that the CSS point represented by aFocus remains + // at the same position on the screen before and after the change in zoom. The below code + // accomplishes this; see https://bugzilla.mozilla.org/show_bug.cgi?id=923431#c6 for an + // in-depth explanation of how. + mFrameMetrics.SetScrollOffset((mFrameMetrics.GetScrollOffset() + aFocus) - (aFocus / aScale)); +} + +/** + * Enlarges the displayport along both axes based on the velocity. + */ +static CSSSize +CalculateDisplayPortSize(const CSSSize& aCompositionSize, + const CSSPoint& aVelocity) +{ + bool xIsStationarySpeed = fabsf(aVelocity.x) < gfxPrefs::APZMinSkateSpeed(); + bool yIsStationarySpeed = fabsf(aVelocity.y) < gfxPrefs::APZMinSkateSpeed(); + float xMultiplier = xIsStationarySpeed + ? gfxPrefs::APZXStationarySizeMultiplier() + : gfxPrefs::APZXSkateSizeMultiplier(); + float yMultiplier = yIsStationarySpeed + ? gfxPrefs::APZYStationarySizeMultiplier() + : gfxPrefs::APZYSkateSizeMultiplier(); + + if (IsHighMemSystem() && !xIsStationarySpeed) { + xMultiplier += gfxPrefs::APZXSkateHighMemAdjust(); + } + + if (IsHighMemSystem() && !yIsStationarySpeed) { + yMultiplier += gfxPrefs::APZYSkateHighMemAdjust(); + } + + return aCompositionSize * CSSSize(xMultiplier, yMultiplier); +} + +/** + * Ensures that the displayport is at least as large as the visible area + * inflated by the danger zone. If this is not the case then the + * "AboutToCheckerboard" function in TiledContentClient.cpp will return true + * even in the stable state. + */ +static CSSSize +ExpandDisplayPortToDangerZone(const CSSSize& aDisplayPortSize, + const FrameMetrics& aFrameMetrics) +{ + CSSSize dangerZone(0.0f, 0.0f); + if (aFrameMetrics.LayersPixelsPerCSSPixel().xScale != 0 && + aFrameMetrics.LayersPixelsPerCSSPixel().yScale != 0) { + dangerZone = LayerSize( + gfxPrefs::APZDangerZoneX(), + gfxPrefs::APZDangerZoneY()) / aFrameMetrics.LayersPixelsPerCSSPixel(); + } + const CSSSize compositionSize = aFrameMetrics.CalculateBoundedCompositedSizeInCssPixels(); + + const float xSize = std::max(aDisplayPortSize.width, + compositionSize.width + (2 * dangerZone.width)); + + const float ySize = std::max(aDisplayPortSize.height, + compositionSize.height + (2 * dangerZone.height)); + + return CSSSize(xSize, ySize); +} + +/** + * Attempts to redistribute any area in the displayport that would get clipped + * by the scrollable rect, or be inaccessible due to disabled scrolling, to the + * other axis, while maintaining total displayport area. + */ +static void +RedistributeDisplayPortExcess(CSSSize& aDisplayPortSize, + const CSSRect& aScrollableRect) +{ + // As aDisplayPortSize.height * aDisplayPortSize.width does not change, + // we are just scaling by the ratio and its inverse. + if (aDisplayPortSize.height > aScrollableRect.height) { + aDisplayPortSize.width *= (aDisplayPortSize.height / aScrollableRect.height); + aDisplayPortSize.height = aScrollableRect.height; + } else if (aDisplayPortSize.width > aScrollableRect.width) { + aDisplayPortSize.height *= (aDisplayPortSize.width / aScrollableRect.width); + aDisplayPortSize.width = aScrollableRect.width; + } +} + +/* static */ +const ScreenMargin AsyncPanZoomController::CalculatePendingDisplayPort( + const FrameMetrics& aFrameMetrics, + const ParentLayerPoint& aVelocity) +{ + if (aFrameMetrics.IsScrollInfoLayer()) { + // Don't compute margins. Since we can't asynchronously scroll this frame, + // we don't want to paint anything more than the composition bounds. + return ScreenMargin(); + } + + CSSSize compositionSize = aFrameMetrics.CalculateBoundedCompositedSizeInCssPixels(); + CSSPoint velocity; + if (aFrameMetrics.GetZoom() != CSSToParentLayerScale2D(0, 0)) { + velocity = aVelocity / aFrameMetrics.GetZoom(); // avoid division by zero + } + CSSRect scrollableRect = aFrameMetrics.GetExpandedScrollableRect(); + + // Calculate the displayport size based on how fast we're moving along each axis. + CSSSize displayPortSize = CalculateDisplayPortSize(compositionSize, velocity); + + displayPortSize = ExpandDisplayPortToDangerZone(displayPortSize, aFrameMetrics); + + if (gfxPrefs::APZEnlargeDisplayPortWhenClipped()) { + RedistributeDisplayPortExcess(displayPortSize, scrollableRect); + } + + // We calculate a "displayport" here which is relative to the scroll offset. + // Note that the scroll offset we have here in the APZ code may not be the + // same as the base rect that gets used on the layout side when the displayport + // margins are actually applied, so it is important to only consider the + // displayport as margins relative to a scroll offset rather than relative to + // something more unchanging like the scrollable rect origin. + + // Center the displayport based on its expansion over the composition size. + CSSRect displayPort((compositionSize.width - displayPortSize.width) / 2.0f, + (compositionSize.height - displayPortSize.height) / 2.0f, + displayPortSize.width, displayPortSize.height); + + // Offset the displayport, depending on how fast we're moving and the + // estimated time it takes to paint, to try to minimise checkerboarding. + float paintFactor = kDefaultEstimatedPaintDurationMs; + displayPort.MoveBy(velocity * paintFactor * gfxPrefs::APZVelocityBias()); + + APZC_LOG_FM(aFrameMetrics, + "Calculated displayport as (%f %f %f %f) from velocity %s paint time %f metrics", + displayPort.x, displayPort.y, displayPort.width, displayPort.height, + ToString(aVelocity).c_str(), paintFactor); + + CSSMargin cssMargins; + cssMargins.left = -displayPort.x; + cssMargins.top = -displayPort.y; + cssMargins.right = displayPort.width - compositionSize.width - cssMargins.left; + cssMargins.bottom = displayPort.height - compositionSize.height - cssMargins.top; + + return cssMargins * aFrameMetrics.DisplayportPixelsPerCSSPixel(); +} + +void AsyncPanZoomController::ScheduleComposite() { + if (mCompositorController) { + mCompositorController->ScheduleRenderOnCompositorThread(); + } +} + +void AsyncPanZoomController::ScheduleCompositeAndMaybeRepaint() { + ScheduleComposite(); + RequestContentRepaint(); +} + +void AsyncPanZoomController::FlushRepaintForOverscrollHandoff() { + ReentrantMonitorAutoEnter lock(mMonitor); + RequestContentRepaint(); + UpdateSharedCompositorFrameMetrics(); +} + +void AsyncPanZoomController::FlushRepaintForNewInputBlock() { + APZC_LOG("%p flushing repaint for new input block\n", this); + + ReentrantMonitorAutoEnter lock(mMonitor); + RequestContentRepaint(); + UpdateSharedCompositorFrameMetrics(); +} + +bool AsyncPanZoomController::SnapBackIfOverscrolled() { + ReentrantMonitorAutoEnter lock(mMonitor); + // It's possible that we're already in the middle of an overscroll + // animation - if so, don't start a new one. + if (IsOverscrolled() && mState != OVERSCROLL_ANIMATION) { + APZC_LOG("%p is overscrolled, starting snap-back\n", this); + StartOverscrollAnimation(ParentLayerPoint(0, 0)); + return true; + } + // If we don't kick off an overscroll animation, we still need to ask the + // main thread to snap to any nearby snap points, assuming we haven't already + // done so when we started this fling + if (mState != FLING) { + ScrollSnap(); + } + return false; +} + +bool AsyncPanZoomController::IsFlingingFast() const { + ReentrantMonitorAutoEnter lock(mMonitor); + if (mState == FLING && + GetVelocityVector().Length() > gfxPrefs::APZFlingStopOnTapThreshold()) { + APZC_LOG("%p is moving fast\n", this); + return true; + } + return false; +} + +bool AsyncPanZoomController::IsPannable() const { + ReentrantMonitorAutoEnter lock(mMonitor); + return mX.CanScroll() || mY.CanScroll(); +} + +int32_t AsyncPanZoomController::GetLastTouchIdentifier() const { + RefPtr listener = GetGestureEventListener(); + return listener ? listener->GetLastTouchIdentifier() : -1; +} + +void AsyncPanZoomController::RequestContentRepaint(bool aUserAction) { + // Reinvoke this method on the repaint thread if it's not there already. It's + // important to do this before the call to CalculatePendingDisplayPort, so + // that CalculatePendingDisplayPort uses the most recent available version of + // mFrameMetrics, just before the paint request is dispatched to content. + RefPtr controller = GetGeckoContentController(); + if (!controller) { + return; + } + if (!controller->IsRepaintThread()) { + // use the local variable to resolve the function overload. + auto func = static_cast + (&AsyncPanZoomController::RequestContentRepaint); + controller->DispatchToRepaintThread(NewRunnableMethod(this, func, aUserAction)); + return; + } + + MOZ_ASSERT(controller->IsRepaintThread()); + + ReentrantMonitorAutoEnter lock(mMonitor); + ParentLayerPoint velocity = GetVelocityVector(); + mFrameMetrics.SetDisplayPortMargins(CalculatePendingDisplayPort(mFrameMetrics, velocity)); + mFrameMetrics.SetUseDisplayPortMargins(true); + mFrameMetrics.SetPaintRequestTime(TimeStamp::Now()); + mFrameMetrics.SetRepaintDrivenByUserAction(aUserAction); + RequestContentRepaint(mFrameMetrics, velocity); +} + +/*static*/ CSSRect +GetDisplayPortRect(const FrameMetrics& aFrameMetrics) +{ + // This computation is based on what happens in CalculatePendingDisplayPort. If that + // changes then this might need to change too + CSSRect baseRect(aFrameMetrics.GetScrollOffset(), + aFrameMetrics.CalculateBoundedCompositedSizeInCssPixels()); + baseRect.Inflate(aFrameMetrics.GetDisplayPortMargins() / aFrameMetrics.DisplayportPixelsPerCSSPixel()); + return baseRect; +} + +void +AsyncPanZoomController::RequestContentRepaint(const FrameMetrics& aFrameMetrics, + const ParentLayerPoint& aVelocity) +{ + RefPtr controller = GetGeckoContentController(); + if (!controller) { + return; + } + MOZ_ASSERT(controller->IsRepaintThread()); + + // If we're trying to paint what we already think is painted, discard this + // request since it's a pointless paint. + ScreenMargin marginDelta = (mLastPaintRequestMetrics.GetDisplayPortMargins() + - aFrameMetrics.GetDisplayPortMargins()); + if (fabsf(marginDelta.left) < EPSILON && + fabsf(marginDelta.top) < EPSILON && + fabsf(marginDelta.right) < EPSILON && + fabsf(marginDelta.bottom) < EPSILON && + fabsf(mLastPaintRequestMetrics.GetScrollOffset().x - + aFrameMetrics.GetScrollOffset().x) < EPSILON && + fabsf(mLastPaintRequestMetrics.GetScrollOffset().y - + aFrameMetrics.GetScrollOffset().y) < EPSILON && + aFrameMetrics.GetPresShellResolution() == mLastPaintRequestMetrics.GetPresShellResolution() && + aFrameMetrics.GetZoom() == mLastPaintRequestMetrics.GetZoom() && + fabsf(aFrameMetrics.GetViewport().width - + mLastPaintRequestMetrics.GetViewport().width) < EPSILON && + fabsf(aFrameMetrics.GetViewport().height - + mLastPaintRequestMetrics.GetViewport().height) < EPSILON && + aFrameMetrics.GetScrollGeneration() == + mLastPaintRequestMetrics.GetScrollGeneration() && + aFrameMetrics.GetScrollUpdateType() == + mLastPaintRequestMetrics.GetScrollUpdateType()) { + return; + } + + APZC_LOG_FM(aFrameMetrics, "%p requesting content repaint", this); + { // scope lock + MutexAutoLock lock(mCheckerboardEventLock); + if (mCheckerboardEvent && mCheckerboardEvent->IsRecordingTrace()) { + std::stringstream info; + info << " velocity " << aVelocity; + std::string str = info.str(); + mCheckerboardEvent->UpdateRendertraceProperty( + CheckerboardEvent::RequestedDisplayPort, GetDisplayPortRect(aFrameMetrics), + str); + } + } + + MOZ_ASSERT(aFrameMetrics.GetScrollUpdateType() == FrameMetrics::eNone || + aFrameMetrics.GetScrollUpdateType() == FrameMetrics::eUserAction); + controller->RequestContentRepaint(aFrameMetrics); + mExpectedGeckoMetrics = aFrameMetrics; + mLastPaintRequestMetrics = aFrameMetrics; +} + +bool AsyncPanZoomController::UpdateAnimation(const TimeStamp& aSampleTime, + nsTArray>* aOutDeferredTasks) +{ + APZThreadUtils::AssertOnCompositorThread(); + + // This function may get called multiple with the same sample time, because + // there may be multiple layers with this APZC, and each layer invokes this + // function during composition. However we only want to do one animation step + // per composition so we need to deduplicate these calls first. + if (mLastSampleTime == aSampleTime) { + return false; + } + TimeDuration sampleTimeDelta = aSampleTime - mLastSampleTime; + mLastSampleTime = aSampleTime; + + if (mAnimation) { + bool continueAnimation = mAnimation->Sample(mFrameMetrics, sampleTimeDelta); + bool wantsRepaints = mAnimation->WantsRepaints(); + *aOutDeferredTasks = mAnimation->TakeDeferredTasks(); + if (!continueAnimation) { + mAnimation = nullptr; + SetState(NOTHING); + } + // Request a repaint at the end of the animation in case something such as a + // call to NotifyLayersUpdated was invoked during the animation and Gecko's + // current state is some intermediate point of the animation. + if (!continueAnimation || wantsRepaints) { + RequestContentRepaint(); + } + UpdateSharedCompositorFrameMetrics(); + return true; + } + return false; +} + +AsyncTransformComponentMatrix +AsyncPanZoomController::GetOverscrollTransform(AsyncMode aMode) const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + + if (aMode == RESPECT_FORCE_DISABLE && mScrollMetadata.IsApzForceDisabled()) { + return AsyncTransformComponentMatrix(); + } + + if (!IsOverscrolled()) { + return AsyncTransformComponentMatrix(); + } + + // The overscroll effect is a uniform stretch along the overscrolled axis, + // with the edge of the content where we have reached the end of the + // scrollable area pinned into place. + + // The kStretchFactor parameter determines how much overscroll can stretch the + // content. + const float kStretchFactor = gfxPrefs::APZOverscrollStretchFactor(); + + // Compute the amount of the stretch along each axis. The stretch is + // proportional to the amount by which we are overscrolled along that axis. + ParentLayerSize compositionSize(mX.GetCompositionLength(), mY.GetCompositionLength()); + float scaleX = 1 + kStretchFactor * fabsf(mX.GetOverscroll()) / mX.GetCompositionLength(); + float scaleY = 1 + kStretchFactor * fabsf(mY.GetOverscroll()) / mY.GetCompositionLength(); + + // The scale is applied relative to the origin of the composition bounds, i.e. + // it keeps the top-left corner of the content in place. This is fine if we + // are overscrolling at the top or on the left, but if we are overscrolling + // at the bottom or on the right, we want the bottom or right edge of the + // content to stay in place instead, so we add a translation to compensate. + ParentLayerPoint translation; + bool overscrolledOnRight = mX.GetOverscroll() > 0; + if (overscrolledOnRight) { + ParentLayerCoord overscrolledCompositionWidth = scaleX * compositionSize.width; + ParentLayerCoord extraCompositionWidth = overscrolledCompositionWidth - compositionSize.width; + translation.x = -extraCompositionWidth; + } + bool overscrolledAtBottom = mY.GetOverscroll() > 0; + if (overscrolledAtBottom) { + ParentLayerCoord overscrolledCompositionHeight = scaleY * compositionSize.height; + ParentLayerCoord extraCompositionHeight = overscrolledCompositionHeight - compositionSize.height; + translation.y = -extraCompositionHeight; + } + + // Combine the transformations into a matrix. + return AsyncTransformComponentMatrix::Scaling(scaleX, scaleY, 1) + .PostTranslate(translation.x, translation.y, 0); +} + +bool AsyncPanZoomController::AdvanceAnimations(const TimeStamp& aSampleTime) +{ + APZThreadUtils::AssertOnCompositorThread(); + + // Don't send any state-change notifications until the end of the function, + // because we may go through some intermediate states while we finish + // animations and start new ones. + StateChangeNotificationBlocker blocker(this); + + // The eventual return value of this function. The compositor needs to know + // whether or not to advance by a frame as soon as it can. For example, if a + // fling is happening, it has to keep compositing so that the animation is + // smooth. If an animation frame is requested, it is the compositor's + // responsibility to schedule a composite. + mAsyncTransformAppliedToContent = false; + bool requestAnimationFrame = false; + nsTArray> deferredTasks; + + { + ReentrantMonitorAutoEnter lock(mMonitor); + + requestAnimationFrame = UpdateAnimation(aSampleTime, &deferredTasks); + + { // scope lock + MutexAutoLock lock(mCheckerboardEventLock); + if (mCheckerboardEvent) { + mCheckerboardEvent->UpdateRendertraceProperty( + CheckerboardEvent::UserVisible, + CSSRect(mFrameMetrics.GetScrollOffset(), + mFrameMetrics.CalculateCompositedSizeInCssPixels())); + } + } + } + + // Execute any deferred tasks queued up by mAnimation's Sample() (called by + // UpdateAnimation()). This needs to be done after the monitor is released + // since the tasks are allowed to call APZCTreeManager methods which can grab + // the tree lock. + for (uint32_t i = 0; i < deferredTasks.Length(); ++i) { + deferredTasks[i]->Run(); + deferredTasks[i] = nullptr; + } + + // One of the deferred tasks may have started a new animation. In this case, + // we want to ask the compositor to schedule a new composite. + requestAnimationFrame |= (mAnimation != nullptr); + + return requestAnimationFrame; +} + +ParentLayerPoint +AsyncPanZoomController::GetCurrentAsyncScrollOffset(AsyncMode aMode) const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + + if (aMode == RESPECT_FORCE_DISABLE && mScrollMetadata.IsApzForceDisabled()) { + return mLastContentPaintMetrics.GetScrollOffset() * mLastContentPaintMetrics.GetZoom(); + } + + return (mFrameMetrics.GetScrollOffset() + mTestAsyncScrollOffset) + * mFrameMetrics.GetZoom() * mTestAsyncZoom.scale; +} + +AsyncTransform +AsyncPanZoomController::GetCurrentAsyncTransform(AsyncMode aMode) const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + + if (aMode == RESPECT_FORCE_DISABLE && mScrollMetadata.IsApzForceDisabled()) { + return AsyncTransform(); + } + + CSSPoint lastPaintScrollOffset; + if (mLastContentPaintMetrics.IsScrollable()) { + lastPaintScrollOffset = mLastContentPaintMetrics.GetScrollOffset(); + } + + CSSPoint currentScrollOffset = mFrameMetrics.GetScrollOffset() + + mTestAsyncScrollOffset; + + // If checkerboarding has been disallowed, clamp the scroll position to stay + // within rendered content. + if (!gfxPrefs::APZAllowCheckerboarding() && + !mLastContentPaintMetrics.GetDisplayPort().IsEmpty()) { + CSSSize compositedSize = mLastContentPaintMetrics.CalculateCompositedSizeInCssPixels(); + CSSPoint maxScrollOffset = lastPaintScrollOffset + + CSSPoint(mLastContentPaintMetrics.GetDisplayPort().XMost() - compositedSize.width, + mLastContentPaintMetrics.GetDisplayPort().YMost() - compositedSize.height); + CSSPoint minScrollOffset = lastPaintScrollOffset + mLastContentPaintMetrics.GetDisplayPort().TopLeft(); + + if (minScrollOffset.x < maxScrollOffset.x) { + currentScrollOffset.x = clamped(currentScrollOffset.x, minScrollOffset.x, maxScrollOffset.x); + } + if (minScrollOffset.y < maxScrollOffset.y) { + currentScrollOffset.y = clamped(currentScrollOffset.y, minScrollOffset.y, maxScrollOffset.y); + } + } + + ParentLayerPoint translation = (currentScrollOffset - lastPaintScrollOffset) + * mFrameMetrics.GetZoom() * mTestAsyncZoom.scale; + + return AsyncTransform( + LayerToParentLayerScale(mFrameMetrics.GetAsyncZoom().scale * mTestAsyncZoom.scale), + -translation); +} + +AsyncTransformComponentMatrix +AsyncPanZoomController::GetCurrentAsyncTransformWithOverscroll(AsyncMode aMode) const +{ + return AsyncTransformComponentMatrix(GetCurrentAsyncTransform(aMode)) + * GetOverscrollTransform(aMode); +} + +Matrix4x4 AsyncPanZoomController::GetTransformToLastDispatchedPaint() const { + ReentrantMonitorAutoEnter lock(mMonitor); + + LayerPoint scrollChange = + (mLastContentPaintMetrics.GetScrollOffset() - mExpectedGeckoMetrics.GetScrollOffset()) + * mLastContentPaintMetrics.GetDevPixelsPerCSSPixel() + * mLastContentPaintMetrics.GetCumulativeResolution(); + + // We're interested in the async zoom change. Factor out the content scale + // that may change when dragging the window to a monitor with a different + // content scale. + LayoutDeviceToParentLayerScale2D lastContentZoom = + mLastContentPaintMetrics.GetZoom() / mLastContentPaintMetrics.GetDevPixelsPerCSSPixel(); + LayoutDeviceToParentLayerScale2D lastDispatchedZoom = + mExpectedGeckoMetrics.GetZoom() / mExpectedGeckoMetrics.GetDevPixelsPerCSSPixel(); + gfxSize zoomChange = lastContentZoom / lastDispatchedZoom; + + return Matrix4x4::Translation(scrollChange.x, scrollChange.y, 0). + PostScale(zoomChange.width, zoomChange.height, 1); +} + +uint32_t +AsyncPanZoomController::GetCheckerboardMagnitude() const +{ + ReentrantMonitorAutoEnter lock(mMonitor); + + CSSPoint currentScrollOffset = mFrameMetrics.GetScrollOffset() + mTestAsyncScrollOffset; + CSSRect painted = mLastContentPaintMetrics.GetDisplayPort() + mLastContentPaintMetrics.GetScrollOffset(); + CSSRect visible = CSSRect(currentScrollOffset, mFrameMetrics.CalculateCompositedSizeInCssPixels()); + + CSSIntRegion checkerboard; + // Round so as to minimize checkerboarding; if we're only showing fractional + // pixels of checkerboarding it's not really worth counting + checkerboard.Sub(RoundedIn(visible), RoundedOut(painted)); + return checkerboard.Area(); +} + +void +AsyncPanZoomController::ReportCheckerboard(const TimeStamp& aSampleTime) +{ + if (mLastCheckerboardReport == aSampleTime) { + // This function will get called multiple times for each APZC on a single + // composite (once for each layer it is attached to). Only report the + // checkerboard once per composite though. + return; + } + mLastCheckerboardReport = aSampleTime; + + bool recordTrace = gfxPrefs::APZRecordCheckerboarding(); + bool forTelemetry = Telemetry::CanRecordExtended(); + uint32_t magnitude = GetCheckerboardMagnitude(); + + MutexAutoLock lock(mCheckerboardEventLock); + if (!mCheckerboardEvent && (recordTrace || forTelemetry)) { + mCheckerboardEvent = MakeUnique(recordTrace); + } + mPotentialCheckerboardTracker.InTransform(IsTransformingState(mState)); + if (magnitude) { + mPotentialCheckerboardTracker.CheckerboardSeen(); + } + UpdateCheckerboardEvent(lock, magnitude); +} + +void +AsyncPanZoomController::UpdateCheckerboardEvent(const MutexAutoLock& aProofOfLock, + uint32_t aMagnitude) +{ + if (mCheckerboardEvent && mCheckerboardEvent->RecordFrameInfo(aMagnitude)) { + // This checkerboard event is done. Report some metrics to telemetry. + mozilla::Telemetry::Accumulate(mozilla::Telemetry::CHECKERBOARD_SEVERITY, + mCheckerboardEvent->GetSeverity()); + mozilla::Telemetry::Accumulate(mozilla::Telemetry::CHECKERBOARD_PEAK, + mCheckerboardEvent->GetPeak()); + mozilla::Telemetry::Accumulate(mozilla::Telemetry::CHECKERBOARD_DURATION, + (uint32_t)mCheckerboardEvent->GetDuration().ToMilliseconds()); + + mPotentialCheckerboardTracker.CheckerboardDone(); + + if (gfxPrefs::APZRecordCheckerboarding()) { + // if the pref is enabled, also send it to the storage class. it may be + // chosen for public display on about:checkerboard, the hall of fame for + // checkerboard events. + uint32_t severity = mCheckerboardEvent->GetSeverity(); + std::string log = mCheckerboardEvent->GetLog(); + CheckerboardEventStorage::Report(severity, log); + } + mCheckerboardEvent = nullptr; + } +} + +void +AsyncPanZoomController::FlushActiveCheckerboardReport() +{ + MutexAutoLock lock(mCheckerboardEventLock); + // Pretend like we got a frame with 0 pixels checkerboarded. This will + // terminate the checkerboard event and flush it out + UpdateCheckerboardEvent(lock, 0); +} + +bool AsyncPanZoomController::IsCurrentlyCheckerboarding() const { + ReentrantMonitorAutoEnter lock(mMonitor); + + if (!gfxPrefs::APZAllowCheckerboarding() || mScrollMetadata.IsApzForceDisabled()) { + return false; + } + + CSSPoint currentScrollOffset = mFrameMetrics.GetScrollOffset() + mTestAsyncScrollOffset; + CSSRect painted = mLastContentPaintMetrics.GetDisplayPort() + mLastContentPaintMetrics.GetScrollOffset(); + painted.Inflate(CSSMargin::FromAppUnits(nsMargin(1, 1, 1, 1))); // fuzz for rounding error + CSSRect visible = CSSRect(currentScrollOffset, mFrameMetrics.CalculateCompositedSizeInCssPixels()); + if (painted.Contains(visible)) { + return false; + } + APZC_LOG_FM(mFrameMetrics, "%p is currently checkerboarding (painted %s visble %s)", + this, Stringify(painted).c_str(), Stringify(visible).c_str()); + return true; +} + +void AsyncPanZoomController::NotifyLayersUpdated(const ScrollMetadata& aScrollMetadata, + bool aIsFirstPaint, + bool aThisLayerTreeUpdated) +{ + APZThreadUtils::AssertOnCompositorThread(); + + ReentrantMonitorAutoEnter lock(mMonitor); + bool isDefault = mScrollMetadata.IsDefault(); + + const FrameMetrics& aLayerMetrics = aScrollMetadata.GetMetrics(); + + if ((aScrollMetadata == mLastContentPaintMetadata) && !isDefault) { + // No new information here, skip it. + APZC_LOG("%p NotifyLayersUpdated short-circuit\n", this); + return; + } + + // If the mFrameMetrics scroll offset is different from the last scroll offset + // that the main-thread sent us, then we know that the user has been doing + // something that triggers a scroll. This check is the APZ equivalent of the + // check on the main-thread at + // https://hg.mozilla.org/mozilla-central/file/97a52326b06a/layout/generic/nsGfxScrollFrame.cpp#l4050 + // There is code below (the use site of userScrolled) that prevents a restored- + // scroll-position update from overwriting a user scroll, again equivalent to + // how the main thread code does the same thing. + CSSPoint lastScrollOffset = mLastContentPaintMetadata.GetMetrics().GetScrollOffset(); + bool userScrolled = + !FuzzyEqualsAdditive(mFrameMetrics.GetScrollOffset().x, lastScrollOffset.x) || + !FuzzyEqualsAdditive(mFrameMetrics.GetScrollOffset().y, lastScrollOffset.y); + + if (aLayerMetrics.GetScrollUpdateType() != FrameMetrics::ScrollOffsetUpdateType::ePending) { + mLastContentPaintMetadata = aScrollMetadata; + } + + mScrollMetadata.SetScrollParentId(aScrollMetadata.GetScrollParentId()); + APZC_LOG_FM(aLayerMetrics, "%p got a NotifyLayersUpdated with aIsFirstPaint=%d, aThisLayerTreeUpdated=%d", + this, aIsFirstPaint, aThisLayerTreeUpdated); + + { // scope lock + MutexAutoLock lock(mCheckerboardEventLock); + if (mCheckerboardEvent && mCheckerboardEvent->IsRecordingTrace()) { + std::string str; + if (aThisLayerTreeUpdated) { + if (!aLayerMetrics.GetPaintRequestTime().IsNull()) { + // Note that we might get the paint request time as non-null, but with + // aThisLayerTreeUpdated false. That can happen if we get a layer transaction + // from a different process right after we get the layer transaction with + // aThisLayerTreeUpdated == true. In this case we want to ignore the + // paint request time because it was already dumped in the previous layer + // transaction. + TimeDuration paintTime = TimeStamp::Now() - aLayerMetrics.GetPaintRequestTime(); + std::stringstream info; + info << " painttime " << paintTime.ToMilliseconds(); + str = info.str(); + } else { + // This might be indicative of a wasted paint particularly if it happens + // during a checkerboard event. + str = " (this layertree updated)"; + } + } + mCheckerboardEvent->UpdateRendertraceProperty( + CheckerboardEvent::Page, aLayerMetrics.GetScrollableRect()); + mCheckerboardEvent->UpdateRendertraceProperty( + CheckerboardEvent::PaintedDisplayPort, + aLayerMetrics.GetDisplayPort() + aLayerMetrics.GetScrollOffset(), + str); + if (!aLayerMetrics.GetCriticalDisplayPort().IsEmpty()) { + mCheckerboardEvent->UpdateRendertraceProperty( + CheckerboardEvent::PaintedCriticalDisplayPort, + aLayerMetrics.GetCriticalDisplayPort() + aLayerMetrics.GetScrollOffset()); + } + } + } + + bool needContentRepaint = false; + bool viewportUpdated = false; + if (FuzzyEqualsAdditive(aLayerMetrics.GetCompositionBounds().width, mFrameMetrics.GetCompositionBounds().width) && + FuzzyEqualsAdditive(aLayerMetrics.GetCompositionBounds().height, mFrameMetrics.GetCompositionBounds().height)) { + // Remote content has sync'd up to the composition geometry + // change, so we can accept the viewport it's calculated. + if (mFrameMetrics.GetViewport().width != aLayerMetrics.GetViewport().width || + mFrameMetrics.GetViewport().height != aLayerMetrics.GetViewport().height) { + needContentRepaint = true; + viewportUpdated = true; + } + mFrameMetrics.SetViewport(aLayerMetrics.GetViewport()); + } + + // If the layers update was not triggered by our own repaint request, then + // we want to take the new scroll offset. Check the scroll generation as well + // to filter duplicate calls to NotifyLayersUpdated with the same scroll offset + // update message. + bool scrollOffsetUpdated = aLayerMetrics.GetScrollOffsetUpdated() + && (aLayerMetrics.GetScrollGeneration() != mFrameMetrics.GetScrollGeneration()); + + if (scrollOffsetUpdated && userScrolled && + aLayerMetrics.GetScrollUpdateType() == FrameMetrics::ScrollOffsetUpdateType::eRestore) { + APZC_LOG("%p dropping scroll update of type eRestore because of user scroll\n", this); + scrollOffsetUpdated = false; + } + + bool smoothScrollRequested = aLayerMetrics.GetDoSmoothScroll() + && (aLayerMetrics.GetScrollGeneration() != mFrameMetrics.GetScrollGeneration()); + + // TODO if we're in a drag and scrollOffsetUpdated is set then we want to + // ignore it + + if ((aIsFirstPaint && aThisLayerTreeUpdated) || isDefault) { + // Initialize our internal state to something sane when the content + // that was just painted is something we knew nothing about previously + CancelAnimation(); + + mScrollMetadata = aScrollMetadata; + mExpectedGeckoMetrics = aLayerMetrics; + ShareCompositorFrameMetrics(); + + if (mFrameMetrics.GetDisplayPortMargins() != ScreenMargin()) { + // A non-zero display port margin here indicates a displayport has + // been set by a previous APZC for the content at this guid. The + // scrollable rect may have changed since then, making the margins + // wrong, so we need to calculate a new display port. + APZC_LOG("%p detected non-empty margins which probably need updating\n", this); + needContentRepaint = true; + } + } else { + // If we're not taking the aLayerMetrics wholesale we still need to pull + // in some things into our local mFrameMetrics because these things are + // determined by Gecko and our copy in mFrameMetrics may be stale. + + if (FuzzyEqualsAdditive(mFrameMetrics.GetCompositionBounds().width, aLayerMetrics.GetCompositionBounds().width) && + mFrameMetrics.GetDevPixelsPerCSSPixel() == aLayerMetrics.GetDevPixelsPerCSSPixel() && + !viewportUpdated) { + // Any change to the pres shell resolution was requested by APZ and is + // already included in our zoom; however, other components of the + // cumulative resolution (a parent document's pres-shell resolution, or + // the css-driven resolution) may have changed, and we need to update + // our zoom to reflect that. Note that we can't just take + // aLayerMetrics.mZoom because the APZ may have additional async zoom + // since the repaint request. + gfxSize totalResolutionChange = aLayerMetrics.GetCumulativeResolution() + / mFrameMetrics.GetCumulativeResolution(); + float presShellResolutionChange = aLayerMetrics.GetPresShellResolution() + / mFrameMetrics.GetPresShellResolution(); + if (presShellResolutionChange != 1.0f) { + needContentRepaint = true; + } + mFrameMetrics.ZoomBy(totalResolutionChange / presShellResolutionChange); + } else { + // Take the new zoom as either device scale or composition width or + // viewport size got changed (e.g. due to orientation change, or content + // changing the meta-viewport tag). + mFrameMetrics.SetZoom(aLayerMetrics.GetZoom()); + mFrameMetrics.SetDevPixelsPerCSSPixel(aLayerMetrics.GetDevPixelsPerCSSPixel()); + } + if (!mFrameMetrics.GetScrollableRect().IsEqualEdges(aLayerMetrics.GetScrollableRect())) { + mFrameMetrics.SetScrollableRect(aLayerMetrics.GetScrollableRect()); + needContentRepaint = true; + } + mFrameMetrics.SetCompositionBounds(aLayerMetrics.GetCompositionBounds()); + mFrameMetrics.SetRootCompositionSize(aLayerMetrics.GetRootCompositionSize()); + mFrameMetrics.SetPresShellResolution(aLayerMetrics.GetPresShellResolution()); + mFrameMetrics.SetCumulativeResolution(aLayerMetrics.GetCumulativeResolution()); + mScrollMetadata.SetHasScrollgrab(aScrollMetadata.GetHasScrollgrab()); + mScrollMetadata.SetLineScrollAmount(aScrollMetadata.GetLineScrollAmount()); + mScrollMetadata.SetPageScrollAmount(aScrollMetadata.GetPageScrollAmount()); + mScrollMetadata.SetSnapInfo(ScrollSnapInfo(aScrollMetadata.GetSnapInfo())); + // The scroll clip can differ between layers associated a given scroll frame, + // so APZC (which keeps a single copy of ScrollMetadata per scroll frame) + // has no business using it. + mScrollMetadata.SetScrollClip(Nothing()); + mScrollMetadata.SetIsLayersIdRoot(aScrollMetadata.IsLayersIdRoot()); + mScrollMetadata.SetUsesContainerScrolling(aScrollMetadata.UsesContainerScrolling()); + mFrameMetrics.SetIsScrollInfoLayer(aLayerMetrics.IsScrollInfoLayer()); + mScrollMetadata.SetForceDisableApz(aScrollMetadata.IsApzForceDisabled()); + + if (scrollOffsetUpdated) { + APZC_LOG("%p updating scroll offset from %s to %s\n", this, + ToString(mFrameMetrics.GetScrollOffset()).c_str(), + ToString(aLayerMetrics.GetScrollOffset()).c_str()); + + // Send an acknowledgement with the new scroll generation so that any + // repaint requests later in this function go through. + // Because of the scroll generation update, any inflight paint requests are + // going to be ignored by layout, and so mExpectedGeckoMetrics + // becomes incorrect for the purposes of calculating the LD transform. To + // correct this we need to update mExpectedGeckoMetrics to be the + // last thing we know was painted by Gecko. + mFrameMetrics.CopyScrollInfoFrom(aLayerMetrics); + mExpectedGeckoMetrics = aLayerMetrics; + + // Cancel the animation (which might also trigger a repaint request) + // after we update the scroll offset above. Otherwise we can be left + // in a state where things are out of sync. + CancelAnimation(); + + // Since the scroll offset has changed, we need to recompute the + // displayport margins and send them to layout. Otherwise there might be + // scenarios where for example we scroll from the top of a page (where the + // top displayport margin is zero) to the bottom of a page, which will + // result in a displayport that doesn't extend upwards at all. + // Note that even if the CancelAnimation call above requested a repaint + // this is fine because we already have repaint request deduplication. + needContentRepaint = true; + } + } + + if (smoothScrollRequested) { + // A smooth scroll has been requested for animation on the compositor + // thread. This flag will be reset by the main thread when it receives + // the scroll update acknowledgement. + + APZC_LOG("%p smooth scrolling from %s to %s in state %d\n", this, + Stringify(mFrameMetrics.GetScrollOffset()).c_str(), + Stringify(aLayerMetrics.GetSmoothScrollOffset()).c_str(), + mState); + + // See comment on the similar code in the |if (scrollOffsetUpdated)| block + // above. + mFrameMetrics.CopySmoothScrollInfoFrom(aLayerMetrics); + needContentRepaint = true; + mExpectedGeckoMetrics = aLayerMetrics; + + SmoothScrollTo(mFrameMetrics.GetSmoothScrollOffset()); + } + + if (needContentRepaint) { + // This repaint request is not driven by a user action on the APZ side + RequestContentRepaint(false); + } + UpdateSharedCompositorFrameMetrics(); +} + +const FrameMetrics& AsyncPanZoomController::GetFrameMetrics() const { + mMonitor.AssertCurrentThreadIn(); + return mFrameMetrics; +} + +APZCTreeManager* AsyncPanZoomController::GetApzcTreeManager() const { + mMonitor.AssertNotCurrentThreadIn(); + return mTreeManager; +} + +void AsyncPanZoomController::ZoomToRect(CSSRect aRect, const uint32_t aFlags) { + if (!aRect.IsFinite()) { + NS_WARNING("ZoomToRect got called with a non-finite rect; ignoring..."); + return; + } else if (aRect.IsEmpty() && (aFlags & DISABLE_ZOOM_OUT)) { + // Double-tap-to-zooming uses an empty rect to mean "zoom out". + // If zooming out is disabled, an empty rect is nonsensical + // and will produce undesirable scrolling. + NS_WARNING("ZoomToRect got called with an empty rect and zoom out disabled; ignoring..."); + return; + } + + // Only the root APZC is zoomable, and the root APZC is not allowed to have + // different x and y scales. If it did, the calculations in this function + // would have to be adjusted (as e.g. it would no longer be valid to take + // the minimum or maximum of the ratios of the widths and heights of the + // page rect and the composition bounds). + MOZ_ASSERT(mFrameMetrics.IsRootContent()); + MOZ_ASSERT(mFrameMetrics.GetZoom().AreScalesSame()); + + SetState(ANIMATING_ZOOM); + + { + ReentrantMonitorAutoEnter lock(mMonitor); + + ParentLayerRect compositionBounds = mFrameMetrics.GetCompositionBounds(); + CSSRect cssPageRect = mFrameMetrics.GetScrollableRect(); + CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset(); + CSSToParentLayerScale currentZoom = mFrameMetrics.GetZoom().ToScaleFactor(); + CSSToParentLayerScale targetZoom; + + // The minimum zoom to prevent over-zoom-out. + // If the zoom factor is lower than this (i.e. we are zoomed more into the page), + // then the CSS content rect, in layers pixels, will be smaller than the + // composition bounds. If this happens, we can't fill the target composited + // area with this frame. + CSSToParentLayerScale localMinZoom(std::max(mZoomConstraints.mMinZoom.scale, + std::max(compositionBounds.width / cssPageRect.width, + compositionBounds.height / cssPageRect.height))); + CSSToParentLayerScale localMaxZoom = mZoomConstraints.mMaxZoom; + + if (!aRect.IsEmpty()) { + // Intersect the zoom-to-rect to the CSS rect to make sure it fits. + aRect = aRect.Intersect(cssPageRect); + targetZoom = CSSToParentLayerScale(std::min(compositionBounds.width / aRect.width, + compositionBounds.height / aRect.height)); + } + + // 1. If the rect is empty, the content-side logic for handling a double-tap + // requested that we zoom out. + // 2. currentZoom is equal to mZoomConstraints.mMaxZoom and user still double-tapping it + // 3. currentZoom is equal to localMinZoom and user still double-tapping it + // Treat these three cases as a request to zoom out as much as possible. + bool zoomOut; + if (aFlags & DISABLE_ZOOM_OUT) { + zoomOut = false; + } else { + zoomOut = aRect.IsEmpty() || + (currentZoom == localMaxZoom && targetZoom >= localMaxZoom) || + (currentZoom == localMinZoom && targetZoom <= localMinZoom); + } + + if (zoomOut) { + CSSSize compositedSize = mFrameMetrics.CalculateCompositedSizeInCssPixels(); + float y = scrollOffset.y; + float newHeight = + cssPageRect.width * (compositedSize.height / compositedSize.width); + float dh = compositedSize.height - newHeight; + + aRect = CSSRect(0.0f, + y + dh/2, + cssPageRect.width, + newHeight); + aRect = aRect.Intersect(cssPageRect); + targetZoom = CSSToParentLayerScale(std::min(compositionBounds.width / aRect.width, + compositionBounds.height / aRect.height)); + } + + targetZoom.scale = clamped(targetZoom.scale, localMinZoom.scale, localMaxZoom.scale); + FrameMetrics endZoomToMetrics = mFrameMetrics; + if (aFlags & PAN_INTO_VIEW_ONLY) { + targetZoom = currentZoom; + } else if(aFlags & ONLY_ZOOM_TO_DEFAULT_SCALE) { + CSSToParentLayerScale zoomAtDefaultScale = + mFrameMetrics.GetDevPixelsPerCSSPixel() * LayoutDeviceToParentLayerScale(1.0); + if (targetZoom.scale > zoomAtDefaultScale.scale) { + // Only change the zoom if we are less than the default zoom + if (currentZoom.scale < zoomAtDefaultScale.scale) { + targetZoom = zoomAtDefaultScale; + } else { + targetZoom = currentZoom; + } + } + } + endZoomToMetrics.SetZoom(CSSToParentLayerScale2D(targetZoom)); + + // Adjust the zoomToRect to a sensible position to prevent overscrolling. + CSSSize sizeAfterZoom = endZoomToMetrics.CalculateCompositedSizeInCssPixels(); + + // Vertically center the zoomed element in the screen. + if (!zoomOut && (sizeAfterZoom.height > aRect.height)) { + aRect.y -= (sizeAfterZoom.height - aRect.height) * 0.5f; + if (aRect.y < 0.0f) { + aRect.y = 0.0f; + } + } + + // If either of these conditions are met, the page will be + // overscrolled after zoomed + if (aRect.y + sizeAfterZoom.height > cssPageRect.height) { + aRect.y = cssPageRect.height - sizeAfterZoom.height; + aRect.y = aRect.y > 0 ? aRect.y : 0; + } + if (aRect.x + sizeAfterZoom.width > cssPageRect.width) { + aRect.x = cssPageRect.width - sizeAfterZoom.width; + aRect.x = aRect.x > 0 ? aRect.x : 0; + } + + endZoomToMetrics.SetScrollOffset(aRect.TopLeft()); + + StartAnimation(new ZoomAnimation( + mFrameMetrics.GetScrollOffset(), + mFrameMetrics.GetZoom(), + endZoomToMetrics.GetScrollOffset(), + endZoomToMetrics.GetZoom())); + + // Schedule a repaint now, so the new displayport will be painted before the + // animation finishes. + ParentLayerPoint velocity(0, 0); + endZoomToMetrics.SetDisplayPortMargins( + CalculatePendingDisplayPort(endZoomToMetrics, velocity)); + endZoomToMetrics.SetUseDisplayPortMargins(true); + endZoomToMetrics.SetPaintRequestTime(TimeStamp::Now()); + endZoomToMetrics.SetRepaintDrivenByUserAction(true); + + RefPtr controller = GetGeckoContentController(); + if (!controller) { + return; + } + if (controller->IsRepaintThread()) { + RequestContentRepaint(endZoomToMetrics, velocity); + } else { + // use a local var to resolve the function overload + auto func = static_cast + (&AsyncPanZoomController::RequestContentRepaint); + controller->DispatchToRepaintThread( + NewRunnableMethod( + this, func, endZoomToMetrics, velocity)); + } + } +} + +CancelableBlockState* +AsyncPanZoomController::GetCurrentInputBlock() const +{ + return GetInputQueue()->GetCurrentBlock(); +} + +TouchBlockState* +AsyncPanZoomController::GetCurrentTouchBlock() const +{ + return GetInputQueue()->GetCurrentTouchBlock(); +} + +PanGestureBlockState* +AsyncPanZoomController::GetCurrentPanGestureBlock() const +{ + return GetInputQueue()->GetCurrentPanGestureBlock(); +} + +void +AsyncPanZoomController::ResetTouchInputState() +{ + MultiTouchInput cancel(MultiTouchInput::MULTITOUCH_CANCEL, 0, TimeStamp::Now(), 0); + RefPtr listener = GetGestureEventListener(); + if (listener) { + listener->HandleInputEvent(cancel); + } + CancelAnimationAndGestureState(); + // Clear overscroll along the entire handoff chain, in case an APZC + // later in the chain is overscrolled. + if (TouchBlockState* block = GetCurrentTouchBlock()) { + block->GetOverscrollHandoffChain()->ClearOverscroll(); + } +} + +void +AsyncPanZoomController::CancelAnimationAndGestureState() +{ + mX.CancelGesture(); + mY.CancelGesture(); + CancelAnimation(CancelAnimationFlags::ScrollSnap); +} + +bool +AsyncPanZoomController::HasReadyTouchBlock() const +{ + return GetInputQueue()->HasReadyTouchBlock(); +} + +void AsyncPanZoomController::SetState(PanZoomState aNewState) +{ + PanZoomState oldState; + + // Intentional scoping for mutex + { + ReentrantMonitorAutoEnter lock(mMonitor); + APZC_LOG("%p changing from state %d to %d\n", this, mState, aNewState); + oldState = mState; + mState = aNewState; + } + + DispatchStateChangeNotification(oldState, aNewState); +} + +void AsyncPanZoomController::DispatchStateChangeNotification(PanZoomState aOldState, + PanZoomState aNewState) +{ + { // scope the lock + ReentrantMonitorAutoEnter lock(mMonitor); + if (mNotificationBlockers > 0) { + return; + } + } + + if (RefPtr controller = GetGeckoContentController()) { + if (!IsTransformingState(aOldState) && IsTransformingState(aNewState)) { + controller->NotifyAPZStateChange( + GetGuid(), APZStateChange::eTransformBegin); +#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) + // Let the compositor know about scroll state changes so it can manage + // windowed plugins. + if (gfxPrefs::HidePluginsForScroll() && mCompositorController) { + mCompositorController->ScheduleHideAllPluginWindows(); + } +#endif + } else if (IsTransformingState(aOldState) && !IsTransformingState(aNewState)) { + controller->NotifyAPZStateChange( + GetGuid(), APZStateChange::eTransformEnd); +#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) + if (gfxPrefs::HidePluginsForScroll() && mCompositorController) { + mCompositorController->ScheduleShowAllPluginWindows(); + } +#endif + } + } +} + +bool AsyncPanZoomController::IsTransformingState(PanZoomState aState) { + return !(aState == NOTHING || aState == TOUCHING); +} + +bool AsyncPanZoomController::IsInPanningState() const { + return (mState == PANNING || mState == PANNING_LOCKED_X || mState == PANNING_LOCKED_Y); +} + +void AsyncPanZoomController::UpdateZoomConstraints(const ZoomConstraints& aConstraints) { + APZC_LOG("%p updating zoom constraints to %d %d %f %f\n", this, aConstraints.mAllowZoom, + aConstraints.mAllowDoubleTapZoom, aConstraints.mMinZoom.scale, aConstraints.mMaxZoom.scale); + if (IsNaN(aConstraints.mMinZoom.scale) || IsNaN(aConstraints.mMaxZoom.scale)) { + NS_WARNING("APZC received zoom constraints with NaN values; dropping..."); + return; + } + + CSSToParentLayerScale min = mFrameMetrics.GetDevPixelsPerCSSPixel() + * kViewportMinScale / ParentLayerToScreenScale(1); + CSSToParentLayerScale max = mFrameMetrics.GetDevPixelsPerCSSPixel() + * kViewportMaxScale / ParentLayerToScreenScale(1); + + // inf float values and other bad cases should be sanitized by the code below. + mZoomConstraints.mAllowZoom = aConstraints.mAllowZoom; + mZoomConstraints.mAllowDoubleTapZoom = aConstraints.mAllowDoubleTapZoom; + mZoomConstraints.mMinZoom = (min > aConstraints.mMinZoom ? min : aConstraints.mMinZoom); + mZoomConstraints.mMaxZoom = (max > aConstraints.mMaxZoom ? aConstraints.mMaxZoom : max); + if (mZoomConstraints.mMaxZoom < mZoomConstraints.mMinZoom) { + mZoomConstraints.mMaxZoom = mZoomConstraints.mMinZoom; + } +} + +ZoomConstraints +AsyncPanZoomController::GetZoomConstraints() const +{ + return mZoomConstraints; +} + + +void AsyncPanZoomController::PostDelayedTask(already_AddRefed aTask, int aDelayMs) { + APZThreadUtils::AssertOnControllerThread(); + RefPtr task = aTask; + RefPtr controller = GetGeckoContentController(); + if (controller) { + controller->PostDelayedTask(task.forget(), aDelayMs); + } + // If there is no controller, that means this APZC has been destroyed, and + // we probably don't need to run the task. It will get destroyed when the + // RefPtr goes out of scope. +} + +bool AsyncPanZoomController::Matches(const ScrollableLayerGuid& aGuid) +{ + return aGuid == GetGuid(); +} + +bool AsyncPanZoomController::HasTreeManager(const APZCTreeManager* aTreeManager) const +{ + return GetApzcTreeManager() == aTreeManager; +} + +void AsyncPanZoomController::GetGuid(ScrollableLayerGuid* aGuidOut) const +{ + if (aGuidOut) { + *aGuidOut = GetGuid(); + } +} + +ScrollableLayerGuid AsyncPanZoomController::GetGuid() const +{ + return ScrollableLayerGuid(mLayersId, mFrameMetrics); +} + +void AsyncPanZoomController::UpdateSharedCompositorFrameMetrics() +{ + mMonitor.AssertCurrentThreadIn(); + + FrameMetrics* frame = mSharedFrameMetricsBuffer ? + static_cast(mSharedFrameMetricsBuffer->memory()) : nullptr; + + if (frame && mSharedLock && gfxPrefs::ProgressivePaint()) { + mSharedLock->Lock(); + *frame = mFrameMetrics; + mSharedLock->Unlock(); + } +} + +void AsyncPanZoomController::ShareCompositorFrameMetrics() +{ + APZThreadUtils::AssertOnCompositorThread(); + + // Only create the shared memory buffer if it hasn't already been created, + // we are using progressive tile painting, and we have a + // controller to pass the shared memory back to the content process/thread. + if (!mSharedFrameMetricsBuffer && mMetricsSharingController && gfxPrefs::ProgressivePaint()) { + + // Create shared memory and initialize it with the current FrameMetrics value + mSharedFrameMetricsBuffer = new ipc::SharedMemoryBasic; + FrameMetrics* frame = nullptr; + mSharedFrameMetricsBuffer->Create(sizeof(FrameMetrics)); + mSharedFrameMetricsBuffer->Map(sizeof(FrameMetrics)); + frame = static_cast(mSharedFrameMetricsBuffer->memory()); + + if (frame) { + + { // scope the monitor, only needed to copy the FrameMetrics. + ReentrantMonitorAutoEnter lock(mMonitor); + *frame = mFrameMetrics; + } + + // Get the process id of the content process + base::ProcessId otherPid = mMetricsSharingController->RemotePid(); + ipc::SharedMemoryBasic::Handle mem = ipc::SharedMemoryBasic::NULLHandle(); + + // Get the shared memory handle to share with the content process + mSharedFrameMetricsBuffer->ShareToProcess(otherPid, &mem); + + // Get the cross process mutex handle to share with the content process + mSharedLock = new CrossProcessMutex("AsyncPanZoomControlLock"); + CrossProcessMutexHandle handle = mSharedLock->ShareToProcess(otherPid); + + // Send the shared memory handle and cross process handle to the content + // process by an asynchronous ipc call. Include the APZC unique ID + // so the content process know which APZC sent this shared FrameMetrics. + if (!mMetricsSharingController->StartSharingMetrics(mem, handle, mLayersId, mAPZCId)) { + APZC_LOG("%p failed to share FrameMetrics with content process.", this); + } + } + } +} + +Maybe AsyncPanZoomController::FindSnapPointNear( + const CSSPoint& aDestination, nsIScrollableFrame::ScrollUnit aUnit) { + mMonitor.AssertCurrentThreadIn(); + APZC_LOG("%p scroll snapping near %s\n", this, Stringify(aDestination).c_str()); + CSSRect scrollRange = mFrameMetrics.CalculateScrollRange(); + if (Maybe snapPoint = ScrollSnapUtils::GetSnapPointForDestination( + mScrollMetadata.GetSnapInfo(), + aUnit, + CSSSize::ToAppUnits(mFrameMetrics.CalculateCompositedSizeInCssPixels()), + CSSRect::ToAppUnits(scrollRange), + CSSPoint::ToAppUnits(mFrameMetrics.GetScrollOffset()), + CSSPoint::ToAppUnits(aDestination))) { + CSSPoint cssSnapPoint = CSSPoint::FromAppUnits(snapPoint.ref()); + // GetSnapPointForDestination() can produce a destination that's outside + // of the scroll frame's scroll range. Clamp it here (this matches the + // behaviour of the main-thread code path, which clamps it in + // nsGfxScrollFrame::ScrollTo()). + return Some(scrollRange.ClampPoint(cssSnapPoint)); + } + return Nothing(); +} + +void AsyncPanZoomController::ScrollSnapNear(const CSSPoint& aDestination) { + if (Maybe snapPoint = + FindSnapPointNear(aDestination, nsIScrollableFrame::DEVICE_PIXELS)) { + if (*snapPoint != mFrameMetrics.GetScrollOffset()) { + APZC_LOG("%p smooth scrolling to snap point %s\n", this, Stringify(*snapPoint).c_str()); + SmoothScrollTo(*snapPoint); + } + } +} + +void AsyncPanZoomController::ScrollSnap() { + ReentrantMonitorAutoEnter lock(mMonitor); + ScrollSnapNear(mFrameMetrics.GetScrollOffset()); +} + +void AsyncPanZoomController::ScrollSnapToDestination() { + ReentrantMonitorAutoEnter lock(mMonitor); + + float friction = gfxPrefs::APZFlingFriction(); + ParentLayerPoint velocity(mX.GetVelocity(), mY.GetVelocity()); + ParentLayerPoint predictedDelta; + // "-velocity / log(1.0 - friction)" is the integral of the deceleration + // curve modeled for flings in the "Axis" class. + if (velocity.x != 0.0f) { + predictedDelta.x = -velocity.x / log(1.0 - friction); + } + if (velocity.y != 0.0f) { + predictedDelta.y = -velocity.y / log(1.0 - friction); + } + CSSPoint predictedDestination = mFrameMetrics.GetScrollOffset() + predictedDelta / mFrameMetrics.GetZoom(); + + // If the fling will overscroll, don't scroll snap, because then the user + // user would not see any overscroll animation. + bool flingWillOverscroll = IsOverscrolled() && ((velocity.x * mX.GetOverscroll() >= 0) || + (velocity.y * mY.GetOverscroll() >= 0)); + if (!flingWillOverscroll) { + APZC_LOG("%p fling snapping. friction: %f velocity: %f, %f " + "predictedDelta: %f, %f position: %f, %f " + "predictedDestination: %f, %f\n", + this, friction, velocity.x, velocity.y, (float)predictedDelta.x, + (float)predictedDelta.y, (float)mFrameMetrics.GetScrollOffset().x, + (float)mFrameMetrics.GetScrollOffset().y, + (float)predictedDestination.x, (float)predictedDestination.y); + + ScrollSnapNear(predictedDestination); + } +} + +bool AsyncPanZoomController::MaybeAdjustDeltaForScrollSnapping( + const ScrollWheelInput& aEvent, + ParentLayerPoint& aDelta, + CSSPoint& aStartPosition) +{ + // Don't scroll snap for pixel scrolls. This matches the main thread + // behaviour in EventStateManager::DoScrollText(). + if (aEvent.mDeltaType == ScrollWheelInput::SCROLLDELTA_PIXEL) { + return false; + } + + ReentrantMonitorAutoEnter lock(mMonitor); + CSSToParentLayerScale2D zoom = mFrameMetrics.GetZoom(); + CSSPoint destination = mFrameMetrics.CalculateScrollRange().ClampPoint( + aStartPosition + (aDelta / zoom)); + nsIScrollableFrame::ScrollUnit unit = + ScrollWheelInput::ScrollUnitForDeltaType(aEvent.mDeltaType); + + if (Maybe snapPoint = FindSnapPointNear(destination, unit)) { + aDelta = (*snapPoint - aStartPosition) * zoom; + aStartPosition = *snapPoint; + return true; + } + return false; +} + +} // namespace layers +} // namespace mozilla -- cgit v1.2.3