OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/android/synchronous_compositor_proxy.h" | 5 #include "content/renderer/android/synchronous_compositor_proxy.h" |
6 | 6 |
7 #include "base/auto_reset.h" | 7 #include "base/auto_reset.h" |
8 #include "base/command_line.h" | 8 #include "base/command_line.h" |
9 #include "base/memory/shared_memory.h" | 9 #include "base/memory/shared_memory.h" |
10 #include "cc/ipc/cc_param_traits.h" | 10 #include "cc/ipc/cc_param_traits.h" |
(...skipping 13 matching lines...) Expand all Loading... |
24 SynchronousCompositorProxy::SynchronousCompositorProxy( | 24 SynchronousCompositorProxy::SynchronousCompositorProxy( |
25 int routing_id, | 25 int routing_id, |
26 IPC::Sender* sender, | 26 IPC::Sender* sender, |
27 ui::SynchronousInputHandlerProxy* input_handler_proxy) | 27 ui::SynchronousInputHandlerProxy* input_handler_proxy) |
28 : routing_id_(routing_id), | 28 : routing_id_(routing_id), |
29 sender_(sender), | 29 sender_(sender), |
30 input_handler_proxy_(input_handler_proxy), | 30 input_handler_proxy_(input_handler_proxy), |
31 use_in_process_zero_copy_software_draw_( | 31 use_in_process_zero_copy_software_draw_( |
32 base::CommandLine::ForCurrentProcess()->HasSwitch( | 32 base::CommandLine::ForCurrentProcess()->HasSwitch( |
33 switches::kSingleProcess)), | 33 switches::kSingleProcess)), |
34 output_surface_(nullptr), | 34 compositor_frame_sink_(nullptr), |
35 inside_receive_(false), | 35 inside_receive_(false), |
36 hardware_draw_reply_(nullptr), | 36 hardware_draw_reply_(nullptr), |
37 software_draw_reply_(nullptr), | 37 software_draw_reply_(nullptr), |
38 hardware_draw_reply_async_(false), | 38 hardware_draw_reply_async_(false), |
39 version_(0u), | 39 version_(0u), |
40 page_scale_factor_(0.f), | 40 page_scale_factor_(0.f), |
41 min_page_scale_factor_(0.f), | 41 min_page_scale_factor_(0.f), |
42 max_page_scale_factor_(0.f), | 42 max_page_scale_factor_(0.f), |
43 need_animate_scroll_(false), | 43 need_animate_scroll_(false), |
44 need_invalidate_count_(0u), | 44 need_invalidate_count_(0u), |
45 did_activate_pending_tree_count_(0u) { | 45 did_activate_pending_tree_count_(0u) { |
46 DCHECK(input_handler_proxy_); | 46 DCHECK(input_handler_proxy_); |
47 input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(this); | 47 input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(this); |
48 } | 48 } |
49 | 49 |
50 SynchronousCompositorProxy::~SynchronousCompositorProxy() { | 50 SynchronousCompositorProxy::~SynchronousCompositorProxy() { |
51 // The OutputSurface is destroyed/removed by the compositor before shutting | 51 // The CompositorFrameSink is destroyed/removed by the compositor before |
52 // down everything. | 52 // shutting down everything. |
53 DCHECK_EQ(output_surface_, nullptr); | 53 DCHECK_EQ(compositor_frame_sink_, nullptr); |
54 input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(nullptr); | 54 input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(nullptr); |
55 } | 55 } |
56 | 56 |
57 void SynchronousCompositorProxy::SetOutputSurface( | 57 void SynchronousCompositorProxy::SetCompositorFrameSink( |
58 SynchronousCompositorOutputSurface* output_surface) { | 58 SynchronousCompositorFrameSink* compositor_frame_sink) { |
59 DCHECK_NE(output_surface_, output_surface); | 59 DCHECK_NE(compositor_frame_sink_, compositor_frame_sink); |
60 if (output_surface_) { | 60 if (compositor_frame_sink_) { |
61 output_surface_->SetSyncClient(nullptr); | 61 compositor_frame_sink_->SetSyncClient(nullptr); |
62 } | 62 } |
63 output_surface_ = output_surface; | 63 compositor_frame_sink_ = compositor_frame_sink; |
64 if (output_surface_) { | 64 if (compositor_frame_sink_) { |
65 output_surface_->SetSyncClient(this); | 65 compositor_frame_sink_->SetSyncClient(this); |
66 } | 66 } |
67 } | 67 } |
68 | 68 |
69 void SynchronousCompositorProxy::SetNeedsSynchronousAnimateInput() { | 69 void SynchronousCompositorProxy::SetNeedsSynchronousAnimateInput() { |
70 need_animate_scroll_ = true; | 70 need_animate_scroll_ = true; |
71 Invalidate(); | 71 Invalidate(); |
72 } | 72 } |
73 | 73 |
74 void SynchronousCompositorProxy::UpdateRootLayerState( | 74 void SynchronousCompositorProxy::UpdateRootLayerState( |
75 const gfx::ScrollOffset& total_scroll_offset, | 75 const gfx::ScrollOffset& total_scroll_offset, |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
122 params->page_scale_factor = page_scale_factor_; | 122 params->page_scale_factor = page_scale_factor_; |
123 params->min_page_scale_factor = min_page_scale_factor_; | 123 params->min_page_scale_factor = min_page_scale_factor_; |
124 params->max_page_scale_factor = max_page_scale_factor_; | 124 params->max_page_scale_factor = max_page_scale_factor_; |
125 params->need_animate_scroll = need_animate_scroll_; | 125 params->need_animate_scroll = need_animate_scroll_; |
126 params->need_invalidate_count = need_invalidate_count_; | 126 params->need_invalidate_count = need_invalidate_count_; |
127 params->did_activate_pending_tree_count = did_activate_pending_tree_count_; | 127 params->did_activate_pending_tree_count = did_activate_pending_tree_count_; |
128 } | 128 } |
129 | 129 |
130 void SynchronousCompositorProxy::OnMessageReceived( | 130 void SynchronousCompositorProxy::OnMessageReceived( |
131 const IPC::Message& message) { | 131 const IPC::Message& message) { |
132 if (output_surface_ && output_surface_->OnMessageReceived(message)) | 132 if (compositor_frame_sink_ && |
| 133 compositor_frame_sink_->OnMessageReceived(message)) |
133 return; | 134 return; |
134 | 135 |
135 IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorProxy, message) | 136 IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorProxy, message) |
136 IPC_MESSAGE_HANDLER(SyncCompositorMsg_ComputeScroll, OnComputeScroll) | 137 IPC_MESSAGE_HANDLER(SyncCompositorMsg_ComputeScroll, OnComputeScroll) |
137 IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawHw, | 138 IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawHw, |
138 DemandDrawHw) | 139 DemandDrawHw) |
139 IPC_MESSAGE_HANDLER(SyncCompositorMsg_DemandDrawHwAsync, DemandDrawHwAsync) | 140 IPC_MESSAGE_HANDLER(SyncCompositorMsg_DemandDrawHwAsync, DemandDrawHwAsync) |
140 IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetSharedMemory, SetSharedMemory) | 141 IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetSharedMemory, SetSharedMemory) |
141 IPC_MESSAGE_HANDLER(SyncCompositorMsg_ZeroSharedMemory, ZeroSharedMemory) | 142 IPC_MESSAGE_HANDLER(SyncCompositorMsg_ZeroSharedMemory, ZeroSharedMemory) |
142 IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawSw, | 143 IPC_MESSAGE_HANDLER_DELAY_REPLY(SyncCompositorMsg_DemandDrawSw, |
(...skipping 18 matching lines...) Expand all Loading... |
161 DCHECK(reply_message); | 162 DCHECK(reply_message); |
162 DoDemandDrawHw(params, reply_message); | 163 DoDemandDrawHw(params, reply_message); |
163 } | 164 } |
164 | 165 |
165 void SynchronousCompositorProxy::DoDemandDrawHw( | 166 void SynchronousCompositorProxy::DoDemandDrawHw( |
166 const SyncCompositorDemandDrawHwParams& params, | 167 const SyncCompositorDemandDrawHwParams& params, |
167 IPC::Message* reply_message) { | 168 IPC::Message* reply_message) { |
168 DCHECK(!inside_receive_); | 169 DCHECK(!inside_receive_); |
169 inside_receive_ = true; | 170 inside_receive_ = true; |
170 | 171 |
171 if (output_surface_) { | 172 if (compositor_frame_sink_) { |
172 if (!reply_message) { | 173 if (!reply_message) { |
173 base::AutoReset<bool> scoped_hardware_draw_reply_async( | 174 base::AutoReset<bool> scoped_hardware_draw_reply_async( |
174 &hardware_draw_reply_async_, true); | 175 &hardware_draw_reply_async_, true); |
175 output_surface_->DemandDrawHw(params.viewport_size, | 176 compositor_frame_sink_->DemandDrawHw( |
176 params.viewport_rect_for_tile_priority, | 177 params.viewport_size, params.viewport_rect_for_tile_priority, |
177 params.transform_for_tile_priority); | 178 params.transform_for_tile_priority); |
178 } else { | 179 } else { |
179 base::AutoReset<IPC::Message*> scoped_hardware_draw_reply( | 180 base::AutoReset<IPC::Message*> scoped_hardware_draw_reply( |
180 &hardware_draw_reply_, reply_message); | 181 &hardware_draw_reply_, reply_message); |
181 output_surface_->DemandDrawHw(params.viewport_size, | 182 compositor_frame_sink_->DemandDrawHw( |
182 params.viewport_rect_for_tile_priority, | 183 params.viewport_size, params.viewport_rect_for_tile_priority, |
183 params.transform_for_tile_priority); | 184 params.transform_for_tile_priority); |
184 } | 185 } |
185 } | 186 } |
186 | 187 |
187 if (inside_receive_) { | 188 if (inside_receive_) { |
188 // Did not swap. | 189 // Did not swap. |
189 if (!reply_message) { | 190 if (!reply_message) { |
190 SendDemandDrawHwReplyAsync(cc::CompositorFrame(), 0u); | 191 SendDemandDrawHwReplyAsync(cc::CompositorFrame(), 0u); |
191 } else { | 192 } else { |
192 SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message); | 193 SendDemandDrawHwReply(cc::CompositorFrame(), 0u, reply_message); |
193 } | 194 } |
194 inside_receive_ = false; | 195 inside_receive_ = false; |
195 } | 196 } |
196 } | 197 } |
197 | 198 |
198 void SynchronousCompositorProxy::SwapBuffersHwAsync(uint32_t output_surface_id, | 199 void SynchronousCompositorProxy::SwapBuffersHwAsync( |
199 cc::CompositorFrame frame) { | 200 uint32_t compositor_frame_sink_id, |
| 201 cc::CompositorFrame frame) { |
200 DCHECK(inside_receive_); | 202 DCHECK(inside_receive_); |
201 DCHECK(hardware_draw_reply_async_); | 203 DCHECK(hardware_draw_reply_async_); |
202 SendDemandDrawHwReplyAsync(std::move(frame), output_surface_id); | 204 SendDemandDrawHwReplyAsync(std::move(frame), compositor_frame_sink_id); |
203 inside_receive_ = false; | 205 inside_receive_ = false; |
204 } | 206 } |
205 | 207 |
206 void SynchronousCompositorProxy::SwapBuffersHw(uint32_t output_surface_id, | 208 void SynchronousCompositorProxy::SwapBuffersHw( |
207 cc::CompositorFrame frame) { | 209 uint32_t compositor_frame_sink_id, |
| 210 cc::CompositorFrame frame) { |
208 DCHECK(inside_receive_); | 211 DCHECK(inside_receive_); |
209 DCHECK(hardware_draw_reply_); | 212 DCHECK(hardware_draw_reply_); |
210 SendDemandDrawHwReply(std::move(frame), output_surface_id, | 213 SendDemandDrawHwReply(std::move(frame), compositor_frame_sink_id, |
211 hardware_draw_reply_); | 214 hardware_draw_reply_); |
212 inside_receive_ = false; | 215 inside_receive_ = false; |
213 } | 216 } |
214 | 217 |
215 void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync( | 218 void SynchronousCompositorProxy::SendDemandDrawHwReplyAsync( |
216 cc::CompositorFrame frame, | 219 cc::CompositorFrame frame, |
217 uint32_t output_surface_id) { | 220 uint32_t compositor_frame_sink_id) { |
218 Send(new SyncCompositorHostMsg_ReturnFrame(routing_id_, output_surface_id, | 221 Send(new SyncCompositorHostMsg_ReturnFrame(routing_id_, |
219 frame)); | 222 compositor_frame_sink_id, frame)); |
220 } | 223 } |
221 | 224 |
222 void SynchronousCompositorProxy::SendDemandDrawHwReply( | 225 void SynchronousCompositorProxy::SendDemandDrawHwReply( |
223 cc::CompositorFrame frame, | 226 cc::CompositorFrame frame, |
224 uint32_t output_surface_id, | 227 uint32_t compositor_frame_sink_id, |
225 IPC::Message* reply_message) { | 228 IPC::Message* reply_message) { |
226 SyncCompositorCommonRendererParams common_renderer_params; | 229 SyncCompositorCommonRendererParams common_renderer_params; |
227 PopulateCommonParams(&common_renderer_params); | 230 PopulateCommonParams(&common_renderer_params); |
228 SyncCompositorMsg_DemandDrawHw::WriteReplyParams( | 231 SyncCompositorMsg_DemandDrawHw::WriteReplyParams( |
229 reply_message, common_renderer_params, output_surface_id, frame); | 232 reply_message, common_renderer_params, compositor_frame_sink_id, frame); |
230 Send(reply_message); | 233 Send(reply_message); |
231 } | 234 } |
232 | 235 |
233 struct SynchronousCompositorProxy::SharedMemoryWithSize { | 236 struct SynchronousCompositorProxy::SharedMemoryWithSize { |
234 base::SharedMemory shm; | 237 base::SharedMemory shm; |
235 const size_t buffer_size; | 238 const size_t buffer_size; |
236 bool zeroed; | 239 bool zeroed; |
237 | 240 |
238 SharedMemoryWithSize(base::SharedMemoryHandle shm_handle, size_t buffer_size) | 241 SharedMemoryWithSize(base::SharedMemoryHandle shm_handle, size_t buffer_size) |
239 : shm(shm_handle, false), buffer_size(buffer_size), zeroed(true) {} | 242 : shm(shm_handle, false), buffer_size(buffer_size), zeroed(true) {} |
(...skipping 14 matching lines...) Expand all Loading... |
254 new SharedMemoryWithSize(params.shm_handle, params.buffer_size)); | 257 new SharedMemoryWithSize(params.shm_handle, params.buffer_size)); |
255 if (!software_draw_shm_->shm.Map(params.buffer_size)) | 258 if (!software_draw_shm_->shm.Map(params.buffer_size)) |
256 return; | 259 return; |
257 DCHECK(software_draw_shm_->shm.memory()); | 260 DCHECK(software_draw_shm_->shm.memory()); |
258 PopulateCommonParams(common_renderer_params); | 261 PopulateCommonParams(common_renderer_params); |
259 *success = true; | 262 *success = true; |
260 } | 263 } |
261 | 264 |
262 void SynchronousCompositorProxy::ZeroSharedMemory() { | 265 void SynchronousCompositorProxy::ZeroSharedMemory() { |
263 // It is possible for this to get called twice, eg. if draw is called before | 266 // It is possible for this to get called twice, eg. if draw is called before |
264 // the OutputSurface is ready. Just ignore duplicated calls rather than | 267 // the CompositorFrameSink is ready. Just ignore duplicated calls rather than |
265 // inventing a complicated system to avoid it. | 268 // inventing a complicated system to avoid it. |
266 if (software_draw_shm_->zeroed) | 269 if (software_draw_shm_->zeroed) |
267 return; | 270 return; |
268 | 271 |
269 memset(software_draw_shm_->shm.memory(), 0, software_draw_shm_->buffer_size); | 272 memset(software_draw_shm_->shm.memory(), 0, software_draw_shm_->buffer_size); |
270 software_draw_shm_->zeroed = true; | 273 software_draw_shm_->zeroed = true; |
271 } | 274 } |
272 | 275 |
273 void SynchronousCompositorProxy::DemandDrawSw( | 276 void SynchronousCompositorProxy::DemandDrawSw( |
274 const SyncCompositorDemandDrawSwParams& params, | 277 const SyncCompositorDemandDrawSwParams& params, |
275 IPC::Message* reply_message) { | 278 IPC::Message* reply_message) { |
276 DCHECK(!inside_receive_); | 279 DCHECK(!inside_receive_); |
277 inside_receive_ = true; | 280 inside_receive_ = true; |
278 if (output_surface_) { | 281 if (compositor_frame_sink_) { |
279 base::AutoReset<IPC::Message*> scoped_software_draw_reply( | 282 base::AutoReset<IPC::Message*> scoped_software_draw_reply( |
280 &software_draw_reply_, reply_message); | 283 &software_draw_reply_, reply_message); |
281 SkCanvas* sk_canvas_for_draw = SynchronousCompositorGetSkCanvas(); | 284 SkCanvas* sk_canvas_for_draw = SynchronousCompositorGetSkCanvas(); |
282 if (use_in_process_zero_copy_software_draw_) { | 285 if (use_in_process_zero_copy_software_draw_) { |
283 DCHECK(sk_canvas_for_draw); | 286 DCHECK(sk_canvas_for_draw); |
284 output_surface_->DemandDrawSw(sk_canvas_for_draw); | 287 compositor_frame_sink_->DemandDrawSw(sk_canvas_for_draw); |
285 } else { | 288 } else { |
286 DCHECK(!sk_canvas_for_draw); | 289 DCHECK(!sk_canvas_for_draw); |
287 DoDemandDrawSw(params); | 290 DoDemandDrawSw(params); |
288 } | 291 } |
289 } | 292 } |
290 if (inside_receive_) { | 293 if (inside_receive_) { |
291 // Did not swap. | 294 // Did not swap. |
292 SendDemandDrawSwReply(false, cc::CompositorFrame(), reply_message); | 295 SendDemandDrawSwReply(false, cc::CompositorFrame(), reply_message); |
293 inside_receive_ = false; | 296 inside_receive_ = false; |
294 } | 297 } |
295 } | 298 } |
296 | 299 |
297 void SynchronousCompositorProxy::DoDemandDrawSw( | 300 void SynchronousCompositorProxy::DoDemandDrawSw( |
298 const SyncCompositorDemandDrawSwParams& params) { | 301 const SyncCompositorDemandDrawSwParams& params) { |
299 DCHECK(output_surface_); | 302 DCHECK(compositor_frame_sink_); |
300 DCHECK(software_draw_shm_->zeroed); | 303 DCHECK(software_draw_shm_->zeroed); |
301 software_draw_shm_->zeroed = false; | 304 software_draw_shm_->zeroed = false; |
302 | 305 |
303 SkImageInfo info = | 306 SkImageInfo info = |
304 SkImageInfo::MakeN32Premul(params.size.width(), params.size.height()); | 307 SkImageInfo::MakeN32Premul(params.size.width(), params.size.height()); |
305 size_t stride = info.minRowBytes(); | 308 size_t stride = info.minRowBytes(); |
306 size_t buffer_size = info.getSafeSize(stride); | 309 size_t buffer_size = info.getSafeSize(stride); |
307 DCHECK_EQ(software_draw_shm_->buffer_size, buffer_size); | 310 DCHECK_EQ(software_draw_shm_->buffer_size, buffer_size); |
308 | 311 |
309 SkBitmap bitmap; | 312 SkBitmap bitmap; |
310 if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride)) | 313 if (!bitmap.installPixels(info, software_draw_shm_->shm.memory(), stride)) |
311 return; | 314 return; |
312 SkCanvas canvas(bitmap); | 315 SkCanvas canvas(bitmap); |
313 canvas.setMatrix(params.transform.matrix()); | 316 canvas.setMatrix(params.transform.matrix()); |
314 canvas.setClipRegion(SkRegion(gfx::RectToSkIRect(params.clip))); | 317 canvas.setClipRegion(SkRegion(gfx::RectToSkIRect(params.clip))); |
315 | 318 |
316 output_surface_->DemandDrawSw(&canvas); | 319 compositor_frame_sink_->DemandDrawSw(&canvas); |
317 } | 320 } |
318 | 321 |
319 void SynchronousCompositorProxy::SwapBuffersSw(cc::CompositorFrame frame) { | 322 void SynchronousCompositorProxy::SwapBuffersSw(cc::CompositorFrame frame) { |
320 DCHECK(inside_receive_); | 323 DCHECK(inside_receive_); |
321 DCHECK(software_draw_reply_); | 324 DCHECK(software_draw_reply_); |
322 SendDemandDrawSwReply(true, std::move(frame), software_draw_reply_); | 325 SendDemandDrawSwReply(true, std::move(frame), software_draw_reply_); |
323 inside_receive_ = false; | 326 inside_receive_ = false; |
324 } | 327 } |
325 | 328 |
326 void SynchronousCompositorProxy::SendDemandDrawSwReply( | 329 void SynchronousCompositorProxy::SendDemandDrawSwReply( |
327 bool success, | 330 bool success, |
328 cc::CompositorFrame frame, | 331 cc::CompositorFrame frame, |
329 IPC::Message* reply_message) { | 332 IPC::Message* reply_message) { |
330 SyncCompositorCommonRendererParams common_renderer_params; | 333 SyncCompositorCommonRendererParams common_renderer_params; |
331 PopulateCommonParams(&common_renderer_params); | 334 PopulateCommonParams(&common_renderer_params); |
332 SyncCompositorMsg_DemandDrawSw::WriteReplyParams( | 335 SyncCompositorMsg_DemandDrawSw::WriteReplyParams( |
333 reply_message, success, common_renderer_params, frame); | 336 reply_message, success, common_renderer_params, frame); |
334 Send(reply_message); | 337 Send(reply_message); |
335 } | 338 } |
336 | 339 |
337 void SynchronousCompositorProxy::SwapBuffers(uint32_t output_surface_id, | 340 void SynchronousCompositorProxy::SwapBuffers(uint32_t compositor_frame_sink_id, |
338 cc::CompositorFrame frame) { | 341 cc::CompositorFrame frame) { |
339 // Verify that exactly one of these is true. | 342 // Verify that exactly one of these is true. |
340 DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ || | 343 DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ || |
341 software_draw_reply_); | 344 software_draw_reply_); |
342 DCHECK(!((hardware_draw_reply_ && software_draw_reply_) || | 345 DCHECK(!((hardware_draw_reply_ && software_draw_reply_) || |
343 (hardware_draw_reply_ && hardware_draw_reply_async_) || | 346 (hardware_draw_reply_ && hardware_draw_reply_async_) || |
344 (software_draw_reply_ && hardware_draw_reply_async_))); | 347 (software_draw_reply_ && hardware_draw_reply_async_))); |
345 if (hardware_draw_reply_async_) { | 348 if (hardware_draw_reply_async_) { |
346 SwapBuffersHwAsync(output_surface_id, std::move(frame)); | 349 SwapBuffersHwAsync(compositor_frame_sink_id, std::move(frame)); |
347 } else if (hardware_draw_reply_) { | 350 } else if (hardware_draw_reply_) { |
348 SwapBuffersHw(output_surface_id, std::move(frame)); | 351 SwapBuffersHw(compositor_frame_sink_id, std::move(frame)); |
349 } else if (software_draw_reply_) { | 352 } else if (software_draw_reply_) { |
350 SwapBuffersSw(std::move(frame)); | 353 SwapBuffersSw(std::move(frame)); |
351 } | 354 } |
352 } | 355 } |
353 | 356 |
354 void SynchronousCompositorProxy::OnComputeScroll( | 357 void SynchronousCompositorProxy::OnComputeScroll( |
355 base::TimeTicks animation_time) { | 358 base::TimeTicks animation_time) { |
356 if (need_animate_scroll_) { | 359 if (need_animate_scroll_) { |
357 need_animate_scroll_ = false; | 360 need_animate_scroll_ = false; |
358 input_handler_proxy_->SynchronouslyAnimate(animation_time); | 361 input_handler_proxy_->SynchronouslyAnimate(animation_time); |
(...skipping 12 matching lines...) Expand all Loading... |
371 | 374 |
372 void SynchronousCompositorProxy::SetScroll( | 375 void SynchronousCompositorProxy::SetScroll( |
373 const gfx::ScrollOffset& new_total_scroll_offset) { | 376 const gfx::ScrollOffset& new_total_scroll_offset) { |
374 if (total_scroll_offset_ == new_total_scroll_offset) | 377 if (total_scroll_offset_ == new_total_scroll_offset) |
375 return; | 378 return; |
376 total_scroll_offset_ = new_total_scroll_offset; | 379 total_scroll_offset_ = new_total_scroll_offset; |
377 input_handler_proxy_->SynchronouslySetRootScrollOffset(total_scroll_offset_); | 380 input_handler_proxy_->SynchronouslySetRootScrollOffset(total_scroll_offset_); |
378 } | 381 } |
379 | 382 |
380 } // namespace content | 383 } // namespace content |
OLD | NEW |