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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
content / browser / android / synchronous_compositor_host.h [blame]
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_ANDROID_SYNCHRONOUS_COMPOSITOR_HOST_H_
#define CONTENT_BROWSER_ANDROID_SYNCHRONOUS_COMPOSITOR_HOST_H_
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include "base/gtest_prod_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/task/single_thread_task_runner.h"
#include "components/viz/common/frame_sinks/begin_frame_source.h"
#include "components/viz/common/quads/compositor_frame.h"
#include "components/viz/common/surfaces/frame_sink_id.h"
#include "content/common/content_export.h"
#include "content/public/browser/android/synchronous_compositor.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "third_party/blink/public/mojom/input/input_event_result.mojom-shared.h"
#include "third_party/blink/public/mojom/input/synchronous_compositor.mojom.h"
#include "ui/android/view_android.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/size_f.h"
namespace ui {
struct DidOverscrollParams;
}
namespace viz {
class HostFrameSinkManager;
}
namespace content {
class RenderProcessHost;
class RenderWidgetHostViewAndroid;
class SynchronousCompositorClient;
class SynchronousCompositorSyncCallBridge;
class CONTENT_EXPORT SynchronousCompositorHost
: public SynchronousCompositor,
public blink::mojom::SynchronousCompositorHost,
public viz::BeginFrameObserver {
public:
static std::unique_ptr<SynchronousCompositorHost> Create(
RenderWidgetHostViewAndroid* rwhva,
const viz::FrameSinkId& frame_sink_id,
viz::HostFrameSinkManager* host_frame_sink_manager);
SynchronousCompositorHost(const SynchronousCompositorHost&) = delete;
SynchronousCompositorHost& operator=(const SynchronousCompositorHost&) =
delete;
~SynchronousCompositorHost() override;
// SynchronousCompositor overrides.
void OnCompositorVisible() override;
void OnCompositorHidden() override;
scoped_refptr<FrameFuture> DemandDrawHwAsync(
const gfx::Size& viewport_size,
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority) override;
bool DemandDrawSw(SkCanvas* canvas, bool software_canvas) override;
void ReturnResources(uint32_t layer_tree_frame_sink_id,
std::vector<viz::ReturnedResource> resources) override;
void OnCompositorFrameTransitionDirectiveProcessed(
uint32_t layer_tree_frame_sink_id,
uint32_t sequence_id) override;
void DidPresentCompositorFrames(viz::FrameTimingDetailsMap timing_details,
uint32_t frame_token) override;
void SetMemoryPolicy(size_t bytes_limit) override;
float GetVelocityInPixelsPerSecond() override;
void DidBecomeActive() override;
void DidChangeRootLayerScrollOffset(const gfx::PointF& root_offset) override;
void SynchronouslyZoomBy(float zoom_delta, const gfx::Point& anchor) override;
void OnComputeScroll(base::TimeTicks animation_time) override;
void SetBeginFrameSource(viz::BeginFrameSource* begin_frame_source) override;
void DidInvalidate() override;
void WasEvicted() override;
ui::ViewAndroid::CopyViewCallback GetCopyViewCallback();
void DidOverscroll(const ui::DidOverscrollParams& over_scroll_params);
// Called by SynchronousCompositorSyncCallBridge.
void UpdateFrameMetaData(
uint32_t version,
viz::CompositorFrameMetadata frame_metadata,
std::optional<viz::LocalSurfaceId> new_local_surface_id);
void BeginFrameComplete(
blink::mojom::SyncCompositorCommonRendererParamsPtr params);
// Called when the mojo channel should be created.
void InitMojo();
SynchronousCompositorClient* client() { return client_; }
RenderProcessHost* GetRenderProcessHost();
void RequestOneBeginFrame();
void AddBeginFrameCompletionCallback(base::OnceClosure callback);
const viz::FrameSinkId& GetFrameSinkId() const { return frame_sink_id_; }
viz::SurfaceId GetSurfaceId() const;
// blink::mojom::SynchronousCompositorHost overrides.
void LayerTreeFrameSinkCreated() override;
void UpdateState(
blink::mojom::SyncCompositorCommonRendererParamsPtr params) override;
void SetNeedsBeginFrames(bool needs_begin_frames) override;
void SetThreads(const std::vector<viz::Thread>& threads) override;
// viz::BeginFrameObserver implementation.
void OnBeginFrame(const viz::BeginFrameArgs& args) override;
const viz::BeginFrameArgs& LastUsedBeginFrameArgs() const override;
void OnBeginFrameSourcePausedChanged(bool paused) override;
bool WantsAnimateOnlyBeginFrames() const override;
private:
enum BeginFrameRequestType {
BEGIN_FRAME = 1 << 0,
PERSISTENT_BEGIN_FRAME = 1 << 1
};
class ScopedSendZeroMemory;
struct SharedMemoryWithSize;
friend class ScopedSetZeroMemory;
friend class SynchronousCompositorBase;
FRIEND_TEST_ALL_PREFIXES(SynchronousCompositorBrowserTest,
RenderWidgetHostViewAndroidReuse);
SynchronousCompositorHost(RenderWidgetHostViewAndroid* rwhva,
const viz::FrameSinkId& frame_sink_id,
viz::HostFrameSinkManager* host_frame_sink_manager,
bool use_in_proc_software_draw);
SynchronousCompositor::Frame DemandDrawHw(
const gfx::Size& viewport_size,
const gfx::Rect& viewport_rect_for_tile_priority,
const gfx::Transform& transform_for_tile_priority);
bool DemandDrawSwInProc(SkCanvas* canvas);
void SetSoftwareDrawSharedMemoryIfNeeded(size_t stride, size_t buffer_size);
void SendZeroMemory();
blink::mojom::SynchronousCompositor* GetSynchronousCompositor();
// Whether the synchronous compositor host is ready to
// handle blocking calls.
bool IsReadyForSynchronousCall();
void UpdateRootLayerStateOnClient();
void SendBeginFramePaused();
void SendBeginFrame(viz::BeginFrameArgs args);
void AddBeginFrameRequest(BeginFrameRequestType request);
void ClearBeginFrameRequest(BeginFrameRequestType request);
const raw_ptr<RenderWidgetHostViewAndroid> rwhva_;
const raw_ptr<SynchronousCompositorClient> client_;
const viz::FrameSinkId frame_sink_id_;
const raw_ptr<viz::HostFrameSinkManager> host_frame_sink_manager_;
const bool use_in_process_zero_copy_software_draw_;
mojo::AssociatedRemote<blink::mojom::SynchronousCompositor> sync_compositor_;
mojo::AssociatedReceiver<blink::mojom::SynchronousCompositorHost>
host_receiver_{this};
viz::LocalSurfaceId local_surface_id_;
bool registered_with_filter_ = false;
size_t bytes_limit_;
std::unique_ptr<SharedMemoryWithSize> software_draw_shm_;
// Make sure to send a synchronous IPC that succeeds first before sending
// asynchronous ones. This shouldn't be needed. However we may have come
// to rely on sending a synchronous message first on initialization. So
// with an abundance of caution, keep that behavior until we are sure this
// isn't required.
bool allow_async_draw_ = false;
// Indicates begin frames are paused from the browser.
bool begin_frame_paused_ = false;
// Updated by both renderer and browser. This is in physical pixels.
gfx::PointF root_scroll_offset_;
float velocity_in_pixels_per_second_ = 0.f;
base::TimeDelta last_begin_frame_time_delta_;
// Indicates that whether OnComputeScroll is called or overridden. The
// fling_controller should advance the fling only when OnComputeScroll is not
// overridden.
bool on_compute_scroll_called_ = false;
// Whether `DemandDrawHwAsync` has ever been called.
bool draw_hw_called_ = false;
// From renderer.
uint32_t renderer_param_version_;
uint32_t need_invalidate_count_;
bool invalidate_needs_draw_;
uint32_t did_activate_pending_tree_count_;
uint32_t frame_metadata_version_ = 0u;
// Physical pixel when use-zoom-for-dsf is enabled, otherwise in dip.
gfx::PointF max_scroll_offset_;
gfx::SizeF scrollable_size_;
float page_scale_factor_ = 0.f;
float min_page_scale_factor_ = 0.f;
float max_page_scale_factor_ = 0.f;
// If the last surface was evicted.
bool was_evicted_ = false;
scoped_refptr<SynchronousCompositorSyncCallBridge> bridge_;
// Indicates whether and for what reason a request for begin frames has been
// issued. Used to control action dispatch at the next |OnBeginFrame()| call.
uint32_t outstanding_begin_frame_requests_ = 0;
uint32_t num_invalidates_since_last_draw_ = 0u;
uint32_t num_begin_frames_to_skip_ = 0u;
// The begin frame source being observed. Null if none.
raw_ptr<viz::BeginFrameSource> begin_frame_source_ = nullptr;
viz::BeginFrameArgs last_begin_frame_args_;
viz::FrameTimingDetailsMap timing_details_;
};
} // namespace content
#endif // CONTENT_BROWSER_ANDROID_SYNCHRONOUS_COMPOSITOR_HOST_H_