boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 1 | // 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 | |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 7 | #include <utility> |
| 8 | |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 9 | #include "base/command_line.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 10 | #include "base/containers/hash_tables.h" |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 11 | #include "base/memory/ptr_util.h" |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 12 | #include "base/memory/shared_memory.h" |
| 13 | #include "base/trace_event/trace_event_argument.h" |
boliu | 2255797 | 2016-10-25 16:08:29 | [diff] [blame] | 14 | #include "content/browser/android/synchronous_compositor_browser_filter.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 15 | #include "content/browser/renderer_host/render_widget_host_view_android.h" |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 16 | #include "content/browser/web_contents/web_contents_android.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 17 | #include "content/browser/web_contents/web_contents_impl.h" |
| 18 | #include "content/common/android/sync_compositor_messages.h" |
jbroman | 801dd27 | 2016-04-22 18:54:02 | [diff] [blame] | 19 | #include "content/common/android/sync_compositor_statics.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 20 | #include "content/public/browser/android/synchronous_compositor_client.h" |
hush | 92bd35e7 | 2015-11-13 22:57:37 | [diff] [blame] | 21 | #include "content/public/browser/browser_thread.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 22 | #include "content/public/browser/render_view_host.h" |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 23 | #include "content/public/common/content_switches.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 24 | #include "ipc/ipc_sender.h" |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 25 | #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" |
chongz | a8ba91fc | 2016-08-16 21:39:17 | [diff] [blame] | 29 | #include "ui/events/blink/did_overscroll_params.h" |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 30 | #include "ui/gfx/skia_util.h" |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 31 | |
| 32 | namespace content { |
| 33 | |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 34 | // static |
| 35 | void 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 |
| 47 | std::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(); |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 57 | bool use_in_proc_software_draw = |
| 58 | command_line->HasSwitch(switches::kSingleProcess); |
| 59 | return base::WrapUnique(new SynchronousCompositorHost( |
boliu | b2768db | 2016-06-03 23:35:16 | [diff] [blame] | 60 | rwhva, web_contents_android->synchronous_compositor_client(), |
boliu | c99f26c1 | 2016-04-21 21:58:59 | [diff] [blame] | 61 | use_in_proc_software_draw)); |
| 62 | } |
| 63 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 64 | SynchronousCompositorHost::SynchronousCompositorHost( |
| 65 | RenderWidgetHostViewAndroid* rwhva, |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 66 | SynchronousCompositorClient* client, |
| 67 | bool use_in_proc_software_draw) |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 68 | : rwhva_(rwhva), |
| 69 | client_(client), |
thestig | 529ad8a | 2016-07-08 20:30:12 | [diff] [blame] | 70 | ui_task_runner_(BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)), |
hush | 284add6 | 2016-06-17 20:47:33 | [diff] [blame] | 71 | process_id_(rwhva_->GetRenderWidgetHost()->GetProcess()->GetID()), |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 72 | routing_id_(rwhva_->GetRenderWidgetHost()->GetRoutingID()), |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 73 | sender_(rwhva_->GetRenderWidgetHost()), |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 74 | use_in_process_zero_copy_software_draw_(use_in_proc_software_draw), |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 75 | bytes_limit_(0u), |
| 76 | renderer_param_version_(0u), |
| 77 | need_animate_scroll_(false), |
boliu | 17bc31f | 2016-02-23 18:46:28 | [diff] [blame] | 78 | need_invalidate_count_(0u), |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 79 | did_activate_pending_tree_count_(0u) { |
hush | 284add6 | 2016-06-17 20:47:33 | [diff] [blame] | 80 | client_->DidInitializeCompositor(this, process_id_, routing_id_); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | SynchronousCompositorHost::~SynchronousCompositorHost() { |
hush | 284add6 | 2016-06-17 20:47:33 | [diff] [blame] | 84 | client_->DidDestroyCompositor(this, process_id_, routing_id_); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 85 | } |
| 86 | |
| 87 | bool SynchronousCompositorHost::OnMessageReceived(const IPC::Message& message) { |
| 88 | bool handled = true; |
| 89 | IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorHost, message) |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 90 | IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_CompositorFrameSinkCreated, |
| 91 | CompositorFrameSinkCreated) |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 92 | IPC_MESSAGE_HANDLER(SyncCompositorHostMsg_UpdateState, ProcessCommonParams) |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 93 | IPC_MESSAGE_UNHANDLED(handled = false) |
| 94 | IPC_END_MESSAGE_MAP() |
| 95 | return handled; |
| 96 | } |
| 97 | |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 98 | scoped_refptr<SynchronousCompositor::FrameFuture> |
| 99 | SynchronousCompositorHost::DemandDrawHwAsync( |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 100 | 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); |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 106 | scoped_refptr<FrameFuture> frame_future = new FrameFuture(); |
boliu | 2255797 | 2016-10-25 16:08:29 | [diff] [blame] | 107 | if (SynchronousCompositorBrowserFilter* filter = GetFilter()) { |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 108 | filter->SetFrameFuture(routing_id_, frame_future); |
| 109 | sender_->Send(new SyncCompositorMsg_DemandDrawHwAsync(routing_id_, params)); |
| 110 | } else { |
boliu | f26c9e0f | 2016-10-27 16:29:08 | [diff] [blame] | 111 | frame_future->SetFrame(nullptr); |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 112 | } |
| 113 | return frame_future; |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 114 | } |
| 115 | |
boliu | f4e57485 | 2016-03-22 19:33:17 | [diff] [blame] | 116 | SynchronousCompositor::Frame SynchronousCompositorHost::DemandDrawHw( |
boliu | 31c233ed | 2016-07-29 05:38:59 | [diff] [blame] | 117 | const gfx::Size& viewport_size, |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 118 | const gfx::Rect& viewport_rect_for_tile_priority, |
| 119 | const gfx::Transform& transform_for_tile_priority) { |
boliu | 31c233ed | 2016-07-29 05:38:59 | [diff] [blame] | 120 | SyncCompositorDemandDrawHwParams params(viewport_size, |
| 121 | viewport_rect_for_tile_priority, |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 122 | transform_for_tile_priority); |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 123 | uint32_t compositor_frame_sink_id; |
samans | 9641873 | 2016-10-27 21:24:45 | [diff] [blame^] | 124 | base::Optional<cc::CompositorFrame> compositor_frame; |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 125 | SyncCompositorCommonRendererParams common_renderer_params; |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 126 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 127 | if (!sender_->Send(new SyncCompositorMsg_DemandDrawHw( |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 128 | routing_id_, params, &common_renderer_params, |
| 129 | &compositor_frame_sink_id, &compositor_frame))) { |
boliu | f4e57485 | 2016-03-22 19:33:17 | [diff] [blame] | 130 | return SynchronousCompositor::Frame(); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 131 | } |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 132 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 133 | ProcessCommonParams(common_renderer_params); |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 134 | |
samans | 9641873 | 2016-10-27 21:24:45 | [diff] [blame^] | 135 | if (!compositor_frame) |
| 136 | return SynchronousCompositor::Frame(); |
| 137 | |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 138 | return ProcessHardwareFrame(compositor_frame_sink_id, |
samans | 9641873 | 2016-10-27 21:24:45 | [diff] [blame^] | 139 | std::move(*compositor_frame)); |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 140 | } |
| 141 | |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 142 | SynchronousCompositor::Frame SynchronousCompositorHost::ProcessHardwareFrame( |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 143 | uint32_t compositor_frame_sink_id, |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 144 | cc::CompositorFrame compositor_frame) { |
| 145 | SynchronousCompositor::Frame frame; |
| 146 | frame.frame.reset(new cc::CompositorFrame); |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 147 | frame.compositor_frame_sink_id = compositor_frame_sink_id; |
ojars | 5339299 | 2016-09-03 00:09:06 | [diff] [blame] | 148 | *frame.frame = std::move(compositor_frame); |
samans | 9641873 | 2016-10-27 21:24:45 | [diff] [blame^] | 149 | UpdateFrameMetaData(frame.frame->metadata.Clone()); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 150 | return frame; |
| 151 | } |
| 152 | |
| 153 | void SynchronousCompositorHost::UpdateFrameMetaData( |
fsamuel | d63137a | 2016-06-24 23:39:51 | [diff] [blame] | 154 | cc::CompositorFrameMetadata frame_metadata) { |
| 155 | rwhva_->SynchronousFrameMetadata(std::move(frame_metadata)); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 156 | } |
| 157 | |
boliu | 2255797 | 2016-10-25 16:08:29 | [diff] [blame] | 158 | SynchronousCompositorBrowserFilter* SynchronousCompositorHost::GetFilter() { |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 159 | return static_cast<RenderProcessHostImpl*>( |
| 160 | rwhva_->GetRenderWidgetHost()->GetProcess()) |
| 161 | ->synchronous_compositor_filter(); |
| 162 | } |
| 163 | |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 164 | namespace { |
| 165 | |
| 166 | class 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 | |
| 182 | bool SynchronousCompositorHost::DemandDrawSwInProc(SkCanvas* canvas) { |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 183 | SyncCompositorCommonRendererParams common_renderer_params; |
| 184 | bool success = false; |
dcheng | 5971627 | 2016-04-09 05:19:08 | [diff] [blame] | 185 | std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame); |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 186 | ScopedSetSkCanvas set_sk_canvas(canvas); |
| 187 | SyncCompositorDemandDrawSwParams params; // Unused. |
| 188 | if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw( |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 189 | routing_id_, params, &success, &common_renderer_params, |
| 190 | frame.get()))) { |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 191 | return false; |
| 192 | } |
| 193 | if (!success) |
| 194 | return false; |
| 195 | ProcessCommonParams(common_renderer_params); |
fsamuel | d63137a | 2016-06-24 23:39:51 | [diff] [blame] | 196 | UpdateFrameMetaData(std::move(frame->metadata)); |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 197 | return true; |
| 198 | } |
| 199 | |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 200 | class 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 | |
| 211 | struct 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 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 223 | bool SynchronousCompositorHost::DemandDrawSw(SkCanvas* canvas) { |
boliu | 4d4b5a8 | 2016-02-17 01:55:21 | [diff] [blame] | 224 | if (use_in_process_zero_copy_software_draw_) |
| 225 | return DemandDrawSwInProc(canvas); |
| 226 | |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 227 | 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 | |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 245 | SetSoftwareDrawSharedMemoryIfNeeded(stride, buffer_size); |
| 246 | if (!software_draw_shm_) |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 247 | return false; |
| 248 | |
dcheng | 5971627 | 2016-04-09 05:19:08 | [diff] [blame] | 249 | std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame); |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 250 | SyncCompositorCommonRendererParams common_renderer_params; |
| 251 | bool success = false; |
| 252 | if (!sender_->Send(new SyncCompositorMsg_DemandDrawSw( |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 253 | routing_id_, params, &success, &common_renderer_params, |
| 254 | frame.get()))) { |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 255 | return false; |
| 256 | } |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 257 | ScopedSendZeroMemory send_zero_memory(this); |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 258 | if (!success) |
| 259 | return false; |
| 260 | |
| 261 | ProcessCommonParams(common_renderer_params); |
fsamuel | d63137a | 2016-06-24 23:39:51 | [diff] [blame] | 262 | UpdateFrameMetaData(std::move(frame->metadata)); |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 263 | |
| 264 | SkBitmap bitmap; |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 265 | if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride)) |
boliu | f6d263e | 2015-11-25 03:53:58 | [diff] [blame] | 266 | 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; |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 277 | } |
| 278 | |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 279 | void 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(); |
dcheng | 5971627 | 2016-04-09 05:19:08 | [diff] [blame] | 286 | std::unique_ptr<SharedMemoryWithSize> software_draw_shm( |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 287 | 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 | |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 303 | bool success = false; |
| 304 | SyncCompositorCommonRendererParams common_renderer_params; |
| 305 | if (!sender_->Send(new SyncCompositorMsg_SetSharedMemory( |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 306 | routing_id_, set_shm_params, &success, &common_renderer_params)) || |
boliu | cafb1bf | 2015-12-29 01:40:19 | [diff] [blame] | 307 | !success) { |
| 308 | return; |
| 309 | } |
| 310 | software_draw_shm_ = std::move(software_draw_shm); |
| 311 | ProcessCommonParams(common_renderer_params); |
| 312 | } |
| 313 | |
| 314 | void SynchronousCompositorHost::SendZeroMemory() { |
| 315 | // No need to check return value. |
| 316 | sender_->Send(new SyncCompositorMsg_ZeroSharedMemory(routing_id_)); |
| 317 | } |
| 318 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 319 | void SynchronousCompositorHost::ReturnResources( |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 320 | uint32_t compositor_frame_sink_id, |
fsamuel | b62b7822 | 2016-07-15 01:14:14 | [diff] [blame] | 321 | const cc::ReturnedResourceArray& resources) { |
| 322 | DCHECK(!resources.empty()); |
boliu | ec72a2ed | 2016-05-10 00:51:56 | [diff] [blame] | 323 | sender_->Send(new SyncCompositorMsg_ReclaimResources( |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 324 | routing_id_, compositor_frame_sink_id, resources)); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 325 | } |
| 326 | |
| 327 | void SynchronousCompositorHost::SetMemoryPolicy(size_t bytes_limit) { |
| 328 | if (bytes_limit_ == bytes_limit) |
| 329 | return; |
boliu | 42e0131 | 2016-05-12 21:47:52 | [diff] [blame] | 330 | |
| 331 | if (sender_->Send( |
| 332 | new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit))) { |
| 333 | bytes_limit_ = bytes_limit; |
| 334 | } |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 335 | } |
| 336 | |
| 337 | void SynchronousCompositorHost::DidChangeRootLayerScrollOffset( |
| 338 | const gfx::ScrollOffset& root_offset) { |
| 339 | if (root_scroll_offset_ == root_offset) |
| 340 | return; |
| 341 | root_scroll_offset_ = root_offset; |
boliu | 22cdc6d | 2016-05-13 19:43:09 | [diff] [blame] | 342 | sender_->Send( |
| 343 | new SyncCompositorMsg_SetScroll(routing_id_, root_scroll_offset_)); |
hush | 92bd35e7 | 2015-11-13 22:57:37 | [diff] [blame] | 344 | } |
| 345 | |
boliu | 21d8ab14 | 2016-04-07 23:33:52 | [diff] [blame] | 346 | void SynchronousCompositorHost::SynchronouslyZoomBy(float zoom_delta, |
| 347 | const gfx::Point& anchor) { |
boliu | 21d8ab14 | 2016-04-07 23:33:52 | [diff] [blame] | 348 | SyncCompositorCommonRendererParams common_renderer_params; |
| 349 | if (!sender_->Send(new SyncCompositorMsg_ZoomBy( |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 350 | routing_id_, zoom_delta, anchor, &common_renderer_params))) { |
boliu | 21d8ab14 | 2016-04-07 23:33:52 | [diff] [blame] | 351 | return; |
| 352 | } |
| 353 | ProcessCommonParams(common_renderer_params); |
| 354 | } |
| 355 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 356 | void SynchronousCompositorHost::OnComputeScroll( |
| 357 | base::TimeTicks animation_time) { |
| 358 | if (!need_animate_scroll_) |
| 359 | return; |
| 360 | need_animate_scroll_ = false; |
| 361 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 362 | SyncCompositorCommonRendererParams common_renderer_params; |
boliu | 8f3016e | 2016-06-04 00:59:18 | [diff] [blame] | 363 | sender_->Send( |
| 364 | new SyncCompositorMsg_ComputeScroll(routing_id_, animation_time)); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 365 | } |
| 366 | |
boliu | de5b75b | 2016-03-11 07:02:14 | [diff] [blame] | 367 | void SynchronousCompositorHost::DidOverscroll( |
chongz | a8ba91fc | 2016-08-16 21:39:17 | [diff] [blame] | 368 | const ui::DidOverscrollParams& over_scroll_params) { |
hush | 83e367c | 2016-06-18 02:37:54 | [diff] [blame] | 369 | client_->DidOverscroll(this, over_scroll_params.accumulated_overscroll, |
boliu | de5b75b | 2016-03-11 07:02:14 | [diff] [blame] | 370 | over_scroll_params.latest_overscroll_delta, |
| 371 | over_scroll_params.current_fling_velocity); |
| 372 | } |
| 373 | |
boliu | 3dd3ca7 | 2016-07-29 00:18:37 | [diff] [blame] | 374 | void SynchronousCompositorHost::DidSendBeginFrame( |
| 375 | ui::WindowAndroid* window_android) { |
boliu | 2255797 | 2016-10-25 16:08:29 | [diff] [blame] | 376 | if (SynchronousCompositorBrowserFilter* filter = GetFilter()) |
boliu | c37cd75b | 2016-10-24 17:54:39 | [diff] [blame] | 377 | filter->SyncStateAfterVSync(window_android, this); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 378 | } |
| 379 | |
danakj | 1120f4c | 2016-09-15 02:05:32 | [diff] [blame] | 380 | void SynchronousCompositorHost::CompositorFrameSinkCreated() { |
| 381 | // New CompositorFrameSink is not aware of state from Browser side. So need to |
boliu | 42e0131 | 2016-05-12 21:47:52 | [diff] [blame] | 382 | // re-send all browser side state here. |
| 383 | sender_->Send( |
| 384 | new SyncCompositorMsg_SetMemoryPolicy(routing_id_, bytes_limit_)); |
| 385 | } |
| 386 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 387 | void 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; |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 396 | root_scroll_offset_ = params.total_scroll_offset; |
| 397 | |
boliu | 17bc31f | 2016-02-23 18:46:28 | [diff] [blame] | 398 | if (need_invalidate_count_ != params.need_invalidate_count) { |
| 399 | need_invalidate_count_ = params.need_invalidate_count; |
hush | 83e367c | 2016-06-18 02:37:54 | [diff] [blame] | 400 | client_->PostInvalidate(this); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 401 | } |
| 402 | |
boliu | 17bc31f | 2016-02-23 18:46:28 | [diff] [blame] | 403 | 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; |
hush | 83e367c | 2016-06-18 02:37:54 | [diff] [blame] | 406 | client_->DidUpdateContent(this); |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 407 | } |
| 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( |
hush | 83e367c | 2016-06-18 02:37:54 | [diff] [blame] | 414 | this, gfx::ScrollOffsetToVector2dF(params.total_scroll_offset), |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 415 | 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 | |
boliu | bee541f4 | 2015-11-05 00:52:53 | [diff] [blame] | 421 | } // namespace content |