blob: 01a92ff56c393e21f5760b007598f4265d8584f1 [file] [log] [blame]
boliubee541f42015-11-05 00:52:531// Copyright 2015 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/android/synchronous_compositor_host.h"
6
boliucafb1bf2015-12-29 01:40:197#include <utility>
8
boliuc99f26c12016-04-21 21:58:599#include "base/command_line.h"
boliubee541f42015-11-05 00:52:5310#include "base/containers/hash_tables.h"
boliuc99f26c12016-04-21 21:58:5911#include "base/memory/ptr_util.h"
boliuf6d263e2015-11-25 03:53:5812#include "base/memory/shared_memory.h"
13#include "base/trace_event/trace_event_argument.h"
boliu22557972016-10-25 16:08:2914#include "content/browser/android/synchronous_compositor_browser_filter.h"
boliubee541f42015-11-05 00:52:5315#include "content/browser/renderer_host/render_widget_host_view_android.h"
boliuc99f26c12016-04-21 21:58:5916#include "content/browser/web_contents/web_contents_android.h"
boliubee541f42015-11-05 00:52:5317#include "content/browser/web_contents/web_contents_impl.h"
18#include "content/common/android/sync_compositor_messages.h"
jbroman801dd272016-04-22 18:54:0219#include "content/common/android/sync_compositor_statics.h"
boliubee541f42015-11-05 00:52:5320#include "content/public/browser/android/synchronous_compositor_client.h"
hush92bd35e72015-11-13 22:57:3721#include "content/public/browser/browser_thread.h"
boliubee541f42015-11-05 00:52:5322#include "content/public/browser/render_view_host.h"
boliuc99f26c12016-04-21 21:58:5923#include "content/public/common/content_switches.h"
boliubee541f42015-11-05 00:52:5324#include "ipc/ipc_sender.h"
boliuf6d263e2015-11-25 03:53:5825#include "third_party/skia/include/core/SkBitmap.h"
26#include "third_party/skia/include/core/SkCanvas.h"
27#include "third_party/skia/include/core/SkImageInfo.h"
28#include "third_party/skia/include/core/SkRect.h"
chongza8ba91fc2016-08-16 21:39:1729#include "ui/events/blink/did_overscroll_params.h"
boliuf6d263e2015-11-25 03:53:5830#include "ui/gfx/skia_util.h"
boliubee541f42015-11-05 00:52:5331
32namespace content {
33
boliuc99f26c12016-04-21 21:58:5934// static
35void SynchronousCompositor::SetClientForWebContents(
36 WebContents* contents,
37 SynchronousCompositorClient* client) {
38 DCHECK(contents);
39 DCHECK(client);
40 WebContentsAndroid* web_contents_android =
41 static_cast<WebContentsImpl*>(contents)->GetWebContentsAndroid();
42 DCHECK(!web_contents_android->synchronous_compositor_client());
43 web_contents_android->set_synchronous_compositor_client(client);
44}
45
46// static
47std::unique_ptr<SynchronousCompositorHost> SynchronousCompositorHost::Create(
48 RenderWidgetHostViewAndroid* rwhva,
49 WebContents* web_contents) {
50 DCHECK(web_contents);
51 WebContentsAndroid* web_contents_android =
52 static_cast<WebContentsImpl*>(web_contents)->GetWebContentsAndroid();
53 if (!web_contents_android->synchronous_compositor_client())
54 return nullptr; // Not using sync compositing.
55
56 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
boliuc99f26c12016-04-21 21:58:5957 bool use_in_proc_software_draw =
58 command_line->HasSwitch(switches::kSingleProcess);
59 return base::WrapUnique(new SynchronousCompositorHost(
boliub2768db2016-06-03 23:35:1660 rwhva, web_contents_android->synchronous_compositor_client(),
boliuc99f26c12016-04-21 21:58:5961 use_in_proc_software_draw));
62}
63
boliubee541f42015-11-05 00:52:5364SynchronousCompositorHost::SynchronousCompositorHost(
65 RenderWidgetHostViewAndroid* rwhva,
boliu4d4b5a82016-02-17 01:55:2166 SynchronousCompositorClient* client,
67 bool use_in_proc_software_draw)
boliubee541f42015-11-05 00:52:5368 : rwhva_(rwhva),
69 client_(client),
thestig529ad8a2016-07-08 20:30:1270 ui_task_runner_(BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)),
hush284add62016-06-17 20:47:3371 process_id_(rwhva_->GetRenderWidgetHost()->GetProcess()->GetID()),
boliubee541f42015-11-05 00:52:5372 routing_id_(rwhva_->GetRenderWidgetHost()->GetRoutingID()),
boliubee541f42015-11-05 00:52:5373 sender_(rwhva_->GetRenderWidgetHost()),
boliu4d4b5a82016-02-17 01:55:2174 use_in_process_zero_copy_software_draw_(use_in_proc_software_draw),
boliubee541f42015-11-05 00:52:5375 bytes_limit_(0u),
76 renderer_param_version_(0u),
77 need_animate_scroll_(false),
boliu17bc31f2016-02-23 18:46:2878 need_invalidate_count_(0u),
boliu8f3016e2016-06-04 00:59:1879 did_activate_pending_tree_count_(0u) {
hush284add62016-06-17 20:47:3380 client_->DidInitializeCompositor(this, process_id_, routing_id_);
boliubee541f42015-11-05 00:52:5381}
82
83SynchronousCompositorHost::~SynchronousCompositorHost() {
hush284add62016-06-17 20:47:3384 client_->DidDestroyCompositor(this, process_id_, routing_id_);
boliubee541f42015-11-05 00:52:5385}
86
87bool SynchronousCompositorHost::OnMessageReceived(const IPC::Message& message) {
88 bool handled = true;
89 IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorHost, message)
danakj1120f4c2016-09-15 02:05:3290 IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_CompositorFrameSinkCreated,
91 CompositorFrameSinkCreated)
boliubee541f42015-11-05 00:52:5392 IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_UpdateState, ProcessCommonParams)
boliubee541f42015-11-05 00:52:5393 IPC_MESSAGE_UNHANDLED(handled = false)
94 IPC_END_MESSAGE_MAP()
95 return handled;
96}
97
boliuc37cd75b2016-10-24 17:54:3998scoped_refptr<SynchronousCompositor::FrameFuture>
99SynchronousCompositorHost::DemandDrawHwAsync(
ojars53392992016-09-03 00:09:06100 const gfx::Size& viewport_size,
101 const gfx::Rect& viewport_rect_for_tile_priority,
102 const gfx::Transform& transform_for_tile_priority) {
103 SyncCompositorDemandDrawHwParams params(viewport_size,
104 viewport_rect_for_tile_priority,
105 transform_for_tile_priority);
boliuc37cd75b2016-10-24 17:54:39106 scoped_refptr<FrameFuture> frame_future = new FrameFuture();
boliu22557972016-10-25 16:08:29107 if (SynchronousCompositorBrowserFilter* filter = GetFilter()) {
boliuc37cd75b2016-10-24 17:54:39108 filter->SetFrameFuture(routing_id_, frame_future);
109 sender_->Send(new SyncCompositorMsg_DemandDrawHwAsync(routing_id_, params));
110 } else {
boliuf26c9e0f2016-10-27 16:29:08111 frame_future->SetFrame(nullptr);
boliuc37cd75b2016-10-24 17:54:39112 }
113 return frame_future;
ojars53392992016-09-03 00:09:06114}
115
boliuf4e574852016-03-22 19:33:17116SynchronousCompositor::Frame SynchronousCompositorHost::DemandDrawHw(
boliu31c233ed2016-07-29 05:38:59117 const gfx::Size& viewport_size,
boliubee541f42015-11-05 00:52:53118 const gfx::Rect& viewport_rect_for_tile_priority,
119 const gfx::Transform& transform_for_tile_priority) {
boliu31c233ed2016-07-29 05:38:59120 SyncCompositorDemandDrawHwParams params(viewport_size,
121 viewport_rect_for_tile_priority,
boliubee541f42015-11-05 00:52:53122 transform_for_tile_priority);
danakj1120f4c2016-09-15 02:05:32123 uint32_t compositor_frame_sink_id;
samans96418732016-10-27 21:24:45124 base::Optional<cc::CompositorFrame> compositor_frame;
boliubee541f42015-11-05 00:52:53125 SyncCompositorCommonRendererParams common_renderer_params;
ojars53392992016-09-03 00:09:06126
boliubee541f42015-11-05 00:52:53127 if (!sender_->Send(new SyncCompositorMsg_DemandDrawHw(
danakj1120f4c2016-09-15 02:05:32128 routing_id_, params, &common_renderer_params,
129 &compositor_frame_sink_id, &compositor_frame))) {
boliuf4e574852016-03-22 19:33:17130 return SynchronousCompositor::Frame();
boliubee541f42015-11-05 00:52:53131 }
ojars53392992016-09-03 00:09:06132
boliubee541f42015-11-05 00:52:53133 ProcessCommonParams(common_renderer_params);
ojars53392992016-09-03 00:09:06134
samans96418732016-10-27 21:24:45135 if (!compositor_frame)
136 return SynchronousCompositor::Frame();
137
danakj1120f4c2016-09-15 02:05:32138 return ProcessHardwareFrame(compositor_frame_sink_id,
samans96418732016-10-27 21:24:45139 std::move(*compositor_frame));
ojars53392992016-09-03 00:09:06140}
141
ojars53392992016-09-03 00:09:06142SynchronousCompositor::Frame SynchronousCompositorHost::ProcessHardwareFrame(
danakj1120f4c2016-09-15 02:05:32143 uint32_t compositor_frame_sink_id,
ojars53392992016-09-03 00:09:06144 cc::CompositorFrame compositor_frame) {
145 SynchronousCompositor::Frame frame;
146 frame.frame.reset(new cc::CompositorFrame);
danakj1120f4c2016-09-15 02:05:32147 frame.compositor_frame_sink_id = compositor_frame_sink_id;
ojars53392992016-09-03 00:09:06148 *frame.frame = std::move(compositor_frame);
samans96418732016-10-27 21:24:45149 UpdateFrameMetaData(frame.frame->metadata.Clone());
boliubee541f42015-11-05 00:52:53150 return frame;
151}
152
153void SynchronousCompositorHost::UpdateFrameMetaData(
fsamueld63137a2016-06-24 23:39:51154 cc::CompositorFrameMetadata frame_metadata) {
155 rwhva_->SynchronousFrameMetadata(std::move(frame_metadata));
boliubee541f42015-11-05 00:52:53156}
157
boliu22557972016-10-25 16:08:29158SynchronousCompositorBrowserFilter* SynchronousCompositorHost::GetFilter() {
boliuc37cd75b2016-10-24 17:54:39159 return static_cast<RenderProcessHostImpl*>(
160 rwhva_->GetRenderWidgetHost()->GetProcess())
161 ->synchronous_compositor_filter();
162}
163
boliu4d4b5a82016-02-17 01:55:21164namespace {
165
166class ScopedSetSkCanvas {
167 public:
168 explicit ScopedSetSkCanvas(SkCanvas* canvas) {
169 SynchronousCompositorSetSkCanvas(canvas);
170 }
171
172 ~ScopedSetSkCanvas() {
173 SynchronousCompositorSetSkCanvas(nullptr);
174 }
175
176 private:
177 DISALLOW_COPY_AND_ASSIGN(ScopedSetSkCanvas);
178};
179
180}
181
182bool SynchronousCompositorHost::DemandDrawSwInProc(SkCanvas* canvas) {
boliu4d4b5a82016-02-17 01:55:21183 SyncCompositorCommonRendererParams common_renderer_params;
184 bool success = false;
dcheng59716272016-04-09 05:19:08185 std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
boliu4d4b5a82016-02-17 01:55:21186 ScopedSetSkCanvas set_sk_canvas(canvas);
187 SyncCompositorDemandDrawSwParams params; // Unused.
188 if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw(
boliu8f3016e2016-06-04 00:59:18189 routing_id_, params, &success, &common_renderer_params,
190 frame.get()))) {
boliu4d4b5a82016-02-17 01:55:21191 return false;
192 }
193 if (!success)
194 return false;
195 ProcessCommonParams(common_renderer_params);
fsamueld63137a2016-06-24 23:39:51196 UpdateFrameMetaData(std::move(frame->metadata));
boliu4d4b5a82016-02-17 01:55:21197 return true;
198}
199
boliucafb1bf2015-12-29 01:40:19200class SynchronousCompositorHost::ScopedSendZeroMemory {
201 public:
202 ScopedSendZeroMemory(SynchronousCompositorHost* host) : host_(host) {}
203 ~ScopedSendZeroMemory() { host_->SendZeroMemory(); }
204
205 private:
206 SynchronousCompositorHost* const host_;
207
208 DISALLOW_COPY_AND_ASSIGN(ScopedSendZeroMemory);
209};
210
211struct SynchronousCompositorHost::SharedMemoryWithSize {
212 base::SharedMemory shm;
213 const size_t stride;
214 const size_t buffer_size;
215
216 SharedMemoryWithSize(size_t stride, size_t buffer_size)
217 : stride(stride), buffer_size(buffer_size) {}
218
219 private:
220 DISALLOW_COPY_AND_ASSIGN(SharedMemoryWithSize);
221};
222
boliubee541f42015-11-05 00:52:53223bool SynchronousCompositorHost::DemandDrawSw(SkCanvas* canvas) {
boliu4d4b5a82016-02-17 01:55:21224 if (use_in_process_zero_copy_software_draw_)
225 return DemandDrawSwInProc(canvas);
226
boliuf6d263e2015-11-25 03:53:58227 SyncCompositorDemandDrawSwParams params;
228 params.size = gfx::Size(canvas->getBaseLayerSize().width(),
229 canvas->getBaseLayerSize().height());
230 SkIRect canvas_clip;
231 canvas->getClipDeviceBounds(&canvas_clip);
232 params.clip = gfx::SkIRectToRect(canvas_clip);
233 params.transform.matrix() = canvas->getTotalMatrix();
234 if (params.size.IsEmpty())
235 return true;
236
237 SkImageInfo info =
238 SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());
239 DCHECK_EQ(kRGBA_8888_SkColorType, info.colorType());
240 size_t stride = info.minRowBytes();
241 size_t buffer_size = info.getSafeSize(stride);
242 if (!buffer_size)
243 return false; // Overflow.
244
boliucafb1bf2015-12-29 01:40:19245 SetSoftwareDrawSharedMemoryIfNeeded(stride, buffer_size);
246 if (!software_draw_shm_)
boliuf6d263e2015-11-25 03:53:58247 return false;
248
dcheng59716272016-04-09 05:19:08249 std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
boliuf6d263e2015-11-25 03:53:58250 SyncCompositorCommonRendererParams common_renderer_params;
251 bool success = false;
252 if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw(
boliu8f3016e2016-06-04 00:59:18253 routing_id_, params, &success, &common_renderer_params,
254 frame.get()))) {
boliuf6d263e2015-11-25 03:53:58255 return false;
256 }
boliucafb1bf2015-12-29 01:40:19257 ScopedSendZeroMemory send_zero_memory(this);
boliuf6d263e2015-11-25 03:53:58258 if (!success)
259 return false;
260
261 ProcessCommonParams(common_renderer_params);
fsamueld63137a2016-06-24 23:39:51262 UpdateFrameMetaData(std::move(frame->metadata));
boliuf6d263e2015-11-25 03:53:58263
264 SkBitmap bitmap;
boliucafb1bf2015-12-29 01:40:19265 if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride))
boliuf6d263e2015-11-25 03:53:58266 return false;
267
268 {
269 TRACE_EVENT0("browser", "DrawBitmap");
270 canvas->save();
271 canvas->resetMatrix();
272 canvas->drawBitmap(bitmap, 0, 0);
273 canvas->restore();
274 }
275
276 return true;
boliubee541f42015-11-05 00:52:53277}
278
boliucafb1bf2015-12-29 01:40:19279void SynchronousCompositorHost::SetSoftwareDrawSharedMemoryIfNeeded(
280 size_t stride,
281 size_t buffer_size) {
282 if (software_draw_shm_ && software_draw_shm_->stride == stride &&
283 software_draw_shm_->buffer_size == buffer_size)
284 return;
285 software_draw_shm_.reset();
dcheng59716272016-04-09 05:19:08286 std::unique_ptr<SharedMemoryWithSize> software_draw_shm(
boliucafb1bf2015-12-29 01:40:19287 new SharedMemoryWithSize(stride, buffer_size));
288 {
289 TRACE_EVENT1("browser", "AllocateSharedMemory", "buffer_size", buffer_size);
290 if (!software_draw_shm->shm.CreateAndMapAnonymous(buffer_size))
291 return;
292 }
293
294 SyncCompositorSetSharedMemoryParams set_shm_params;
295 set_shm_params.buffer_size = buffer_size;
296 base::ProcessHandle renderer_process_handle =
297 rwhva_->GetRenderWidgetHost()->GetProcess()->GetHandle();
298 if (!software_draw_shm->shm.ShareToProcess(renderer_process_handle,
299 &set_shm_params.shm_handle)) {
300 return;
301 }
302
boliucafb1bf2015-12-29 01:40:19303 bool success = false;
304 SyncCompositorCommonRendererParams common_renderer_params;
305 if (!sender_->Send(new SyncCompositorMsg_SetSharedMemory(
boliu8f3016e2016-06-04 00:59:18306 routing_id_, set_shm_params, &success, &common_renderer_params)) ||
boliucafb1bf2015-12-29 01:40:19307 !success) {
308 return;
309 }
310 software_draw_shm_ = std::move(software_draw_shm);
311 ProcessCommonParams(common_renderer_params);
312}
313
314void SynchronousCompositorHost::SendZeroMemory() {
315 // No need to check return value.
316 sender_->Send(new SyncCompositorMsg_ZeroSharedMemory(routing_id_));
317}
318
boliubee541f42015-11-05 00:52:53319void SynchronousCompositorHost::ReturnResources(
danakj1120f4c2016-09-15 02:05:32320 uint32_t compositor_frame_sink_id,
fsamuelb62b78222016-07-15 01:14:14321 const cc::ReturnedResourceArray& resources) {
322 DCHECK(!resources.empty());
boliuec72a2ed2016-05-10 00:51:56323 sender_->Send(new SyncCompositorMsg_ReclaimResources(
danakj1120f4c2016-09-15 02:05:32324 routing_id_, compositor_frame_sink_id, resources));
boliubee541f42015-11-05 00:52:53325}
326
327void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) {
328 if (bytes_limit_ == bytes_limit)
329 return;
boliu42e01312016-05-12 21:47:52330
331 if (sender_->Send(
332 new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit))) {
333 bytes_limit_ = bytes_limit;
334 }
boliubee541f42015-11-05 00:52:53335}
336
337void SynchronousCompositorHost::DidChangeRootLayerScrollOffset(
338 const gfx::ScrollOffset& root_offset) {
339 if (root_scroll_offset_ == root_offset)
340 return;
341 root_scroll_offset_ = root_offset;
boliu22cdc6d2016-05-13 19:43:09342 sender_->Send(
343 new SyncCompositorMsg_SetScroll(routing_id_, root_scroll_offset_));
hush92bd35e72015-11-13 22:57:37344}
345
boliu21d8ab142016-04-07 23:33:52346void SynchronousCompositorHost::SynchronouslyZoomBy(float zoom_delta,
347 const gfx::Point& anchor) {
boliu21d8ab142016-04-07 23:33:52348 SyncCompositorCommonRendererParams common_renderer_params;
349 if (!sender_->Send(new SyncCompositorMsg_ZoomBy(
boliu8f3016e2016-06-04 00:59:18350 routing_id_, zoom_delta, anchor, &common_renderer_params))) {
boliu21d8ab142016-04-07 23:33:52351 return;
352 }
353 ProcessCommonParams(common_renderer_params);
354}
355
boliubee541f42015-11-05 00:52:53356void SynchronousCompositorHost::OnComputeScroll(
357 base::TimeTicks animation_time) {
358 if (!need_animate_scroll_)
359 return;
360 need_animate_scroll_ = false;
361
boliubee541f42015-11-05 00:52:53362 SyncCompositorCommonRendererParams common_renderer_params;
boliu8f3016e2016-06-04 00:59:18363 sender_->Send(
364 new SyncCompositorMsg_ComputeScroll(routing_id_, animation_time));
boliubee541f42015-11-05 00:52:53365}
366
boliude5b75b2016-03-11 07:02:14367void SynchronousCompositorHost::DidOverscroll(
chongza8ba91fc2016-08-16 21:39:17368 const ui::DidOverscrollParams& over_scroll_params) {
hush83e367c2016-06-18 02:37:54369 client_->DidOverscroll(this, over_scroll_params.accumulated_overscroll,
boliude5b75b2016-03-11 07:02:14370 over_scroll_params.latest_overscroll_delta,
371 over_scroll_params.current_fling_velocity);
372}
373
boliu3dd3ca72016-07-29 00:18:37374void SynchronousCompositorHost::DidSendBeginFrame(
375 ui::WindowAndroid* window_android) {
boliu22557972016-10-25 16:08:29376 if (SynchronousCompositorBrowserFilter* filter = GetFilter())
boliuc37cd75b2016-10-24 17:54:39377 filter->SyncStateAfterVSync(window_android, this);
boliubee541f42015-11-05 00:52:53378}
379
danakj1120f4c2016-09-15 02:05:32380void SynchronousCompositorHost::CompositorFrameSinkCreated() {
381 // New CompositorFrameSink is not aware of state from Browser side. So need to
boliu42e01312016-05-12 21:47:52382 // re-send all browser side state here.
383 sender_->Send(
384 new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit_));
385}
386
boliubee541f42015-11-05 00:52:53387void SynchronousCompositorHost::ProcessCommonParams(
388 const SyncCompositorCommonRendererParams& params) {
389 // Ignore if |renderer_param_version_| is newer than |params.version|. This
390 // comparison takes into account when the unsigned int wraps.
391 if ((renderer_param_version_ - params.version) < 0x80000000) {
392 return;
393 }
394 renderer_param_version_ = params.version;
395 need_animate_scroll_ = params.need_animate_scroll;
boliubee541f42015-11-05 00:52:53396 root_scroll_offset_ = params.total_scroll_offset;
397
boliu17bc31f2016-02-23 18:46:28398 if (need_invalidate_count_ != params.need_invalidate_count) {
399 need_invalidate_count_ = params.need_invalidate_count;
hush83e367c2016-06-18 02:37:54400 client_->PostInvalidate(this);
boliubee541f42015-11-05 00:52:53401 }
402
boliu17bc31f2016-02-23 18:46:28403 if (did_activate_pending_tree_count_ !=
404 params.did_activate_pending_tree_count) {
405 did_activate_pending_tree_count_ = params.did_activate_pending_tree_count;
hush83e367c2016-06-18 02:37:54406 client_->DidUpdateContent(this);
boliubee541f42015-11-05 00:52:53407 }
408
409 // Ensure only valid values from compositor are sent to client.
410 // Compositor has page_scale_factor set to 0 before initialization, so check
411 // for that case here.
412 if (params.page_scale_factor) {
413 client_->UpdateRootLayerState(
hush83e367c2016-06-18 02:37:54414 this, gfx::ScrollOffsetToVector2dF(params.total_scroll_offset),
boliubee541f42015-11-05 00:52:53415 gfx::ScrollOffsetToVector2dF(params.max_scroll_offset),
416 params.scrollable_size, params.page_scale_factor,
417 params.min_page_scale_factor, params.max_page_scale_factor);
418 }
419}
420
boliubee541f42015-11-05 00:52:53421} // namespace content