The Tor Browser: comparison gfx/layers/apz/src/AsyncPanZoomController.cpp

--1:000000000000
+:f5933a9f9a23
+/* -*- 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 <math.h>                       // for fabsf, fabs, atan2
+#include <stdint.h>                     // for uint32_t, uint64_t
+#include <sys/types.h>                  // for int32_t
+#include <algorithm>                    // for max, min
+#include "AnimationCommon.h"            // for ComputedTimingFunction
+#include "AsyncPanZoomController.h"     // for AsyncPanZoomController, etc
+#include "CompositorParent.h"           // for CompositorParent
+#include "FrameMetrics.h"               // for FrameMetrics, etc
+#include "GestureEventListener.h"       // for GestureEventListener
+#include "InputData.h"                  // for MultiTouchInput, etc
+#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 "base/tracked.h"               // for FROM_HERE
+#include "gfxPrefs.h"                   // for gfxPrefs
+#include "gfxTypes.h"                   // for gfxFloat
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+#include "mozilla/BasicEvents.h"        // for Modifiers, MODIFIER_*
+#include "mozilla/ClearOnShutdown.h"    // for ClearOnShutdown
+#include "mozilla/Constants.h"          // for M_PI
+#include "mozilla/EventForwards.h"      // for nsEventStatus_*
+#include "mozilla/Preferences.h"        // for Preferences
+#include "mozilla/ReentrantMonitor.h"   // for ReentrantMonitorAutoEnter, etc
+#include "mozilla/StaticPtr.h"          // for StaticAutoPtr
+#include "mozilla/TimeStamp.h"          // for TimeDuration, TimeStamp
+#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/AsyncCompositionManager.h"  // for ViewTransform
+#include "mozilla/layers/Axis.h"        // for AxisX, AxisY, Axis, etc
+#include "mozilla/layers/LayerTransactionParent.h" // for LayerTransactionParent
+#include "mozilla/layers/PCompositorParent.h" // for PCompositorParent
+#include "mozilla/layers/TaskThrottler.h"  // for TaskThrottler
+#include "mozilla/mozalloc.h"           // for operator new, etc
+#include "mozilla/unused.h"             // for unused
+#include "mozilla/FloatingPoint.h"      // for FuzzyEqualsMultiplicative
+#include "nsAlgorithm.h"                // for clamped
+#include "nsAutoPtr.h"                  // for nsRefPtr
+#include "nsCOMPtr.h"                   // for already_AddRefed
+#include "nsDebug.h"                    // for NS_WARNING
+#include "nsIDOMWindowUtils.h"          // for nsIDOMWindowUtils
+#include "nsISupportsImpl.h"            // for MOZ_COUNT_CTOR, etc
+#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 "SharedMemoryBasic.h"          // for SharedMemoryBasic
+// #define APZC_ENABLE_RENDERTRACE
+#define APZC_LOG(...)
+// #define APZC_LOG(...) printf_stderr("APZC: " __VA_ARGS__)
+#define APZC_LOG_FM(fm, prefix, ...) \
+APZC_LOG(prefix ":" \
+" i=(%ld %lld) cb=(%d %d %d %d) rcs=(%.3f %.3f) dp=(%.3f %.3f %.3f %.3f) dpm=(%.3f %.3f %.3f %.3f) um=%d " \
+"v=(%.3f %.3f %.3f %.3f) s=(%.3f %.3f) sr=(%.3f %.3f %.3f %.3f) z=(%.3f %.3f %.3f %.3f) u=(%d %lu)\n", \
+__VA_ARGS__, \
+fm.mPresShellId, fm.GetScrollId(), \
+fm.mCompositionBounds.x, fm.mCompositionBounds.y, fm.mCompositionBounds.width, fm.mCompositionBounds.height, \
+fm.GetRootCompositionSize().width, fm.GetRootCompositionSize().height, \
+fm.mDisplayPort.x, fm.mDisplayPort.y, fm.mDisplayPort.width, fm.mDisplayPort.height, \
+fm.GetDisplayPortMargins().top, fm.GetDisplayPortMargins().right, fm.GetDisplayPortMargins().bottom, fm.GetDisplayPortMargins().left, \
+fm.GetUseDisplayPortMargins() ? 1 : 0, \
+fm.mViewport.x, fm.mViewport.y, fm.mViewport.width, fm.mViewport.height, \
+fm.GetScrollOffset().x, fm.GetScrollOffset().y, \
+fm.mScrollableRect.x, fm.mScrollableRect.y, fm.mScrollableRect.width, fm.mScrollableRect.height, \
+fm.mDevPixelsPerCSSPixel.scale, fm.mResolution.scale, fm.mCumulativeResolution.scale, fm.GetZoom().scale, \
+fm.GetScrollOffsetUpdated(), fm.GetScrollGeneration()); \
+// Static helper functions
+namespace {
+int32_t
+WidgetModifiersToDOMModifiers(mozilla::Modifiers aModifiers)
+{
+int32_t result = 0;
+if (aModifiers & mozilla::MODIFIER_SHIFT) {
+result |= nsIDOMWindowUtils::MODIFIER_SHIFT;
+}
+if (aModifiers & mozilla::MODIFIER_CONTROL) {
+result |= nsIDOMWindowUtils::MODIFIER_CONTROL;
+}
+if (aModifiers & mozilla::MODIFIER_ALT) {
+result |= nsIDOMWindowUtils::MODIFIER_ALT;
+}
+if (aModifiers & mozilla::MODIFIER_META) {
+result |= nsIDOMWindowUtils::MODIFIER_META;
+}
+if (aModifiers & mozilla::MODIFIER_ALTGRAPH) {
+result |= nsIDOMWindowUtils::MODIFIER_ALTGRAPH;
+}
+if (aModifiers & mozilla::MODIFIER_CAPSLOCK) {
+result |= nsIDOMWindowUtils::MODIFIER_CAPSLOCK;
+}
+if (aModifiers & mozilla::MODIFIER_FN) {
+result |= nsIDOMWindowUtils::MODIFIER_FN;
+}
+if (aModifiers & mozilla::MODIFIER_NUMLOCK) {
+result |= nsIDOMWindowUtils::MODIFIER_NUMLOCK;
+}
+if (aModifiers & mozilla::MODIFIER_SCROLLLOCK) {
+result |= nsIDOMWindowUtils::MODIFIER_SCROLLLOCK;
+}
+if (aModifiers & mozilla::MODIFIER_SYMBOLLOCK) {
+result |= nsIDOMWindowUtils::MODIFIER_SYMBOLLOCK;
+}
+if (aModifiers & mozilla::MODIFIER_OS) {
+result |= nsIDOMWindowUtils::MODIFIER_OS;
+}
+return result;
+}
+}
+using namespace mozilla::css;
+namespace mozilla {
+namespace layers {
+typedef mozilla::layers::AllowedTouchBehavior AllowedTouchBehavior;
+typedef GeckoContentController::APZStateChange APZStateChange;
+/*
+* The following prefs are used to control the behaviour of the APZC.
+* The default values are provided in gfxPrefs.h.
+*
+* "apz.allow-checkerboarding"
+* Pref that allows or disallows checkerboarding
+*
+* "apz.asyncscroll.throttle"
+* The time period in ms that throttles mozbrowserasyncscroll event.
+*
+* "apz.asyncscroll.timeout"
+* The timeout in ms for mAsyncScrollTimeoutTask delay task.
+*
+* "apz.axis_lock_mode"
+* The preferred axis locking style. See AxisLockMode for possible values.
+*
+* "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.
+*
+* "apz.cross_slide_enabled"
+* Pref that enables integration with the Metro "cross-slide" gesture.
+*
+* "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.
+*
+* "apz.fling_friction"
+* Amount of friction applied during flings.
+*
+* "apz.fling_repaint_interval"
+* Maximum amount of time flinging before sending a viewport change. This will
+* asynchronously repaint the page.
+*
+* "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.
+*
+* "apz.max_velocity_inches_per_ms"
+* Maximum velocity in inches per millisecond.  Velocity will be capped at this
+* value if a faster fling occurs.  Negative values indicate unlimited velocity.
+*
+* "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.
+*
+* "apz.min_skate_speed"
+* Minimum amount of speed along an axis before we switch to "skate" multipliers
+* rather than using the "stationary" multipliers.
+*
+* "apz.num_paint_duration_samples"
+* Number of samples to store of how long it took to paint after the previous
+* requests.
+*
+* "apz.pan_repaint_interval"
+* Maximum amount of time while panning before sending a viewport change. This
+* will asynchronously repaint the page. It is also forced when panning stops.
+*
+* "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.
+*
+* "apz.use_paint_duration"
+* Whether or not to use the estimated paint duration as a factor when projecting
+* the displayport in the direction of scrolling. If this value is set to false,
+* a constant 50ms paint time is used; the projection can be scaled as desired
+* using the apz.velocity_bias pref below.
+*
+* "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.
+*
+* "apz.x_skate_size_multiplier", "apz.y_skate_size_multiplier"
+* The multiplier we apply to the displayport size if it is skating (current
+* velocity is above 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
+* that scrolls up/down. Note that one, both or neither of these may be used
+* at any instant.
+* In general we want 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.
+*
+* "apz.x_stationary_size_multiplier", "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).
+*/
+/**
+* Default touch behavior (is used when not touch behavior is set).
+*/
+static const uint32_t DefaultTouchBehavior = AllowedTouchBehavior::VERTICAL_PAN |
+AllowedTouchBehavior::HORIZONTAL_PAN |
+AllowedTouchBehavior::PINCH_ZOOM |
+AllowedTouchBehavior::DOUBLE_TAP_ZOOM;
+/**
+* Angle from axis within which we stay axis-locked
+*/
+static const double AXIS_LOCK_ANGLE = M_PI / 6.0; // 30 degrees
+/**
+* The distance in inches the user must pan before axis lock can be broken
+*/
+static const float AXIS_BREAKOUT_THRESHOLD = 1.0f/32.0f;
+/**
+* The angle at which axis lock can be broken
+*/
+static const double AXIS_BREAKOUT_ANGLE = M_PI / 8.0; // 22.5 degrees
+/**
+* Angle from axis to the line drawn by pan move.
+* If angle is less than this value we can assume that panning
+* can be done in allowed direction (horizontal or vertical).
+* Currently used only for touch-action css property stuff and was
+* added to keep behavior consistent with IE.
+*/
+static const double ALLOWED_DIRECT_PAN_ANGLE = M_PI / 3.0; // 60 degrees
+/**
+* Duration of a zoom to animation.
+*/
+static const TimeDuration ZOOM_TO_DURATION = TimeDuration::FromSeconds(0.25);
+/**
+* Computed time function used for sampling frames of a zoom to animation.
+*/
+StaticAutoPtr<ComputedTimingFunction> gComputedTimingFunction;
+/**
+* Maximum zoom amount, always used, even if a page asks for higher.
+*/
+static const CSSToScreenScale MAX_ZOOM(8.0f);
+/**
+* Minimum zoom amount, always used, even if a page asks for lower.
+*/
+static const CSSToScreenScale MIN_ZOOM(0.125f);
+/**
+* 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);
+}
+template <typename Units>
+static bool IsZero(const gfx::PointTyped<Units>& aPoint)
+{
+return FuzzyEqualsMultiplicative(aPoint.x, 0.0f)
+&& FuzzyEqualsMultiplicative(aPoint.y, 0.0f);
+}
+static inline void LogRendertraceRect(const ScrollableLayerGuid& aGuid, const char* aDesc, const char* aColor, const CSSRect& aRect)
+{
+#ifdef APZC_ENABLE_RENDERTRACE
+static const TimeStamp sRenderStart = TimeStamp::Now();
+TimeDuration delta = TimeStamp::Now() - sRenderStart;
+printf_stderr("(%llu,%lu,%llu)%s RENDERTRACE %f rect %s %f %f %f %f\n",
+aGuid.mLayersId, aGuid.mPresShellId, aGuid.GetScrollId(),
+aDesc, delta.ToMilliseconds(), aColor,
+aRect.x, aRect.y, aRect.width, aRect.height);
+#endif
+}
+static TimeStamp sFrameTime;
+// Counter used to give each APZC a unique id
+static uint32_t sAsyncPanZoomControllerCount = 0;
+static TimeStamp
+GetFrameTime() {
+if (sFrameTime.IsNull()) {
+return TimeStamp::Now();
+}
+return sFrameTime;
+}
+class FlingAnimation: public AsyncPanZoomAnimation {
+public:
+FlingAnimation(AsyncPanZoomController& aApzc)
+: AsyncPanZoomAnimation(TimeDuration::FromMilliseconds(gfxPrefs::APZFlingRepaintInterval()))
+, mApzc(aApzc)
+{}
+/**
+* Advances a fling by an interpolated amount based on the passed in |aDelta|.
+* This should be called whenever sampling the content transform for this
+* frame. Returns true if the fling animation should be advanced by one frame,
+* or false if there is no fling or the fling has ended.
+*/
+virtual bool Sample(FrameMetrics& aFrameMetrics,
+const TimeDuration& aDelta);
+private:
+AsyncPanZoomController& mApzc;
+};
+class ZoomAnimation: public AsyncPanZoomAnimation {
+public:
+ZoomAnimation(CSSPoint aStartOffset, CSSToScreenScale aStartZoom,
+CSSPoint aEndOffset, CSSToScreenScale aEndZoom)
+: mStartOffset(aStartOffset)
+, mStartZoom(aStartZoom)
+, mEndOffset(aEndOffset)
+, mEndZoom(aEndZoom)
+{}
+virtual bool Sample(FrameMetrics& aFrameMetrics,
+const TimeDuration& aDelta);
+private:
+TimeDuration mDuration;
+// 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;
+CSSToScreenScale 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;
+CSSToScreenScale mEndZoom;
+};
+void
+AsyncPanZoomController::SetFrameTime(const TimeStamp& aTime) {
+sFrameTime = aTime;
+}
+/*static*/ void
+AsyncPanZoomController::InitializeGlobalState()
+{
+MOZ_ASSERT(NS_IsMainThread());
+static bool sInitialized = false;
+if (sInitialized)
+return;
+sInitialized = true;
+gComputedTimingFunction = new ComputedTimingFunction();
+gComputedTimingFunction->Init(
+nsTimingFunction(NS_STYLE_TRANSITION_TIMING_FUNCTION_EASE));
+ClearOnShutdown(&gComputedTimingFunction);
+}
+AsyncPanZoomController::AsyncPanZoomController(uint64_t aLayersId,
+APZCTreeManager* aTreeManager,
+GeckoContentController* aGeckoContentController,
+GestureBehavior aGestures)
+:  mLayersId(aLayersId),
+mCrossProcessCompositorParent(nullptr),
+mPaintThrottler(GetFrameTime()),
+mGeckoContentController(aGeckoContentController),
+mRefPtrMonitor("RefPtrMonitor"),
+mMonitor("AsyncPanZoomController"),
+mTouchActionPropertyEnabled(gfxPrefs::TouchActionEnabled()),
+mContentResponseTimeoutTask(nullptr),
+mX(MOZ_THIS_IN_INITIALIZER_LIST()),
+mY(MOZ_THIS_IN_INITIALIZER_LIST()),
+mPanDirRestricted(false),
+mZoomConstraints(false, false, MIN_ZOOM, MAX_ZOOM),
+mLastSampleTime(GetFrameTime()),
+mState(NOTHING),
+mLastAsyncScrollTime(GetFrameTime()),
+mLastAsyncScrollOffset(0, 0),
+mCurrentAsyncScrollOffset(0, 0),
+mAsyncScrollTimeoutTask(nullptr),
+mHandlingTouchQueue(false),
+mTreeManager(aTreeManager),
+mScrollParentId(FrameMetrics::NULL_SCROLL_ID),
+mAPZCId(sAsyncPanZoomControllerCount++),
+mSharedFrameMetricsBuffer(nullptr),
+mSharedLock(nullptr)
+{
+MOZ_COUNT_CTOR(AsyncPanZoomController);
+if (aGestures == USE_GESTURE_DETECTOR) {
+mGestureEventListener = new GestureEventListener(this);
+}
+}
+AsyncPanZoomController::~AsyncPanZoomController() {
+PCompositorParent* compositor =
+(mCrossProcessCompositorParent ? mCrossProcessCompositorParent : mCompositorParent.get());
+// Only send the release message if the SharedFrameMetrics has been created.
+if (compositor && mSharedFrameMetricsBuffer) {
+unused << compositor->SendReleaseSharedCompositorFrameMetrics(mFrameMetrics.GetScrollId(), mAPZCId);
+}
+delete mSharedFrameMetricsBuffer;
+delete mSharedLock;
+MOZ_COUNT_DTOR(AsyncPanZoomController);
+}
+already_AddRefed<GeckoContentController>
+AsyncPanZoomController::GetGeckoContentController() {
+MonitorAutoLock lock(mRefPtrMonitor);
+nsRefPtr<GeckoContentController> controller = mGeckoContentController;
+return controller.forget();
+}
+already_AddRefed<GestureEventListener>
+AsyncPanZoomController::GetGestureEventListener() {
+MonitorAutoLock lock(mRefPtrMonitor);
+nsRefPtr<GestureEventListener> listener = mGestureEventListener;
+return listener.forget();
+}
+void
+AsyncPanZoomController::Destroy()
+{
+{ // scope the lock
+MonitorAutoLock lock(mRefPtrMonitor);
+mGeckoContentController = nullptr;
+mGestureEventListener = nullptr;
+}
+mPrevSibling = nullptr;
+mLastChild = nullptr;
+mParent = nullptr;
+mTreeManager = nullptr;
+}
+bool
+AsyncPanZoomController::IsDestroyed()
+{
+return mTreeManager == nullptr;
+}
+/* static */float
+AsyncPanZoomController::GetTouchStartTolerance()
+{
+return (gfxPrefs::APZTouchStartTolerance() * APZCTreeManager::GetDPI());
+}
+/* static */AsyncPanZoomController::AxisLockMode AsyncPanZoomController::GetAxisLockMode()
+{
+return static_cast<AxisLockMode>(gfxPrefs::APZAxisLockMode());
+}
+nsEventStatus AsyncPanZoomController::ReceiveInputEvent(const InputData& aEvent) {
+if (aEvent.mInputType == MULTITOUCH_INPUT &&
+aEvent.AsMultiTouchInput().mType == MultiTouchInput::MULTITOUCH_START) {
+// Starting a new touch block, clear old touch block state.
+mTouchBlockState = TouchBlockState();
+}
+// If we may have touch listeners and touch action property is enabled, we
+// enable the machinery that allows touch listeners to preventDefault any touch inputs
+// and also waits for the allowed touch behavior values to be received from the outside.
+// This should not happen unless there are actually touch listeners and touch-action property
+// enable as it introduces potentially unbounded lag because it causes a round-trip through
+// content.  Usually, if content is responding in a timely fashion, this only introduces a
+// nearly constant few hundred ms of lag.
+if (mFrameMetrics.mMayHaveTouchListeners && aEvent.mInputType == MULTITOUCH_INPUT &&
+(mState == NOTHING || mState == TOUCHING || IsPanningState(mState))) {
+const MultiTouchInput& multiTouchInput = aEvent.AsMultiTouchInput();
+if (multiTouchInput.mType == MultiTouchInput::MULTITOUCH_START) {
+SetState(WAITING_CONTENT_RESPONSE);
+}
+}
+if (mState == WAITING_CONTENT_RESPONSE || mHandlingTouchQueue) {
+if (aEvent.mInputType == MULTITOUCH_INPUT) {
+const MultiTouchInput& multiTouchInput = aEvent.AsMultiTouchInput();
+mTouchQueue.AppendElement(multiTouchInput);
+SetContentResponseTimer();
+}
+return nsEventStatus_eIgnore;
+}
+return HandleInputEvent(aEvent);
+}
+nsEventStatus AsyncPanZoomController::HandleInputEvent(const InputData& aEvent) {
+nsEventStatus rv = nsEventStatus_eIgnore;
+switch (aEvent.mInputType) {
+case MULTITOUCH_INPUT: {
+const MultiTouchInput& multiTouchInput = aEvent.AsMultiTouchInput();
+nsRefPtr<GestureEventListener> 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;
+}
+default: NS_WARNING("Unhandled input event"); break;
+}
+mLastEventTime = aEvent.mTime;
+return rv;
+}
+nsEventStatus AsyncPanZoomController::HandleGestureEvent(const InputData& aEvent)
+{
+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_CANCEL: rv = OnCancelTap(tapGestureInput); break;
+default: NS_WARNING("Unhandled tap gesture"); break;
+}
+break;
+}
+default: NS_WARNING("Unhandled input event"); break;
+}
+mLastEventTime = aEvent.mTime;
+return rv;
+}
+nsEventStatus AsyncPanZoomController::OnTouchStart(const MultiTouchInput& aEvent) {
+APZC_LOG("%p got a touch-start in state %d\n", this, mState);
+mPanDirRestricted = false;
+ScreenIntPoint point = GetFirstTouchScreenPoint(aEvent);
+switch (mState) {
+case ANIMATING_ZOOM:
+// We just interrupted a double-tap animation, so force a redraw in case
+// this touchstart is just a tap that doesn't end up triggering a redraw.
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+RequestContentRepaint();
+ScheduleComposite();
+UpdateSharedCompositorFrameMetrics();
+}
+// Fall through.
+case FLING:
+CancelAnimation();
+// Fall through.
+case NOTHING: {
+mX.StartTouch(point.x);
+mY.StartTouch(point.y);
+APZCTreeManager* treeManagerLocal = mTreeManager;
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (treeManagerLocal && controller) {
+bool touchCanBePan = treeManagerLocal->CanBePanned(this);
+controller->NotifyAPZStateChange(
+GetGuid(), APZStateChange::StartTouch, touchCanBePan);
+}
+SetState(TOUCHING);
+break;
+}
+case TOUCHING:
+case PANNING:
+case PANNING_LOCKED_X:
+case PANNING_LOCKED_Y:
+case CROSS_SLIDING_X:
+case CROSS_SLIDING_Y:
+case PINCHING:
+case WAITING_CONTENT_RESPONSE:
+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 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 CROSS_SLIDING_X:
+case CROSS_SLIDING_Y:
+// While cross-sliding, we don't want to consume any touchmove events for
+// panning or zooming, and let the caller handle them instead.
+return nsEventStatus_eIgnore;
+case TOUCHING: {
+float panThreshold = GetTouchStartTolerance();
+UpdateWithTouchAtDevicePoint(aEvent);
+if (PanDistance() < panThreshold) {
+return nsEventStatus_eIgnore;
+}
+if (mTouchActionPropertyEnabled &&
+(GetTouchBehavior(0) & AllowedTouchBehavior::VERTICAL_PAN) &&
+(GetTouchBehavior(0) & AllowedTouchBehavior::HORIZONTAL_PAN)) {
+// 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:
+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 WAITING_CONTENT_RESPONSE:
+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);
+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);
+SendAsyncScrollEvent();
+}
+switch (mState) {
+case FLING:
+// Should never happen.
+NS_WARNING("Received impossible touch end in OnTouchEnd.");
+// Fall through.
+case ANIMATING_ZOOM:
+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:
+case CROSS_SLIDING_X:
+case CROSS_SLIDING_Y:
+SetState(NOTHING);
+return nsEventStatus_eIgnore;
+case PANNING:
+case PANNING_LOCKED_X:
+case PANNING_LOCKED_Y:
+{
+// Make a local copy of the tree manager pointer and check if it's not
+// null before calling FlushRepaintsForOverscrollHandoffChain().
+// This is necessary because Destroy(), which nulls out mTreeManager,
+// could be called concurrently.
+APZCTreeManager* treeManagerLocal = mTreeManager;
+if (treeManagerLocal) {
+if (!treeManagerLocal->FlushRepaintsForOverscrollHandoffChain()) {
+NS_WARNING("Overscroll handoff chain was empty during panning! This should not be the case.");
+// Graceful handling of error condition
+FlushRepaintForOverscrollHandoff();
+}
+}
+}
+mX.EndTouch();
+mY.EndTouch();
+SetState(FLING);
+StartAnimation(new FlingAnimation(*this));
+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 WAITING_CONTENT_RESPONSE:
+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();
+SetState(NOTHING);
+return nsEventStatus_eConsumeNoDefault;
+}
+nsEventStatus AsyncPanZoomController::OnScaleBegin(const PinchGestureInput& aEvent) {
+APZC_LOG("%p got a scale-begin in state %d\n", this, mState);
+if (!TouchActionAllowPinchZoom()) {
+return nsEventStatus_eIgnore;
+}
+if (!mZoomConstraints.mAllowZoom) {
+return nsEventStatus_eConsumeNoDefault;
+}
+SetState(PINCHING);
+mLastZoomFocus = ToParentLayerCoords(aEvent.mFocusPoint) - mFrameMetrics.mCompositionBounds.TopLeft();
+return nsEventStatus_eConsumeNoDefault;
+}
+nsEventStatus AsyncPanZoomController::OnScale(const PinchGestureInput& aEvent) {
+APZC_LOG("%p got a scale in state %d\n", this, mState);
+if (mState != PINCHING) {
+return nsEventStatus_eConsumeNoDefault;
+}
+float prevSpan = aEvent.mPreviousSpan;
+if (fabsf(prevSpan) <= EPSILON || fabsf(aEvent.mCurrentSpan) <= EPSILON) {
+// We're still handling it; we've just decided to throw this event away.
+return nsEventStatus_eConsumeNoDefault;
+}
+float spanRatio = aEvent.mCurrentSpan / aEvent.mPreviousSpan;
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+CSSToParentLayerScale userZoom = mFrameMetrics.GetZoomToParent();
+ParentLayerPoint focusPoint = ToParentLayerCoords(aEvent.mFocusPoint) - mFrameMetrics.mCompositionBounds.TopLeft();
+CSSPoint cssFocusPoint = focusPoint / userZoom;
+CSSPoint focusChange = (mLastZoomFocus - focusPoint) / userZoom;
+// If displacing by the change in focus point will take us off page bounds,
+// then reduce the displacement such that it doesn't.
+if (mX.DisplacementWillOverscroll(focusChange.x) != Axis::OVERSCROLL_NONE) {
+focusChange.x -= mX.DisplacementWillOverscrollAmount(focusChange.x);
+}
+if (mY.DisplacementWillOverscroll(focusChange.y) != Axis::OVERSCROLL_NONE) {
+focusChange.y -= mY.DisplacementWillOverscrollAmount(focusChange.y);
+}
+ScrollBy(focusChange);
+// 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 * mFrameMetrics.mTransformScale;
+CSSToParentLayerScale realMaxZoom = mZoomConstraints.mMaxZoom * mFrameMetrics.mTransformScale;
+realMinZoom.scale = std::max(realMinZoom.scale,
+mFrameMetrics.mCompositionBounds.width / mFrameMetrics.mScrollableRect.width);
+realMinZoom.scale = std::max(realMinZoom.scale,
+mFrameMetrics.mCompositionBounds.height / mFrameMetrics.mScrollableRect.height);
+if (realMaxZoom < realMinZoom) {
+realMaxZoom = realMinZoom;
+}
+bool doScale = (spanRatio > 1.0 && userZoom < realMaxZoom) ||
+(spanRatio < 1.0 && userZoom > realMinZoom);
+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);
+}
+ScheduleComposite();
+// We don't want to redraw on every scale, so don't use
+// RequestContentRepaint()
+UpdateSharedCompositorFrameMetrics();
+}
+mLastZoomFocus = focusPoint;
+}
+return nsEventStatus_eConsumeNoDefault;
+}
+nsEventStatus AsyncPanZoomController::OnScaleEnd(const PinchGestureInput& aEvent) {
+APZC_LOG("%p got a scale-end in state %d\n", this, mState);
+SetState(NOTHING);
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+ScheduleComposite();
+RequestContentRepaint();
+UpdateSharedCompositorFrameMetrics();
+}
+return nsEventStatus_eConsumeNoDefault;
+}
+bool
+AsyncPanZoomController::ConvertToGecko(const ScreenPoint& aPoint, CSSPoint* aOut)
+{
+APZCTreeManager* treeManagerLocal = mTreeManager;
+if (treeManagerLocal) {
+gfx3DMatrix transformToApzc;
+gfx3DMatrix transformToGecko;
+treeManagerLocal->GetInputTransforms(this, transformToApzc, transformToGecko);
+gfxPoint result = transformToGecko.Transform(gfxPoint(aPoint.x, aPoint.y));
+// NOTE: This isn't *quite* LayoutDevicePoint, we just don't have a name
+// for this coordinate space and it maps the closest to LayoutDevicePoint.
+LayoutDevicePoint layoutPoint = LayoutDevicePoint(result.x, result.y);
+{ // scoped lock to access mFrameMetrics
+ReentrantMonitorAutoEnter lock(mMonitor);
+*aOut = layoutPoint / mFrameMetrics.mDevPixelsPerCSSPixel;
+}
+return true;
+}
+return false;
+}
+nsEventStatus AsyncPanZoomController::OnLongPress(const TapGestureInput& aEvent) {
+APZC_LOG("%p got a long-press in state %d\n", this, mState);
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+int32_t modifiers = WidgetModifiersToDOMModifiers(aEvent.modifiers);
+CSSPoint geckoScreenPoint;
+if (ConvertToGecko(aEvent.mPoint, &geckoScreenPoint)) {
+SetState(WAITING_CONTENT_RESPONSE);
+SetContentResponseTimer();
+controller->HandleLongTap(geckoScreenPoint, modifiers, GetGuid());
+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);
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+int32_t modifiers = WidgetModifiersToDOMModifiers(aEvent.modifiers);
+CSSPoint geckoScreenPoint;
+if (ConvertToGecko(aEvent.mPoint, &geckoScreenPoint)) {
+controller->HandleLongTapUp(geckoScreenPoint, modifiers, GetGuid());
+return nsEventStatus_eConsumeNoDefault;
+}
+}
+return nsEventStatus_eIgnore;
+}
+nsEventStatus AsyncPanZoomController::GenerateSingleTap(const ScreenIntPoint& aPoint, mozilla::Modifiers aModifiers) {
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+CSSPoint geckoScreenPoint;
+if (ConvertToGecko(aPoint, &geckoScreenPoint)) {
+int32_t modifiers = WidgetModifiersToDOMModifiers(aModifiers);
+// Because this may be being running as part of APZCTreeManager::ReceiveInputEvent,
+// calling controller->HandleSingleTap 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.
+controller->PostDelayedTask(
+NewRunnableMethod(controller.get(), &GeckoContentController::HandleSingleTap,
+geckoScreenPoint, modifiers, GetGuid()),
+0);
+mTouchBlockState.mSingleTapOccurred = true;
+return nsEventStatus_eConsumeNoDefault;
+}
+}
+return nsEventStatus_eIgnore;
+}
+void AsyncPanZoomController::OnTouchEndOrCancel() {
+if (nsRefPtr<GeckoContentController> controller = GetGeckoContentController()) {
+controller->NotifyAPZStateChange(
+GetGuid(), APZStateChange::EndTouch, mTouchBlockState.mSingleTapOccurred);
+}
+}
+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
+if (!(mZoomConstraints.mAllowDoubleTapZoom && TouchActionAllowDoubleTapZoom())) {
+return GenerateSingleTap(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(aEvent.mPoint, aEvent.modifiers);
+}
+nsEventStatus AsyncPanZoomController::OnDoubleTap(const TapGestureInput& aEvent) {
+APZC_LOG("%p got a double-tap in state %d\n", this, mState);
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+if (mZoomConstraints.mAllowDoubleTapZoom && TouchActionAllowDoubleTapZoom()) {
+int32_t modifiers = WidgetModifiersToDOMModifiers(aEvent.modifiers);
+CSSPoint geckoScreenPoint;
+if (ConvertToGecko(aEvent.mPoint, &geckoScreenPoint)) {
+controller->HandleDoubleTap(geckoScreenPoint, modifiers, GetGuid());
+}
+}
+return nsEventStatus_eConsumeNoDefault;
+}
+return nsEventStatus_eIgnore;
+}
+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;
+}
+float AsyncPanZoomController::PanDistance() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+return NS_hypot(mX.PanDistance(), mY.PanDistance());
+}
+const ScreenPoint AsyncPanZoomController::GetVelocityVector() {
+return ScreenPoint(mX.GetVelocity(), mY.GetVelocity());
+}
+void AsyncPanZoomController::HandlePanningWithTouchAction(double aAngle, TouchBehaviorFlags aBehavior) {
+// Handling of cross sliding will need to be added in this method after touch-action released
+// enabled by default.
+if ((aBehavior & AllowedTouchBehavior::VERTICAL_PAN) && (aBehavior & AllowedTouchBehavior::HORIZONTAL_PAN)) {
+if (mX.Scrollable() && mY.Scrollable()) {
+if (IsCloseToHorizontal(aAngle, AXIS_LOCK_ANGLE)) {
+mY.SetAxisLocked(true);
+SetState(PANNING_LOCKED_X);
+} else if (IsCloseToVertical(aAngle, AXIS_LOCK_ANGLE)) {
+mX.SetAxisLocked(true);
+SetState(PANNING_LOCKED_Y);
+} else {
+SetState(PANNING);
+}
+} else if (mX.Scrollable() || mY.Scrollable()) {
+SetState(PANNING);
+} else {
+SetState(NOTHING);
+}
+} else if (aBehavior & AllowedTouchBehavior::HORIZONTAL_PAN) {
+// Using bigger angle for panning to keep behavior consistent
+// with IE.
+if (IsCloseToHorizontal(aAngle, ALLOWED_DIRECT_PAN_ANGLE)) {
+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 (aBehavior & AllowedTouchBehavior::VERTICAL_PAN) {
+if (IsCloseToVertical(aAngle, ALLOWED_DIRECT_PAN_ANGLE)) {
+mX.SetAxisLocked(true);
+SetState(PANNING_LOCKED_Y);
+mPanDirRestricted = true;
+} else {
+SetState(NOTHING);
+}
+} else {
+SetState(NOTHING);
+}
+}
+void AsyncPanZoomController::HandlePanning(double aAngle) {
+if (!gfxPrefs::APZCrossSlideEnabled() && (!mX.Scrollable() || !mY.Scrollable())) {
+SetState(PANNING);
+} else if (IsCloseToHorizontal(aAngle, AXIS_LOCK_ANGLE)) {
+mY.SetAxisLocked(true);
+if (mX.Scrollable()) {
+SetState(PANNING_LOCKED_X);
+} else {
+SetState(CROSS_SLIDING_X);
+mX.SetAxisLocked(true);
+}
+} else if (IsCloseToVertical(aAngle, AXIS_LOCK_ANGLE)) {
+mX.SetAxisLocked(true);
+if (mY.Scrollable()) {
+SetState(PANNING_LOCKED_Y);
+} else {
+SetState(CROSS_SLIDING_Y);
+mY.SetAxisLocked(true);
+}
+} else {
+SetState(PANNING);
+}
+}
+nsEventStatus AsyncPanZoomController::StartPanning(const MultiTouchInput& aEvent) {
+ReentrantMonitorAutoEnter lock(mMonitor);
+ScreenIntPoint point = GetFirstTouchScreenPoint(aEvent);
+float dx = mX.PanDistance(point.x);
+float dy = mY.PanDistance(point.y);
+// When the touch move breaks through the pan threshold, reposition the touch down origin
+// so the page won't jump when we start panning.
+mX.StartTouch(point.x);
+mY.StartTouch(point.y);
+mLastEventTime = aEvent.mTime;
+double angle = atan2(dy, dx); // range [-pi, pi]
+angle = fabs(angle); // range [0, pi]
+if (mTouchActionPropertyEnabled) {
+HandlePanningWithTouchAction(angle, GetTouchBehavior(0));
+} else {
+if (GetAxisLockMode() == FREE) {
+SetState(PANNING);
+} else {
+HandlePanning(angle);
+}
+}
+if (IsPanningState(mState)) {
+if (nsRefPtr<GeckoContentController> controller = GetGeckoContentController()) {
+controller->NotifyAPZStateChange(GetGuid(), APZStateChange::StartPanning);
+}
+return nsEventStatus_eConsumeNoDefault;
+}
+// Don't consume an event that didn't trigger a panning.
+return nsEventStatus_eIgnore;
+}
+void AsyncPanZoomController::UpdateWithTouchAtDevicePoint(const MultiTouchInput& aEvent) {
+ScreenIntPoint point = GetFirstTouchScreenPoint(aEvent);
+TimeDuration timeDelta = TimeDuration().FromMilliseconds(aEvent.mTime - mLastEventTime);
+// Probably a duplicate event, just throw it away.
+if (timeDelta.ToMilliseconds() <= EPSILON) {
+return;
+}
+mX.UpdateWithTouchAtDevicePoint(point.x, timeDelta);
+mY.UpdateWithTouchAtDevicePoint(point.y, timeDelta);
+}
+void AsyncPanZoomController::AttemptScroll(const ScreenPoint& aStartPoint,
+const ScreenPoint& aEndPoint,
+uint32_t aOverscrollHandoffChainIndex) {
+// "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.
+ScreenPoint displacement = aStartPoint - aEndPoint;
+ScreenPoint overscroll;  // will be used outside monitor block
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+CSSToScreenScale zoom = mFrameMetrics.GetZoom();
+// Inversely scale the offset by the resolution (when you're zoomed further in,
+// the same swipe should move you a shorter distance).
+CSSPoint cssDisplacement = displacement / zoom;
+CSSPoint cssOverscroll;
+CSSPoint allowedDisplacement(mX.AdjustDisplacement(cssDisplacement.x,
+cssOverscroll.x),
+mY.AdjustDisplacement(cssDisplacement.y,
+cssOverscroll.y));
+overscroll = cssOverscroll * zoom;
+if (!IsZero(allowedDisplacement)) {
+ScrollBy(allowedDisplacement);
+ScheduleComposite();
+TimeDuration timePaintDelta = mPaintThrottler.TimeSinceLastRequest(GetFrameTime());
+if (timePaintDelta.ToMilliseconds() > gfxPrefs::APZPanRepaintInterval()) {
+RequestContentRepaint();
+}
+UpdateSharedCompositorFrameMetrics();
+}
+}
+if (!IsZero(overscroll)) {
+// "+ overscroll" rather than "- overscroll" because "overscroll" is what's
+// left of "displacement", and "displacement" is "start - end".
+CallDispatchScroll(aEndPoint + overscroll, aEndPoint, aOverscrollHandoffChainIndex + 1);
+}
+}
+void AsyncPanZoomController::TakeOverFling(ScreenPoint aVelocity) {
+// We may have a pre-existing velocity for whatever reason (for example,
+// a previously handed off fling). We don't want to clobber that.
+mX.SetVelocity(mX.GetVelocity() + aVelocity.x);
+mY.SetVelocity(mY.GetVelocity() + aVelocity.y);
+SetState(FLING);
+StartAnimation(new FlingAnimation(*this));
+}
+void AsyncPanZoomController::CallDispatchScroll(const ScreenPoint& aStartPoint, const ScreenPoint& aEndPoint,
+uint32_t aOverscrollHandoffChainIndex) {
+// 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 = mTreeManager;
+if (treeManagerLocal) {
+treeManagerLocal->DispatchScroll(this, aStartPoint, aEndPoint,
+aOverscrollHandoffChainIndex);
+}
+}
+void AsyncPanZoomController::TrackTouch(const MultiTouchInput& aEvent) {
+ScreenIntPoint prevTouchPoint(mX.GetPos(), mY.GetPos());
+ScreenIntPoint touchPoint = GetFirstTouchScreenPoint(aEvent);
+TimeDuration timeDelta = TimeDuration().FromMilliseconds(aEvent.mTime - mLastEventTime);
+// Probably a duplicate event, just throw it away.
+if (timeDelta.ToMilliseconds() <= EPSILON) {
+return;
+}
+// If we're axis-locked, check if the user is trying to break the lock
+if (GetAxisLockMode() == STICKY && !mPanDirRestricted) {
+ScreenIntPoint point = GetFirstTouchScreenPoint(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]
+float breakThreshold = AXIS_BREAKOUT_THRESHOLD * APZCTreeManager::GetDPI();
+if (fabs(dx) > breakThreshold || fabs(dy) > breakThreshold) {
+if (mState == PANNING_LOCKED_X || mState == CROSS_SLIDING_X) {
+if (!IsCloseToHorizontal(angle, AXIS_BREAKOUT_ANGLE)) {
+mY.SetAxisLocked(false);
+SetState(PANNING);
+}
+} else if (mState == PANNING_LOCKED_Y || mState == CROSS_SLIDING_Y) {
+if (!IsCloseToVertical(angle, AXIS_BREAKOUT_ANGLE)) {
+mX.SetAxisLocked(false);
+SetState(PANNING);
+}
+}
+}
+}
+UpdateWithTouchAtDevicePoint(aEvent);
+CallDispatchScroll(prevTouchPoint, touchPoint, 0);
+}
+ScreenIntPoint& AsyncPanZoomController::GetFirstTouchScreenPoint(const MultiTouchInput& aEvent) {
+return ((SingleTouchData&)aEvent.mTouches[0]).mScreenPoint;
+}
+bool FlingAnimation::Sample(FrameMetrics& aFrameMetrics,
+const TimeDuration& aDelta) {
+// If the fling is handed off to our APZC from a child, on the first call to
+// Sample() aDelta might be negative because it's computed as the sample time
+// from SampleContentTransformForFrame() minus our APZC's mLastSampleTime
+// which is the time the child handed off the fling from its call to
+// SampleContentTransformForFrame() with the same sample time. If we allow
+// the negative aDelta to be processed, it will yield a displacement in the
+// direction opposite to the fling, which can cause us to overscroll and
+// hand off the fling to _our_ parent, which effectively kills the fling.
+if (aDelta.ToMilliseconds() <= 0) {
+return true;
+}
+bool shouldContinueFlingX = mApzc.mX.FlingApplyFrictionOrCancel(aDelta),
+shouldContinueFlingY = mApzc.mY.FlingApplyFrictionOrCancel(aDelta);
+// If we shouldn't continue the fling, let's just stop and repaint.
+if (!shouldContinueFlingX && !shouldContinueFlingY) {
+return false;
+}
+// AdjustDisplacement() zeroes out the Axis velocity if we're in overscroll.
+// Since we need to hand off the velocity to the tree manager in such a case,
+// we save it here. Would be ScreenVector instead of ScreenPoint if we had
+// vector classes.
+ScreenPoint velocity(mApzc.mX.GetVelocity(), mApzc.mY.GetVelocity());
+ScreenPoint offset = velocity * aDelta.ToMilliseconds();
+// Inversely scale the offset by the resolution (when you're zoomed further in,
+// the same swipe should move you a shorter distance).
+CSSPoint cssOffset = offset / aFrameMetrics.GetZoom();
+CSSPoint overscroll;
+aFrameMetrics.ScrollBy(CSSPoint(
+mApzc.mX.AdjustDisplacement(cssOffset.x, overscroll.x),
+mApzc.mY.AdjustDisplacement(cssOffset.y, overscroll.y)
+));
+// If the fling has caused us to reach the end of our scroll range, hand
+// off the fling to the next APZC in the overscroll handoff chain.
+if (!IsZero(overscroll)) {
+// 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 (FuzzyEqualsMultiplicative(overscroll.x, 0.0f)) {
+velocity.x = 0;
+} else if (FuzzyEqualsMultiplicative(overscroll.y, 0.0f)) {
+velocity.y = 0;
+}
+// To hand off the fling, we call APZCTreeManager::HandleFlingOverscroll()
+// which starts a new fling in the next APZC in the handoff chain with
+// the same velocity. 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.
+// Make a local copy of the tree manager pointer and check if it's not
+// null before calling HandleFlingOverscroll(). This is necessary because
+// Destroy(), which nulls out mTreeManager, could be called concurrently.
+APZCTreeManager* treeManagerLocal = mApzc.mTreeManager;
+if (treeManagerLocal) {
+// APZC is holding mMonitor, so directly calling HandleFlingOverscroll()
+// (which acquires the tree lock) would violate the lock ordering. Instead
+// we schedule HandleFlingOverscroll() to be called after mMonitor is
+// released.
+mDeferredTasks.append(NewRunnableMethod(treeManagerLocal,
+&APZCTreeManager::HandOffFling,
+&mApzc,
+velocity));
+}
+}
+return true;
+}
+void AsyncPanZoomController::StartAnimation(AsyncPanZoomAnimation* aAnimation)
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+mAnimation = aAnimation;
+mLastSampleTime = GetFrameTime();
+ScheduleComposite();
+}
+void AsyncPanZoomController::CancelAnimation() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+SetState(NOTHING);
+mAnimation = nullptr;
+}
+void AsyncPanZoomController::SetCompositorParent(CompositorParent* aCompositorParent) {
+mCompositorParent = aCompositorParent;
+}
+void AsyncPanZoomController::SetCrossProcessCompositorParent(PCompositorParent* aCrossProcessCompositorParent) {
+mCrossProcessCompositorParent = aCrossProcessCompositorParent;
+}
+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)
+{
+float xMultiplier = fabsf(aVelocity.x) < gfxPrefs::APZMinSkateSpeed()
+? gfxPrefs::APZXStationarySizeMultiplier()
+: gfxPrefs::APZXSkateSizeMultiplier();
+float yMultiplier = fabsf(aVelocity.y) < gfxPrefs::APZMinSkateSpeed()
+? gfxPrefs::APZYStationarySizeMultiplier()
+: gfxPrefs::APZYSkateSizeMultiplier();
+return CSSSize(aCompositionSize.width * xMultiplier,
+aCompositionSize.height * yMultiplier);
+}
+/**
+* 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)
+{
+float xSlack = std::max(0.0f, aDisplayPortSize.width - aScrollableRect.width);
+float ySlack = std::max(0.0f, aDisplayPortSize.height - aScrollableRect.height);
+if (ySlack > 0) {
+// Reassign wasted y-axis displayport to the x-axis
+aDisplayPortSize.height -= ySlack;
+float xExtra = ySlack * aDisplayPortSize.width / aDisplayPortSize.height;
+aDisplayPortSize.width += xExtra;
+} else if (xSlack > 0) {
+// Reassign wasted x-axis displayport to the y-axis
+aDisplayPortSize.width -= xSlack;
+float yExtra = xSlack * aDisplayPortSize.height / aDisplayPortSize.width;
+aDisplayPortSize.height += yExtra;
+}
+}
+/* static */
+const LayerMargin AsyncPanZoomController::CalculatePendingDisplayPort(
+const FrameMetrics& aFrameMetrics,
+const ScreenPoint& aVelocity,
+double aEstimatedPaintDuration)
+{
+CSSSize compositionBounds = aFrameMetrics.CalculateCompositedSizeInCssPixels();
+CSSSize compositionSize = aFrameMetrics.GetRootCompositionSize();
+compositionSize =
+CSSSize(std::min(compositionBounds.width, compositionSize.width),
+std::min(compositionBounds.height, compositionSize.height));
+CSSPoint velocity = aVelocity / aFrameMetrics.GetZoom();
+CSSPoint scrollOffset = aFrameMetrics.GetScrollOffset();
+CSSRect scrollableRect = aFrameMetrics.GetExpandedScrollableRect();
+// Calculate the displayport size based on how fast we're moving along each axis.
+CSSSize displayPortSize = CalculateDisplayPortSize(compositionSize, velocity);
+if (gfxPrefs::APZEnlargeDisplayPortWhenClipped()) {
+RedistributeDisplayPortExcess(displayPortSize, scrollableRect);
+}
+// Offset the displayport, depending on how fast we're moving and the
+// estimated time it takes to paint, to try to minimise checkerboarding.
+float estimatedPaintDurationMillis = (float)(aEstimatedPaintDuration * 1000.0);
+float paintFactor = (gfxPrefs::APZUsePaintDuration() ? estimatedPaintDurationMillis : 50.0f);
+CSSRect displayPort = CSSRect(scrollOffset + (velocity * paintFactor * gfxPrefs::APZVelocityBias()),
+displayPortSize);
+// Re-center the displayport based on its expansion over the composition size.
+displayPort.MoveBy((compositionSize.width - displayPort.width)/2.0f,
+(compositionSize.height - displayPort.height)/2.0f);
+// Make sure the displayport remains within the scrollable rect.
+displayPort = displayPort.ForceInside(scrollableRect) - scrollOffset;
+APZC_LOG_FM(aFrameMetrics,
+"Calculated displayport as (%f %f %f %f) from velocity (%f %f) paint time %f metrics",
+displayPort.x, displayPort.y, displayPort.width, displayPort.height,
+aVelocity.x, aVelocity.y, (float)estimatedPaintDurationMillis);
+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;
+LayerMargin layerMargins = cssMargins * aFrameMetrics.LayersPixelsPerCSSPixel();
+return layerMargins;
+}
+void AsyncPanZoomController::ScheduleComposite() {
+if (mCompositorParent) {
+mCompositorParent->ScheduleRenderOnCompositorThread();
+}
+}
+void AsyncPanZoomController::FlushRepaintForOverscrollHandoff() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+RequestContentRepaint();
+UpdateSharedCompositorFrameMetrics();
+}
+bool AsyncPanZoomController::IsPannable() const {
+ReentrantMonitorAutoEnter lock(mMonitor);
+return mX.HasRoomToPan() || mY.HasRoomToPan();
+}
+void AsyncPanZoomController::RequestContentRepaint() {
+RequestContentRepaint(mFrameMetrics);
+}
+void AsyncPanZoomController::RequestContentRepaint(FrameMetrics& aFrameMetrics) {
+aFrameMetrics.SetDisplayPortMargins(
+CalculatePendingDisplayPort(aFrameMetrics,
+GetVelocityVector(),
+mPaintThrottler.AverageDuration().ToSeconds()));
+aFrameMetrics.SetUseDisplayPortMargins();
+// If we're trying to paint what we already think is painted, discard this
+// request since it's a pointless paint.
+LayerMargin 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.GetZoom() == mLastPaintRequestMetrics.GetZoom() &&
+fabsf(aFrameMetrics.mViewport.width - mLastPaintRequestMetrics.mViewport.width) < EPSILON &&
+fabsf(aFrameMetrics.mViewport.height - mLastPaintRequestMetrics.mViewport.height) < EPSILON) {
+return;
+}
+SendAsyncScrollEvent();
+mPaintThrottler.PostTask(
+FROM_HERE,
+NewRunnableMethod(this,
+&AsyncPanZoomController::DispatchRepaintRequest,
+aFrameMetrics),
+GetFrameTime());
+aFrameMetrics.mPresShellId = mLastContentPaintMetrics.mPresShellId;
+mLastPaintRequestMetrics = aFrameMetrics;
+}
+/*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(),
+CSSSize(std::min(aFrameMetrics.CalculateCompositedSizeInCssPixels().width,
+aFrameMetrics.GetRootCompositionSize().width),
+std::min(aFrameMetrics.CalculateCompositedSizeInCssPixels().height,
+aFrameMetrics.GetRootCompositionSize().height)));
+baseRect.Inflate(aFrameMetrics.GetDisplayPortMargins() / aFrameMetrics.LayersPixelsPerCSSPixel());
+return baseRect;
+}
+void
+AsyncPanZoomController::DispatchRepaintRequest(const FrameMetrics& aFrameMetrics) {
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+APZC_LOG_FM(aFrameMetrics, "%p requesting content repaint", this);
+LogRendertraceRect(GetGuid(), "requested displayport", "yellow", GetDisplayPortRect(aFrameMetrics));
+controller->RequestContentRepaint(aFrameMetrics);
+mLastDispatchedPaintMetrics = aFrameMetrics;
+}
+}
+void
+AsyncPanZoomController::FireAsyncScrollOnTimeout()
+{
+if (mCurrentAsyncScrollOffset != mLastAsyncScrollOffset) {
+ReentrantMonitorAutoEnter lock(mMonitor);
+SendAsyncScrollEvent();
+}
+mAsyncScrollTimeoutTask = nullptr;
+}
+bool ZoomAnimation::Sample(FrameMetrics& aFrameMetrics,
+const TimeDuration& aDelta) {
+mDuration += aDelta;
+double animPosition = mDuration / ZOOM_TO_DURATION;
+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.
+double sampledPosition = gComputedTimingFunction->GetValue(animPosition);
+// We scale the scrollOffset linearly with sampledPosition, so the zoom
+// needs to scale inversely to match.
+aFrameMetrics.SetZoom(CSSToScreenScale(1 /
+(sampledPosition / mEndZoom.scale +
+(1 - sampledPosition) / mStartZoom.scale)));
+aFrameMetrics.SetScrollOffset(CSSPoint::FromUnknownPoint(gfx::Point(
+mEndOffset.x * sampledPosition + mStartOffset.x * (1 - sampledPosition),
+mEndOffset.y * sampledPosition + mStartOffset.y * (1 - sampledPosition)
+)));
+return true;
+}
+bool AsyncPanZoomController::UpdateAnimation(const TimeStamp& aSampleTime)
+{
+if (mAnimation) {
+if (mAnimation->Sample(mFrameMetrics, aSampleTime - mLastSampleTime)) {
+if (mPaintThrottler.TimeSinceLastRequest(aSampleTime) >
+mAnimation->mRepaintInterval) {
+RequestContentRepaint();
+}
+} else {
+mAnimation = nullptr;
+SetState(NOTHING);
+SendAsyncScrollEvent();
+RequestContentRepaint();
+}
+UpdateSharedCompositorFrameMetrics();
+mLastSampleTime = aSampleTime;
+return true;
+}
+return false;
+}
+bool AsyncPanZoomController::SampleContentTransformForFrame(const TimeStamp& aSampleTime,
+ViewTransform* aNewTransform,
+ScreenPoint& aScrollOffset) {
+// 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.
+bool requestAnimationFrame = false;
+Vector<Task*> deferredTasks;
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+requestAnimationFrame = UpdateAnimation(aSampleTime);
+aScrollOffset = mFrameMetrics.GetScrollOffset() * mFrameMetrics.GetZoom();
+*aNewTransform = GetCurrentAsyncTransform();
+LogRendertraceRect(GetGuid(), "viewport", "red",
+CSSRect(mFrameMetrics.GetScrollOffset(),
+ParentLayerSize(mFrameMetrics.mCompositionBounds.Size()) / mFrameMetrics.GetZoomToParent()));
+mCurrentAsyncScrollOffset = mFrameMetrics.GetScrollOffset();
+// Get any deferred tasks queued up by mAnimation's Sample() (called by
+// UpdateAnimation()). This needs to be done here since mAnimation can
+// be destroyed by another thread when we release the monitor, but
+// the tasks need to be executed after we release the monitor since they
+// are allowed to call APZCTreeManager methods which can grab the tree lock.
+if (mAnimation) {
+deferredTasks = mAnimation->TakeDeferredTasks();
+}
+}
+for (uint32_t i = 0; i < deferredTasks.length(); ++i) {
+deferredTasks[i]->Run();
+delete deferredTasks[i];
+}
+// Cancel the mAsyncScrollTimeoutTask because we will fire a
+// mozbrowserasyncscroll event or renew the mAsyncScrollTimeoutTask again.
+if (mAsyncScrollTimeoutTask) {
+mAsyncScrollTimeoutTask->Cancel();
+mAsyncScrollTimeoutTask = nullptr;
+}
+// Fire the mozbrowserasyncscroll event immediately if it's been
+// sAsyncScrollThrottleTime ms since the last time we fired the event and the
+// current scroll offset is different than the mLastAsyncScrollOffset we sent
+// with the last event.
+// Otherwise, start a timer to fire the event sAsyncScrollTimeout ms from now.
+TimeDuration delta = aSampleTime - mLastAsyncScrollTime;
+if (delta.ToMilliseconds() > gfxPrefs::APZAsyncScrollThrottleTime() &&
+mCurrentAsyncScrollOffset != mLastAsyncScrollOffset) {
+ReentrantMonitorAutoEnter lock(mMonitor);
+mLastAsyncScrollTime = aSampleTime;
+mLastAsyncScrollOffset = mCurrentAsyncScrollOffset;
+SendAsyncScrollEvent();
+}
+else {
+mAsyncScrollTimeoutTask =
+NewRunnableMethod(this, &AsyncPanZoomController::FireAsyncScrollOnTimeout);
+MessageLoop::current()->PostDelayedTask(FROM_HERE,
+mAsyncScrollTimeoutTask,
+gfxPrefs::APZAsyncScrollTimeout());
+}
+return requestAnimationFrame;
+}
+ViewTransform AsyncPanZoomController::GetCurrentAsyncTransform() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+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.mDisplayPort.IsEmpty()) {
+CSSSize compositedSize = mLastContentPaintMetrics.CalculateCompositedSizeInCssPixels();
+CSSPoint maxScrollOffset = lastPaintScrollOffset +
+CSSPoint(mLastContentPaintMetrics.mDisplayPort.XMost() - compositedSize.width,
+mLastContentPaintMetrics.mDisplayPort.YMost() - compositedSize.height);
+CSSPoint minScrollOffset = lastPaintScrollOffset + mLastContentPaintMetrics.mDisplayPort.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);
+}
+}
+LayerPoint translation = (currentScrollOffset - lastPaintScrollOffset)
+* mLastContentPaintMetrics.LayersPixelsPerCSSPixel();
+return ViewTransform(-translation,
+mFrameMetrics.GetZoom()
+/ mLastContentPaintMetrics.mDevPixelsPerCSSPixel
+/ mFrameMetrics.GetParentResolution());
+}
+gfx3DMatrix AsyncPanZoomController::GetNontransientAsyncTransform() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+return gfx3DMatrix::ScalingMatrix(mLastContentPaintMetrics.mResolution.scale,
+mLastContentPaintMetrics.mResolution.scale,
+1.0f);
+}
+gfx3DMatrix AsyncPanZoomController::GetTransformToLastDispatchedPaint() {
+ReentrantMonitorAutoEnter lock(mMonitor);
+LayerPoint scrollChange = (mLastContentPaintMetrics.GetScrollOffset() - mLastDispatchedPaintMetrics.GetScrollOffset())
+* mLastContentPaintMetrics.LayersPixelsPerCSSPixel();
+float zoomChange = mLastContentPaintMetrics.GetZoom().scale / mLastDispatchedPaintMetrics.GetZoom().scale;
+return gfx3DMatrix::Translation(scrollChange.x, scrollChange.y, 0) *
+gfx3DMatrix::ScalingMatrix(zoomChange, zoomChange, 1);
+}
+void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetrics, bool aIsFirstPaint) {
+ReentrantMonitorAutoEnter lock(mMonitor);
+mLastContentPaintMetrics = aLayerMetrics;
+UpdateTransformScale();
+bool isDefault = mFrameMetrics.IsDefault();
+mFrameMetrics.mMayHaveTouchListeners = aLayerMetrics.mMayHaveTouchListeners;
+APZC_LOG_FM(aLayerMetrics, "%p got a NotifyLayersUpdated with aIsFirstPaint=%d", this, aIsFirstPaint);
+LogRendertraceRect(GetGuid(), "page", "brown", aLayerMetrics.mScrollableRect);
+LogRendertraceRect(GetGuid(), "painted displayport", "green",
+aLayerMetrics.mDisplayPort + aLayerMetrics.GetScrollOffset());
+mPaintThrottler.TaskComplete(GetFrameTime());
+bool needContentRepaint = false;
+if (aLayerMetrics.mCompositionBounds.width == mFrameMetrics.mCompositionBounds.width &&
+aLayerMetrics.mCompositionBounds.height == mFrameMetrics.mCompositionBounds.height) {
+// Remote content has sync'd up to the composition geometry
+// change, so we can accept the viewport it's calculated.
+if (mFrameMetrics.mViewport.width != aLayerMetrics.mViewport.width ||
+mFrameMetrics.mViewport.height != aLayerMetrics.mViewport.height) {
+needContentRepaint = true;
+}
+mFrameMetrics.mViewport = aLayerMetrics.mViewport;
+}
+// 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 (aIsFirstPaint || isDefault) {
+// Initialize our internal state to something sane when the content
+// that was just painted is something we knew nothing about previously
+mPaintThrottler.ClearHistory();
+mPaintThrottler.SetMaxDurations(gfxPrefs::APZNumPaintDurationSamples());
+mX.CancelTouch();
+mY.CancelTouch();
+SetState(NOTHING);
+mFrameMetrics = aLayerMetrics;
+mLastDispatchedPaintMetrics = aLayerMetrics;
+ShareCompositorFrameMetrics();
+} 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 (mFrameMetrics.mCompositionBounds.width == aLayerMetrics.mCompositionBounds.width &&
+mFrameMetrics.mDevPixelsPerCSSPixel == aLayerMetrics.mDevPixelsPerCSSPixel) {
+float parentResolutionChange = aLayerMetrics.GetParentResolution().scale
+/ mFrameMetrics.GetParentResolution().scale;
+mFrameMetrics.ZoomBy(parentResolutionChange);
+} else {
+// Take the new zoom as either device scale or composition width or both
+// got changed (e.g. due to orientation change).
+mFrameMetrics.SetZoom(aLayerMetrics.GetZoom());
+mFrameMetrics.mDevPixelsPerCSSPixel.scale = aLayerMetrics.mDevPixelsPerCSSPixel.scale;
+}
+mFrameMetrics.mScrollableRect = aLayerMetrics.mScrollableRect;
+mFrameMetrics.mCompositionBounds = aLayerMetrics.mCompositionBounds;
+mFrameMetrics.SetRootCompositionSize(aLayerMetrics.GetRootCompositionSize());
+mFrameMetrics.mResolution = aLayerMetrics.mResolution;
+mFrameMetrics.mCumulativeResolution = aLayerMetrics.mCumulativeResolution;
+mFrameMetrics.mHasScrollgrab = aLayerMetrics.mHasScrollgrab;
+if (scrollOffsetUpdated) {
+APZC_LOG("%p updating scroll offset from (%f, %f) to (%f, %f)\n", this,
+mFrameMetrics.GetScrollOffset().x, mFrameMetrics.GetScrollOffset().y,
+aLayerMetrics.GetScrollOffset().x, aLayerMetrics.GetScrollOffset().y);
+mFrameMetrics.CopyScrollInfoFrom(aLayerMetrics);
+// Because of the scroll offset update, any inflight paint requests are
+// going to be ignored by layout, and so mLastDispatchedPaintMetrics
+// becomes incorrect for the purposes of calculating the LD transform. To
+// correct this we need to update mLastDispatchedPaintMetrics to be the
+// last thing we know was painted by Gecko.
+mLastDispatchedPaintMetrics = aLayerMetrics;
+}
+}
+if (scrollOffsetUpdated) {
+// Once layout issues a scroll offset update, it becomes impervious to
+// scroll offset updates from APZ until we acknowledge the update it sent.
+// This prevents APZ updates from clobbering scroll updates from other
+// more "legitimate" sources like content scripts.
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+APZC_LOG("%p sending scroll update acknowledgement with gen %lu\n", this, aLayerMetrics.GetScrollGeneration());
+controller->AcknowledgeScrollUpdate(aLayerMetrics.GetScrollId(),
+aLayerMetrics.GetScrollGeneration());
+}
+}
+if (needContentRepaint) {
+RequestContentRepaint();
+}
+UpdateSharedCompositorFrameMetrics();
+}
+const FrameMetrics& AsyncPanZoomController::GetFrameMetrics() {
+mMonitor.AssertCurrentThreadIn();
+return mFrameMetrics;
+}
+void AsyncPanZoomController::ZoomToRect(CSSRect aRect) {
+if (!aRect.IsFinite()) {
+NS_WARNING("ZoomToRect got called with a non-finite rect; ignoring...\n");
+return;
+}
+SetState(ANIMATING_ZOOM);
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+ParentLayerIntRect compositionBounds = mFrameMetrics.mCompositionBounds;
+CSSRect cssPageRect = mFrameMetrics.mScrollableRect;
+CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset();
+CSSToParentLayerScale currentZoom = mFrameMetrics.GetZoomToParent();
+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 * mFrameMetrics.mTransformScale).scale,
+std::max(compositionBounds.width / cssPageRect.width,
+compositionBounds.height / cssPageRect.height)));
+CSSToParentLayerScale localMaxZoom = mZoomConstraints.mMaxZoom * mFrameMetrics.mTransformScale;
+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, request received from browserElementScrolling.js
+// 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.
+if (aRect.IsEmpty() ||
+(currentZoom == localMaxZoom && targetZoom >= localMaxZoom) ||
+(currentZoom == localMinZoom && targetZoom <= localMinZoom)) {
+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;
+endZoomToMetrics.SetZoom(targetZoom / mFrameMetrics.mTransformScale);
+// Adjust the zoomToRect to a sensible position to prevent overscrolling.
+CSSSize sizeAfterZoom = endZoomToMetrics.CalculateCompositedSizeInCssPixels();
+// 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());
+endZoomToMetrics.SetDisplayPortMargins(
+CalculatePendingDisplayPort(endZoomToMetrics,
+ScreenPoint(0,0),
+0));
+endZoomToMetrics.SetUseDisplayPortMargins();
+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.
+RequestContentRepaint(endZoomToMetrics);
+}
+}
+void AsyncPanZoomController::ContentReceivedTouch(bool aPreventDefault) {
+mTouchBlockState.mPreventDefaultSet = true;
+mTouchBlockState.mPreventDefault = aPreventDefault;
+CheckContentResponse();
+}
+void AsyncPanZoomController::CheckContentResponse() {
+bool canProceedToTouchState = true;
+if (mFrameMetrics.mMayHaveTouchListeners) {
+canProceedToTouchState &= mTouchBlockState.mPreventDefaultSet;
+}
+if (mTouchActionPropertyEnabled) {
+canProceedToTouchState &= mTouchBlockState.mAllowedTouchBehaviorSet;
+}
+if (!canProceedToTouchState) {
+return;
+}
+if (mContentResponseTimeoutTask) {
+mContentResponseTimeoutTask->Cancel();
+mContentResponseTimeoutTask = nullptr;
+}
+if (mState == WAITING_CONTENT_RESPONSE) {
+if (!mTouchBlockState.mPreventDefault) {
+SetState(NOTHING);
+}
+mHandlingTouchQueue = true;
+while (!mTouchQueue.IsEmpty()) {
+if (!mTouchBlockState.mPreventDefault) {
+HandleInputEvent(mTouchQueue[0]);
+}
+if (mTouchQueue[0].mType == MultiTouchInput::MULTITOUCH_END ||
+mTouchQueue[0].mType == MultiTouchInput::MULTITOUCH_CANCEL) {
+mTouchQueue.RemoveElementAt(0);
+break;
+}
+mTouchQueue.RemoveElementAt(0);
+}
+mHandlingTouchQueue = false;
+}
+}
+bool AsyncPanZoomController::TouchActionAllowPinchZoom() {
+if (!mTouchActionPropertyEnabled) {
+return true;
+}
+// Pointer events specification implies all touch points to allow zoom
+// to perform it.
+for (size_t i = 0; i < mTouchBlockState.mAllowedTouchBehaviors.Length(); i++) {
+if (!(mTouchBlockState.mAllowedTouchBehaviors[i] & AllowedTouchBehavior::PINCH_ZOOM)) {
+return false;
+}
+}
+return true;
+}
+bool AsyncPanZoomController::TouchActionAllowDoubleTapZoom() {
+if (!mTouchActionPropertyEnabled) {
+return true;
+}
+for (size_t i = 0; i < mTouchBlockState.mAllowedTouchBehaviors.Length(); i++) {
+if (!(mTouchBlockState.mAllowedTouchBehaviors[i] & AllowedTouchBehavior::DOUBLE_TAP_ZOOM)) {
+return false;
+}
+}
+return true;
+}
+AsyncPanZoomController::TouchBehaviorFlags
+AsyncPanZoomController::GetTouchBehavior(uint32_t touchIndex) {
+if (touchIndex < mTouchBlockState.mAllowedTouchBehaviors.Length()) {
+return mTouchBlockState.mAllowedTouchBehaviors[touchIndex];
+}
+return DefaultTouchBehavior;
+}
+AsyncPanZoomController::TouchBehaviorFlags
+AsyncPanZoomController::GetAllowedTouchBehavior(ScreenIntPoint& aPoint) {
+// Here we need to perform a hit testing over the touch-action regions attached to the
+// layer associated with current apzc.
+// Currently they are in progress, for more info see bug 928833.
+return AllowedTouchBehavior::UNKNOWN;
+}
+void AsyncPanZoomController::SetAllowedTouchBehavior(const nsTArray<TouchBehaviorFlags>& aBehaviors) {
+mTouchBlockState.mAllowedTouchBehaviors.Clear();
+mTouchBlockState.mAllowedTouchBehaviors.AppendElements(aBehaviors);
+mTouchBlockState.mAllowedTouchBehaviorSet = true;
+CheckContentResponse();
+}
+void AsyncPanZoomController::SetState(PanZoomState aNewState) {
+PanZoomState oldState;
+// Intentional scoping for mutex
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+oldState = mState;
+mState = aNewState;
+}
+if (nsRefPtr<GeckoContentController> controller = GetGeckoContentController()) {
+if (!IsTransformingState(oldState) && IsTransformingState(aNewState)) {
+controller->NotifyAPZStateChange(
+GetGuid(), APZStateChange::TransformBegin);
+} else if (IsTransformingState(oldState) && !IsTransformingState(aNewState)) {
+controller->NotifyAPZStateChange(
+GetGuid(), APZStateChange::TransformEnd);
+}
+}
+}
+bool AsyncPanZoomController::IsTransformingState(PanZoomState aState) {
+return !(aState == NOTHING || aState == TOUCHING || aState == WAITING_CONTENT_RESPONSE);
+}
+bool AsyncPanZoomController::IsPanningState(PanZoomState aState) {
+return (aState == PANNING || aState == PANNING_LOCKED_X || aState == PANNING_LOCKED_Y);
+}
+void AsyncPanZoomController::SetContentResponseTimer() {
+if (!mContentResponseTimeoutTask) {
+mContentResponseTimeoutTask =
+NewRunnableMethod(this, &AsyncPanZoomController::TimeoutContentResponse);
+PostDelayedTask(mContentResponseTimeoutTask, gfxPrefs::APZContentResponseTimeout());
+}
+}
+void AsyncPanZoomController::TimeoutContentResponse() {
+mContentResponseTimeoutTask = nullptr;
+ContentReceivedTouch(false);
+}
+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...\n");
+return;
+}
+// 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_ZOOM > aConstraints.mMinZoom ? MIN_ZOOM : aConstraints.mMinZoom);
+mZoomConstraints.mMaxZoom = (MAX_ZOOM > aConstraints.mMaxZoom ? aConstraints.mMaxZoom : MAX_ZOOM);
+if (mZoomConstraints.mMaxZoom < mZoomConstraints.mMinZoom) {
+mZoomConstraints.mMaxZoom = mZoomConstraints.mMinZoom;
+}
+}
+ZoomConstraints
+AsyncPanZoomController::GetZoomConstraints() const
+{
+return mZoomConstraints;
+}
+void AsyncPanZoomController::PostDelayedTask(Task* aTask, int aDelayMs) {
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (controller) {
+controller->PostDelayedTask(aTask, aDelayMs);
+}
+}
+void AsyncPanZoomController::SendAsyncScrollEvent() {
+nsRefPtr<GeckoContentController> controller = GetGeckoContentController();
+if (!controller) {
+return;
+}
+bool isRoot;
+CSSRect contentRect;
+CSSSize scrollableSize;
+{
+ReentrantMonitorAutoEnter lock(mMonitor);
+isRoot = mFrameMetrics.mIsRoot;
+scrollableSize = mFrameMetrics.mScrollableRect.Size();
+contentRect = mFrameMetrics.CalculateCompositedRectInCssPixels();
+contentRect.MoveTo(mCurrentAsyncScrollOffset);
+}
+controller->SendAsyncScrollDOMEvent(isRoot, contentRect, scrollableSize);
+}
+bool AsyncPanZoomController::Matches(const ScrollableLayerGuid& aGuid)
+{
+return aGuid == GetGuid();
+}
+void AsyncPanZoomController::GetGuid(ScrollableLayerGuid* aGuidOut)
+{
+if (aGuidOut) {
+*aGuidOut = GetGuid();
+}
+}
+ScrollableLayerGuid AsyncPanZoomController::GetGuid()
+{
+return ScrollableLayerGuid(mLayersId, mFrameMetrics);
+}
+void AsyncPanZoomController::UpdateSharedCompositorFrameMetrics()
+{
+mMonitor.AssertCurrentThreadIn();
+FrameMetrics* frame = mSharedFrameMetricsBuffer ?
+static_cast<FrameMetrics*>(mSharedFrameMetricsBuffer->memory()) : nullptr;
+if (frame && mSharedLock && gfxPrefs::UseProgressiveTilePainting()) {
+mSharedLock->Lock();
+*frame = mFrameMetrics;
+mSharedLock->Unlock();
+}
+}
+void AsyncPanZoomController::ShareCompositorFrameMetrics() {
+PCompositorParent* compositor =
+(mCrossProcessCompositorParent ? mCrossProcessCompositorParent : mCompositorParent.get());
+// Only create the shared memory buffer if it hasn't already been created,
+// we are using progressive tile painting, and we have a
+// compositor to pass the shared memory back to the content process/thread.
+if (!mSharedFrameMetricsBuffer && compositor && gfxPrefs::UseProgressiveTilePainting()) {
+// 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<FrameMetrics*>(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::ProcessHandle processHandle = compositor->OtherProcess();
+ipc::SharedMemoryBasic::Handle mem = ipc::SharedMemoryBasic::NULLHandle();
+// Get the shared memory handle to share with the content process
+mSharedFrameMetricsBuffer->ShareToProcess(processHandle, &mem);
+// Get the cross process mutex handle to share with the content process
+mSharedLock = new CrossProcessMutex("AsyncPanZoomControlLock");
+CrossProcessMutexHandle handle = mSharedLock->ShareToProcess(processHandle);
+// 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 (!compositor->SendSharedCompositorFrameMetrics(mem, handle, mAPZCId)) {
+APZC_LOG("%p failed to share FrameMetrics with content process.", this);
+}
+}
+}
+}
+ParentLayerPoint AsyncPanZoomController::ToParentLayerCoords(const ScreenPoint& aPoint)
+{
+return TransformTo<ParentLayerPixel>(GetNontransientAsyncTransform() * GetCSSTransform(), aPoint);
+}
+void AsyncPanZoomController::UpdateTransformScale()
+{
+gfx3DMatrix nontransientTransforms = GetNontransientAsyncTransform() * GetCSSTransform();
+if (!FuzzyEqualsMultiplicative(nontransientTransforms.GetXScale(), nontransientTransforms.GetYScale())) {
+NS_WARNING("The x- and y-scales of the nontransient transforms should be equal");
+}
+mFrameMetrics.mTransformScale.scale = nontransientTransforms.GetXScale();
+}
+}
+}

The Tor Browser / file comparison

comparison: gfx/layers/apz/src/AsyncPanZoomController.cpp

gfx/layers/apz/src/AsyncPanZoomController.cpp