Source code

Revision control

Other Tools

1
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3
/* This Source Code Form is subject to the terms of the Mozilla Public
4
* License, v. 2.0. If a copy of the MPL was not distributed with this
5
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7
#ifndef GFX_REPAINTREQUEST_H
8
#define GFX_REPAINTREQUEST_H
9
10
#include <stdint.h> // for uint8_t, uint32_t, uint64_t
11
12
#include "FrameMetrics.h" // for FrameMetrics
13
#include "mozilla/DefineEnum.h" // for MOZ_DEFINE_ENUM
14
#include "mozilla/gfx/BasePoint.h" // for BasePoint
15
#include "mozilla/gfx/Rect.h" // for RoundedIn
16
#include "mozilla/gfx/ScaleFactor.h" // for ScaleFactor
17
#include "mozilla/TimeStamp.h" // for TimeStamp
18
#include "Units.h" // for CSSRect, CSSPixel, etc
19
20
namespace IPC {
21
template <typename T>
22
struct ParamTraits;
23
} // namespace IPC
24
25
namespace mozilla {
26
namespace layers {
27
28
struct RepaintRequest {
29
friend struct IPC::ParamTraits<mozilla::layers::RepaintRequest>;
30
31
public:
32
// clang-format off
33
MOZ_DEFINE_ENUM_WITH_BASE_AT_CLASS_SCOPE(
34
ScrollOffsetUpdateType, uint8_t, (
35
eNone, // The default; the scroll offset was not updated.
36
eUserAction, // The scroll offset was updated by APZ in response
37
// to user action.
38
eVisualUpdate // The scroll offset was updated by APZ in response
39
// to a visual scroll update request from the
40
// main thread.
41
));
42
// clang-format on
43
44
RepaintRequest()
45
: mScrollId(ScrollableLayerGuid::NULL_SCROLL_ID),
46
mPresShellResolution(1),
47
mCompositionBounds(0, 0, 0, 0),
48
mCumulativeResolution(),
49
mDevPixelsPerCSSPixel(1),
50
mScrollOffset(0, 0),
51
mZoom(),
52
mScrollGeneration(0),
53
mDisplayPortMargins(0, 0, 0, 0),
54
mPresShellId(-1),
55
mLayoutViewport(0, 0, 0, 0),
56
mExtraResolution(),
57
mPaintRequestTime(),
58
mScrollUpdateType(eNone),
59
mIsRootContent(false),
60
mIsScrollInfoLayer(false) {}
61
62
RepaintRequest(const FrameMetrics& aOther,
63
const ScrollOffsetUpdateType aScrollUpdateType)
64
: mScrollId(aOther.GetScrollId()),
65
mPresShellResolution(aOther.GetPresShellResolution()),
66
mCompositionBounds(aOther.GetCompositionBounds()),
67
mCumulativeResolution(aOther.GetCumulativeResolution()),
68
mDevPixelsPerCSSPixel(aOther.GetDevPixelsPerCSSPixel()),
69
mScrollOffset(aOther.GetScrollOffset()),
70
mZoom(aOther.GetZoom()),
71
mScrollGeneration(aOther.GetScrollGeneration()),
72
mDisplayPortMargins(aOther.GetDisplayPortMargins()),
73
mPresShellId(aOther.GetPresShellId()),
74
mLayoutViewport(aOther.GetLayoutViewport()),
75
mExtraResolution(aOther.GetExtraResolution()),
76
mPaintRequestTime(aOther.GetPaintRequestTime()),
77
mScrollUpdateType(aScrollUpdateType),
78
mIsRootContent(aOther.IsRootContent()),
79
mIsScrollInfoLayer(aOther.IsScrollInfoLayer()) {}
80
81
// Default copy ctor and operator= are fine
82
83
bool operator==(const RepaintRequest& aOther) const {
84
// Put mScrollId at the top since it's the most likely one to fail.
85
return mScrollId == aOther.mScrollId &&
86
mPresShellResolution == aOther.mPresShellResolution &&
87
mCompositionBounds.IsEqualEdges(aOther.mCompositionBounds) &&
88
mCumulativeResolution == aOther.mCumulativeResolution &&
89
mDevPixelsPerCSSPixel == aOther.mDevPixelsPerCSSPixel &&
90
mScrollOffset == aOther.mScrollOffset &&
91
// don't compare mZoom
92
mScrollGeneration == aOther.mScrollGeneration &&
93
mDisplayPortMargins == aOther.mDisplayPortMargins &&
94
mPresShellId == aOther.mPresShellId &&
95
mLayoutViewport.IsEqualEdges(aOther.mLayoutViewport) &&
96
mExtraResolution == aOther.mExtraResolution &&
97
mPaintRequestTime == aOther.mPaintRequestTime &&
98
mScrollUpdateType == aOther.mScrollUpdateType &&
99
mIsRootContent == aOther.mIsRootContent &&
100
mIsScrollInfoLayer == aOther.mIsScrollInfoLayer;
101
}
102
103
bool operator!=(const RepaintRequest& aOther) const {
104
return !operator==(aOther);
105
}
106
107
CSSToScreenScale2D DisplayportPixelsPerCSSPixel() const {
108
// Note: use 'mZoom * ParentLayerToLayerScale(1.0f)' as the CSS-to-Layer
109
// scale instead of LayersPixelsPerCSSPixel(), because displayport
110
// calculations are done in the context of a repaint request, where we ask
111
// Layout to repaint at a new resolution that includes any async zoom. Until
112
// this repaint request is processed, LayersPixelsPerCSSPixel() does not yet
113
// include the async zoom, but it will when the displayport is interpreted
114
// for the repaint.
115
return mZoom * ParentLayerToLayerScale(1.0f) / mExtraResolution;
116
}
117
118
CSSToLayerScale2D LayersPixelsPerCSSPixel() const {
119
return mDevPixelsPerCSSPixel * mCumulativeResolution;
120
}
121
122
// Get the amount by which this frame has been zoomed since the last repaint.
123
LayerToParentLayerScale GetAsyncZoom() const {
124
// The async portion of the zoom should be the same along the x and y
125
// axes.
126
return (mZoom / LayersPixelsPerCSSPixel()).ToScaleFactor();
127
}
128
129
CSSSize CalculateCompositedSizeInCssPixels() const {
130
if (GetZoom() == CSSToParentLayerScale2D(0, 0)) {
131
return CSSSize(); // avoid division by zero
132
}
133
return mCompositionBounds.Size() / GetZoom();
134
}
135
136
float GetPresShellResolution() const { return mPresShellResolution; }
137
138
const ParentLayerRect& GetCompositionBounds() const {
139
return mCompositionBounds;
140
}
141
142
const LayoutDeviceToLayerScale2D& GetCumulativeResolution() const {
143
return mCumulativeResolution;
144
}
145
146
const CSSToLayoutDeviceScale& GetDevPixelsPerCSSPixel() const {
147
return mDevPixelsPerCSSPixel;
148
}
149
150
bool IsRootContent() const { return mIsRootContent; }
151
152
const CSSPoint& GetScrollOffset() const { return mScrollOffset; }
153
154
const CSSToParentLayerScale2D& GetZoom() const { return mZoom; }
155
156
ScrollOffsetUpdateType GetScrollUpdateType() const {
157
return mScrollUpdateType;
158
}
159
160
bool GetScrollOffsetUpdated() const { return mScrollUpdateType != eNone; }
161
162
uint32_t GetScrollGeneration() const { return mScrollGeneration; }
163
164
ScrollableLayerGuid::ViewID GetScrollId() const { return mScrollId; }
165
166
const ScreenMargin& GetDisplayPortMargins() const {
167
return mDisplayPortMargins;
168
}
169
170
uint32_t GetPresShellId() const { return mPresShellId; }
171
172
const CSSRect& GetLayoutViewport() const { return mLayoutViewport; }
173
174
const ScreenToLayerScale2D& GetExtraResolution() const {
175
return mExtraResolution;
176
}
177
178
const TimeStamp& GetPaintRequestTime() const { return mPaintRequestTime; }
179
180
bool IsScrollInfoLayer() const { return mIsScrollInfoLayer; }
181
182
protected:
183
void SetIsRootContent(bool aIsRootContent) {
184
mIsRootContent = aIsRootContent;
185
}
186
187
void SetIsScrollInfoLayer(bool aIsScrollInfoLayer) {
188
mIsScrollInfoLayer = aIsScrollInfoLayer;
189
}
190
191
private:
192
// A ID assigned to each scrollable frame, unique within each LayersId..
193
ScrollableLayerGuid::ViewID mScrollId;
194
195
// The pres-shell resolution that has been induced on the document containing
196
// this scroll frame as a result of zooming this scroll frame (whether via
197
// user action, or choosing an initial zoom level on page load). This can
198
// only be different from 1.0 for frames that are zoomable, which currently
199
// is just the root content document's root scroll frame
200
// (mIsRootContent = true).
201
// This is a plain float rather than a ScaleFactor because in and of itself
202
// it does not convert between any coordinate spaces for which we have names.
203
float mPresShellResolution;
204
205
// This is the area within the widget that we're compositing to. It is in the
206
// layer coordinates of the scrollable content's parent layer.
207
//
208
// The size of the composition bounds corresponds to the size of the scroll
209
// frame's scroll port (but in a coordinate system where the size does not
210
// change during zooming).
211
//
212
// The origin of the composition bounds is relative to the layer tree origin.
213
// Unlike the scroll port's origin, it does not change during scrolling of
214
// the scrollable layer to which it is associated. However, it may change due
215
// to scrolling of ancestor layers.
216
//
217
// This value is provided by Gecko at layout/paint time.
218
ParentLayerRect mCompositionBounds;
219
220
// The cumulative resolution that the current frame has been painted at.
221
// This is the product of the pres-shell resolutions of the document
222
// containing this scroll frame and its ancestors, and any css-driven
223
// resolution. This information is provided by Gecko at layout/paint time.
224
// Note that this is allowed to have different x- and y-scales, but only
225
// for subframes (mIsRootContent = false). (The same applies to other scales
226
// that "inherit" the 2D-ness of this one, such as mZoom.)
227
LayoutDeviceToLayerScale2D mCumulativeResolution;
228
229
// The conversion factor between CSS pixels and device pixels for this frame.
230
// This can vary based on a variety of things, such as reflowing-zoom.
231
CSSToLayoutDeviceScale mDevPixelsPerCSSPixel;
232
233
// The position of the top-left of the scroll frame's scroll port, relative
234
// to the scrollable content's origin.
235
CSSPoint mScrollOffset;
236
237
// The "user zoom". Content is painted by gecko at mCumulativeResolution *
238
// mDevPixelsPerCSSPixel, but will be drawn to the screen at mZoom. In the
239
// steady state, the two will be the same, but during an async zoom action the
240
// two may diverge. This information is initialized in Gecko but updated in
241
// the APZC.
242
CSSToParentLayerScale2D mZoom;
243
244
// The scroll generation counter used to acknowledge the scroll offset update.
245
uint32_t mScrollGeneration;
246
247
// A display port expressed as layer margins that apply to the rect of what
248
// is drawn of the scrollable element.
249
ScreenMargin mDisplayPortMargins;
250
251
uint32_t mPresShellId;
252
253
// For a root scroll frame (RSF), the document's layout viewport
254
// (sometimes called "CSS viewport" in older code).
255
//
256
// Its size is the dimensions we're using to constrain the <html> element
257
// of the document (i.e. the initial containing block (ICB) size).
258
//
259
// Its origin is the RSF's layout scroll position, i.e. the scroll position
260
// exposed to web content via window.scrollX/Y.
261
//
262
// Note that only the root content document's RSF has a layout viewport
263
// that's distinct from the visual viewport. For an iframe RSF, the two
264
// are the same.
265
//
266
// For a scroll frame that is not an RSF, this metric is meaningless and
267
// invalid.
268
CSSRect mLayoutViewport;
269
270
// The extra resolution at which content in this scroll frame is drawn beyond
271
// that necessary to draw one Layer pixel per Screen pixel.
272
ScreenToLayerScale2D mExtraResolution;
273
274
// The time at which the APZC last requested a repaint for this scroll frame.
275
TimeStamp mPaintRequestTime;
276
277
// The type of repaint request this represents.
278
ScrollOffsetUpdateType mScrollUpdateType;
279
280
// Whether or not this is the root scroll frame for the root content document.
281
bool mIsRootContent : 1;
282
283
// True if this scroll frame is a scroll info layer. A scroll info layer is
284
// not layerized and its content cannot be truly async-scrolled, but its
285
// metrics are still sent to and updated by the compositor, with the updates
286
// being reflected on the next paint rather than the next composite.
287
bool mIsScrollInfoLayer : 1;
288
};
289
290
} // namespace layers
291
} // namespace mozilla
292
293
#endif /* GFX_REPAINTREQUEST_H */