1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 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/. */
#ifndef mozilla_layers_GeckoContentController_h
#define mozilla_layers_GeckoContentController_h
#include "GeckoContentControllerTypes.h"
#include "InputData.h" // for PinchGestureInput
#include "LayersTypes.h" // for ScrollDirection
#include "Units.h" // for CSSPoint, CSSRect, etc
#include "mozilla/Assertions.h" // for MOZ_ASSERT_HELPER2
#include "mozilla/Attributes.h" // for MOZ_CAN_RUN_SCRIPT
#include "mozilla/DefineEnum.h" // for MOZ_DEFINE_ENUM
#include "mozilla/EventForwards.h" // for Modifiers
#include "mozilla/layers/APZThreadUtils.h"
#include "mozilla/layers/MatrixMessage.h" // for MatrixMessage
#include "mozilla/layers/ScrollableLayerGuid.h" // for ScrollableLayerGuid, etc
#include "nsISupportsImpl.h"
namespace mozilla {
class Runnable;
namespace layers {
struct DoubleTapToZoomMetrics;
struct RepaintRequest;
class GeckoContentController {
public:
using APZStateChange = GeckoContentController_APZStateChange;
using TapType = GeckoContentController_TapType;
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GeckoContentController)
/**
* Notifies the content side of the most recently computed transforms for
* each layers subtree to the root. The nsTArray will contain one
* MatrixMessage for each layers id in the current APZ tree, along with the
* corresponding transform.
*/
virtual void NotifyLayerTransforms(nsTArray<MatrixMessage>&& aTransforms) = 0;
/**
* Requests a paint of the given RepaintRequest |aRequest| from Gecko.
* Implementations per-platform are responsible for actually handling this.
*
* This method must always be called on the repaint thread, which depends
* on the GeckoContentController. For ChromeProcessController it is the
* Gecko main thread, while for RemoteContentController it is the compositor
* thread where it can send IPDL messages.
*/
virtual void RequestContentRepaint(const RepaintRequest& aRequest) = 0;
/**
* Requests handling of a tap event. |aPoint| is in LD pixels, relative to the
* current scroll offset.
*/
MOZ_CAN_RUN_SCRIPT
virtual void HandleTap(
TapType aType, const LayoutDevicePoint& aPoint, Modifiers aModifiers,
const ScrollableLayerGuid& aGuid, uint64_t aInputBlockId,
const Maybe<DoubleTapToZoomMetrics>& aDoubleTapTooZoomMetrics) = 0;
/**
* When the apz.allow_zooming pref is set to false, the APZ will not
* translate pinch gestures to actual zooming. Instead, it will call this
* method to notify gecko of the pinch gesture, and allow it to deal with it
* however it wishes. Note that this function is not called if the pinch is
* prevented by content calling preventDefault() on the touch events, or via
* use of the touch-action property.
* @param aType One of PINCHGESTURE_START, PINCHGESTURE_SCALE,
* PINCHGESTURE_FINGERLIFTED, or PINCHGESTURE_END, indicating the phase
* of the pinch.
* @param aGuid The guid of the APZ that is detecting the pinch. This is
* generally the root APZC for the layers id.
* @param aFocusPoint The focus point of the pinch event.
* @param aSpanChange For the START or END event, this is always 0.
* For a SCALE event, this is the difference in span between the
* previous state and the new state.
* @param aModifiers The keyboard modifiers depressed during the pinch.
*/
virtual void NotifyPinchGesture(PinchGestureInput::PinchGestureType aType,
const ScrollableLayerGuid& aGuid,
const LayoutDevicePoint& aFocusPoint,
LayoutDeviceCoord aSpanChange,
Modifiers aModifiers) = 0;
/**
* Schedules a runnable to run on the controller thread at some time
* in the future.
* This method must always be called on the controller thread.
*/
virtual void PostDelayedTask(already_AddRefed<Runnable> aRunnable,
int aDelayMs) {
APZThreadUtils::DelayedDispatch(std::move(aRunnable), aDelayMs);
}
/**
* Returns true if we are currently on the thread that can send repaint
* requests.
*/
virtual bool IsRepaintThread() = 0;
/**
* Runs the given task on the "repaint" thread.
*/
virtual void DispatchToRepaintThread(already_AddRefed<Runnable> aTask) = 0;
/**
* General notices of APZ state changes for consumers.
* |aGuid| identifies the APZC originating the state change.
* |aChange| identifies the type of state change
* |aArg| is used by some state changes to pass extra information (see
* the documentation for each state change above)
* |aInputBlockId| is populated for the |eStartTouch| and |eEndTouch|
* state changes and identifies the input block of the
* gesture that triggers the state change.
*/
virtual void NotifyAPZStateChange(const ScrollableLayerGuid& aGuid,
APZStateChange aChange, int aArg = 0,
Maybe<uint64_t> aInputBlockId = Nothing()) {
}
/**
* Notify content of a MozMouseScrollFailed event.
*/
virtual void NotifyMozMouseScrollEvent(
const ScrollableLayerGuid::ViewID& aScrollId, const nsString& aEvent) {}
/**
* Notify content that the repaint requests have been flushed.
*/
virtual void NotifyFlushComplete() = 0;
/**
* If the async scrollbar-drag initiation code kicks in on the APZ side, then
* we need to let content know that we are dragging the scrollbar. Otherwise,
* by the time the mousedown events is handled by content, the scrollthumb
* could already have been moved via a RequestContentRepaint message at a
* new scroll position, and the mousedown might end up triggering a click-to-
* scroll on where the thumb used to be.
*/
virtual void NotifyAsyncScrollbarDragInitiated(
uint64_t aDragBlockId, const ScrollableLayerGuid::ViewID& aScrollId,
ScrollDirection aDirection) = 0;
virtual void NotifyAsyncScrollbarDragRejected(
const ScrollableLayerGuid::ViewID& aScrollId) = 0;
virtual void NotifyAsyncAutoscrollRejected(
const ScrollableLayerGuid::ViewID& aScrollId) = 0;
virtual void CancelAutoscroll(const ScrollableLayerGuid& aGuid) = 0;
virtual void NotifyScaleGestureComplete(const ScrollableLayerGuid& aGuid,
float aScale) = 0;
virtual void UpdateOverscrollVelocity(const ScrollableLayerGuid& aGuid,
float aX, float aY,
bool aIsRootContent) {}
virtual void UpdateOverscrollOffset(const ScrollableLayerGuid& aGuid,
float aX, float aY, bool aIsRootContent) {
}
GeckoContentController() = default;
/**
* Needs to be called on the main thread.
*/
virtual void Destroy() {}
/**
* Whether this is RemoteContentController.
*/
virtual bool IsRemote() { return false; }
virtual PresShell* GetTopLevelPresShell() const { return nullptr; };
protected:
// Protected destructor, to discourage deletion outside of Release():
virtual ~GeckoContentController() = default;
};
} // namespace layers
} // namespace mozilla
#endif // mozilla_layers_GeckoContentController_h
|
