| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 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/renderer/android/synchronous_compositor_output_surface.h" | |
| 6 | |
| 7 #include <vector> | |
| 8 | |
| 9 #include "base/auto_reset.h" | |
| 10 #include "base/location.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/macros.h" | |
| 13 #include "base/memory/ptr_util.h" | |
| 14 #include "base/single_thread_task_runner.h" | |
| 15 #include "base/threading/thread_task_runner_handle.h" | |
| 16 #include "cc/output/compositor_frame.h" | |
| 17 #include "cc/output/context_provider.h" | |
| 18 #include "cc/output/output_surface_client.h" | |
| 19 #include "cc/output/renderer_settings.h" | |
| 20 #include "cc/output/software_output_device.h" | |
| 21 #include "cc/output/texture_mailbox_deleter.h" | |
| 22 #include "cc/surfaces/display.h" | |
| 23 #include "cc/surfaces/surface_factory.h" | |
| 24 #include "cc/surfaces/surface_id_allocator.h" | |
| 25 #include "cc/surfaces/surface_manager.h" | |
| 26 #include "content/common/android/sync_compositor_messages.h" | |
| 27 #include "content/renderer/android/synchronous_compositor_filter.h" | |
| 28 #include "content/renderer/android/synchronous_compositor_registry.h" | |
| 29 #include "content/renderer/gpu/frame_swap_message_queue.h" | |
| 30 #include "content/renderer/render_thread_impl.h" | |
| 31 #include "gpu/command_buffer/client/context_support.h" | |
| 32 #include "gpu/command_buffer/client/gles2_interface.h" | |
| 33 #include "gpu/command_buffer/common/gpu_memory_allocation.h" | |
| 34 #include "ipc/ipc_message.h" | |
| 35 #include "ipc/ipc_message_macros.h" | |
| 36 #include "ipc/ipc_sender.h" | |
| 37 #include "third_party/skia/include/core/SkCanvas.h" | |
| 38 #include "ui/gfx/geometry/rect_conversions.h" | |
| 39 #include "ui/gfx/skia_util.h" | |
| 40 #include "ui/gfx/transform.h" | |
| 41 | |
| 42 namespace content { | |
| 43 | |
| 44 namespace { | |
| 45 | |
| 46 const int64_t kFallbackTickTimeoutInMilliseconds = 100; | |
| 47 const uint32_t kCompositorClientId = 1; | |
| 48 | |
| 49 // Do not limit number of resources, so use an unrealistically high value. | |
| 50 const size_t kNumResourcesLimit = 10 * 1000 * 1000; | |
| 51 | |
| 52 class SoftwareDevice : public cc::SoftwareOutputDevice { | |
| 53 public: | |
| 54 SoftwareDevice(SkCanvas** canvas) : canvas_(canvas) {} | |
| 55 | |
| 56 void Resize(const gfx::Size& pixel_size, float scale_factor) override { | |
| 57 // Intentional no-op: canvas size is controlled by the embedder. | |
| 58 } | |
| 59 SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override { | |
| 60 DCHECK(*canvas_) << "BeginPaint with no canvas set"; | |
| 61 return *canvas_; | |
| 62 } | |
| 63 void EndPaint() override {} | |
| 64 | |
| 65 private: | |
| 66 SkCanvas** canvas_; | |
| 67 | |
| 68 DISALLOW_COPY_AND_ASSIGN(SoftwareDevice); | |
| 69 }; | |
| 70 | |
| 71 } // namespace | |
| 72 | |
| 73 class SynchronousCompositorOutputSurface::SoftwareOutputSurface | |
| 74 : public cc::OutputSurface { | |
| 75 public: | |
| 76 SoftwareOutputSurface(std::unique_ptr<SoftwareDevice> software_device) | |
| 77 : cc::OutputSurface(nullptr, nullptr, std::move(software_device)) {} | |
| 78 | |
| 79 // cc::OutputSurface implementation. | |
| 80 uint32_t GetFramebufferCopyTextureFormat() override { return 0; } | |
| 81 void SwapBuffers(cc::CompositorFrame frame) override {} | |
| 82 void Reshape(const gfx::Size& size, | |
| 83 float scale_factor, | |
| 84 const gfx::ColorSpace& color_space, | |
| 85 bool has_alpha) override { | |
| 86 // Intentional no-op. Surface size controlled by embedder. | |
| 87 } | |
| 88 | |
| 89 void SetSurfaceSize(const gfx::Size surface_size) { | |
| 90 surface_size_ = surface_size; | |
| 91 } | |
| 92 }; | |
| 93 | |
| 94 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface( | |
| 95 scoped_refptr<cc::ContextProvider> context_provider, | |
| 96 scoped_refptr<cc::ContextProvider> worker_context_provider, | |
| 97 int routing_id, | |
| 98 uint32_t output_surface_id, | |
| 99 std::unique_ptr<cc::BeginFrameSource> begin_frame_source, | |
| 100 SynchronousCompositorRegistry* registry, | |
| 101 scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue) | |
| 102 : cc::OutputSurface(std::move(context_provider), | |
| 103 std::move(worker_context_provider), | |
| 104 nullptr), | |
| 105 routing_id_(routing_id), | |
| 106 output_surface_id_(output_surface_id), | |
| 107 registry_(registry), | |
| 108 sender_(RenderThreadImpl::current()->sync_compositor_message_filter()), | |
| 109 memory_policy_(0u), | |
| 110 frame_swap_message_queue_(frame_swap_message_queue), | |
| 111 surface_manager_(new cc::SurfaceManager), | |
| 112 surface_id_allocator_(new cc::SurfaceIdAllocator(kCompositorClientId)), | |
| 113 surface_factory_(new cc::SurfaceFactory(surface_manager_.get(), this)), | |
| 114 begin_frame_source_(std::move(begin_frame_source)) { | |
| 115 DCHECK(registry_); | |
| 116 DCHECK(sender_); | |
| 117 DCHECK(begin_frame_source_); | |
| 118 thread_checker_.DetachFromThread(); | |
| 119 capabilities_.adjust_deadline_for_parent = false; | |
| 120 capabilities_.delegated_rendering = true; | |
| 121 memory_policy_.priority_cutoff_when_visible = | |
| 122 gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE; | |
| 123 } | |
| 124 | |
| 125 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() = | |
| 126 default; | |
| 127 | |
| 128 void SynchronousCompositorOutputSurface::SetSyncClient( | |
| 129 SynchronousCompositorOutputSurfaceClient* compositor) { | |
| 130 DCHECK(CalledOnValidThread()); | |
| 131 sync_client_ = compositor; | |
| 132 if (sync_client_) | |
| 133 Send(new SyncCompositorHostMsg_OutputSurfaceCreated(routing_id_)); | |
| 134 } | |
| 135 | |
| 136 bool SynchronousCompositorOutputSurface::OnMessageReceived( | |
| 137 const IPC::Message& message) { | |
| 138 bool handled = true; | |
| 139 IPC_BEGIN_MESSAGE_MAP(SynchronousCompositorOutputSurface, message) | |
| 140 IPC_MESSAGE_HANDLER(SyncCompositorMsg_SetMemoryPolicy, SetMemoryPolicy) | |
| 141 IPC_MESSAGE_HANDLER(SyncCompositorMsg_ReclaimResources, OnReclaimResources) | |
| 142 IPC_MESSAGE_UNHANDLED(handled = false) | |
| 143 IPC_END_MESSAGE_MAP() | |
| 144 return handled; | |
| 145 } | |
| 146 | |
| 147 bool SynchronousCompositorOutputSurface::BindToClient( | |
| 148 cc::OutputSurfaceClient* surface_client) { | |
| 149 DCHECK(CalledOnValidThread()); | |
| 150 if (!cc::OutputSurface::BindToClient(surface_client)) | |
| 151 return false; | |
| 152 | |
| 153 DCHECK(begin_frame_source_); | |
| 154 client_->SetBeginFrameSource(begin_frame_source_.get()); | |
| 155 client_->SetMemoryPolicy(memory_policy_); | |
| 156 client_->SetTreeActivationCallback( | |
| 157 base::Bind(&SynchronousCompositorOutputSurface::DidActivatePendingTree, | |
| 158 base::Unretained(this))); | |
| 159 registry_->RegisterOutputSurface(routing_id_, this); | |
| 160 registered_ = true; | |
| 161 | |
| 162 surface_manager_->RegisterSurfaceClientId(surface_id_allocator_->client_id()); | |
| 163 surface_manager_->RegisterSurfaceFactoryClient( | |
| 164 surface_id_allocator_->client_id(), this); | |
| 165 | |
| 166 cc::RendererSettings software_renderer_settings; | |
| 167 | |
| 168 std::unique_ptr<SoftwareOutputSurface> output_surface( | |
| 169 new SoftwareOutputSurface( | |
| 170 base::MakeUnique<SoftwareDevice>(¤t_sw_canvas_))); | |
| 171 software_output_surface_ = output_surface.get(); | |
| 172 | |
| 173 // The shared_bitmap_manager and gpu_memory_buffer_manager here are null as | |
| 174 // this Display is only used for resourcesless software draws, where no | |
| 175 // resources are included in the frame swapped from the compositor. So there | |
| 176 // is no need for these. | |
| 177 display_.reset(new cc::Display( | |
| 178 nullptr /* shared_bitmap_manager */, | |
| 179 nullptr /* gpu_memory_buffer_manager */, software_renderer_settings, | |
| 180 nullptr /* begin_frame_source */, std::move(output_surface), | |
| 181 nullptr /* scheduler */, nullptr /* texture_mailbox_deleter */)); | |
| 182 display_->Initialize(&display_client_, surface_manager_.get(), | |
| 183 surface_id_allocator_->client_id()); | |
| 184 display_->SetVisible(true); | |
| 185 return true; | |
| 186 } | |
| 187 | |
| 188 void SynchronousCompositorOutputSurface::DetachFromClient() { | |
| 189 DCHECK(CalledOnValidThread()); | |
| 190 client_->SetBeginFrameSource(nullptr); | |
| 191 // Destroy the begin frame source on the same thread it was bound on. | |
| 192 begin_frame_source_ = nullptr; | |
| 193 if (registered_) | |
| 194 registry_->UnregisterOutputSurface(routing_id_, this); | |
| 195 client_->SetTreeActivationCallback(base::Closure()); | |
| 196 if (!delegated_surface_id_.is_null()) | |
| 197 surface_factory_->Destroy(delegated_surface_id_); | |
| 198 surface_manager_->UnregisterSurfaceFactoryClient( | |
| 199 surface_id_allocator_->client_id()); | |
| 200 surface_manager_->InvalidateSurfaceClientId( | |
| 201 surface_id_allocator_->client_id()); | |
| 202 software_output_surface_ = nullptr; | |
| 203 display_ = nullptr; | |
| 204 surface_factory_ = nullptr; | |
| 205 surface_id_allocator_ = nullptr; | |
| 206 surface_manager_ = nullptr; | |
| 207 cc::OutputSurface::DetachFromClient(); | |
| 208 CancelFallbackTick(); | |
| 209 } | |
| 210 | |
| 211 void SynchronousCompositorOutputSurface::Reshape( | |
| 212 const gfx::Size& size, | |
| 213 float scale_factor, | |
| 214 const gfx::ColorSpace& color_space, | |
| 215 bool has_alpha) { | |
| 216 // Intentional no-op: surface size is controlled by the embedder. | |
| 217 } | |
| 218 | |
| 219 static void NoOpDrawCallback() {} | |
| 220 | |
| 221 void SynchronousCompositorOutputSurface::SwapBuffers( | |
| 222 cc::CompositorFrame frame) { | |
| 223 DCHECK(CalledOnValidThread()); | |
| 224 DCHECK(sync_client_); | |
| 225 | |
| 226 if (fallback_tick_running_) { | |
| 227 DCHECK(frame.delegated_frame_data->resource_list.empty()); | |
| 228 cc::ReturnedResourceArray return_resources; | |
| 229 ReturnResources(return_resources); | |
| 230 did_swap_ = true; | |
| 231 return; | |
| 232 } | |
| 233 | |
| 234 cc::CompositorFrame swap_frame; | |
| 235 | |
| 236 if (in_software_draw_) { | |
| 237 // The frame we send to the client is actually just the metadata. Preserve | |
| 238 // the |frame| for the software path below. | |
| 239 swap_frame.metadata = frame.metadata.Clone(); | |
| 240 | |
| 241 if (delegated_surface_id_.is_null()) { | |
| 242 delegated_surface_id_ = surface_id_allocator_->GenerateId(); | |
| 243 surface_factory_->Create(delegated_surface_id_); | |
| 244 } | |
| 245 | |
| 246 display_->SetSurfaceId(delegated_surface_id_, | |
| 247 frame.metadata.device_scale_factor); | |
| 248 | |
| 249 gfx::Size frame_size = | |
| 250 frame.delegated_frame_data->render_pass_list.back()->output_rect.size(); | |
| 251 display_->Resize(frame_size); | |
| 252 | |
| 253 surface_factory_->SubmitCompositorFrame( | |
| 254 delegated_surface_id_, std::move(frame), base::Bind(&NoOpDrawCallback)); | |
| 255 display_->DrawAndSwap(); | |
| 256 } else { | |
| 257 // For hardware draws we send the whole frame to the client so it can draw | |
| 258 // the content in it. | |
| 259 swap_frame = std::move(frame); | |
| 260 } | |
| 261 | |
| 262 sync_client_->SwapBuffers(output_surface_id_, std::move(swap_frame)); | |
| 263 DeliverMessages(); | |
| 264 did_swap_ = true; | |
| 265 } | |
| 266 | |
| 267 void SynchronousCompositorOutputSurface::CancelFallbackTick() { | |
| 268 fallback_tick_.Cancel(); | |
| 269 fallback_tick_pending_ = false; | |
| 270 } | |
| 271 | |
| 272 void SynchronousCompositorOutputSurface::FallbackTickFired() { | |
| 273 DCHECK(CalledOnValidThread()); | |
| 274 TRACE_EVENT0("renderer", | |
| 275 "SynchronousCompositorOutputSurface::FallbackTickFired"); | |
| 276 base::AutoReset<bool> in_fallback_tick(&fallback_tick_running_, true); | |
| 277 SkBitmap bitmap; | |
| 278 bitmap.allocN32Pixels(1, 1); | |
| 279 bitmap.eraseColor(0); | |
| 280 SkCanvas canvas(bitmap); | |
| 281 fallback_tick_pending_ = false; | |
| 282 DemandDrawSw(&canvas); | |
| 283 } | |
| 284 | |
| 285 void SynchronousCompositorOutputSurface::Invalidate() { | |
| 286 DCHECK(CalledOnValidThread()); | |
| 287 if (sync_client_) | |
| 288 sync_client_->Invalidate(); | |
| 289 | |
| 290 if (!fallback_tick_pending_) { | |
| 291 fallback_tick_.Reset( | |
| 292 base::Bind(&SynchronousCompositorOutputSurface::FallbackTickFired, | |
| 293 base::Unretained(this))); | |
| 294 base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( | |
| 295 FROM_HERE, fallback_tick_.callback(), | |
| 296 base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds)); | |
| 297 fallback_tick_pending_ = true; | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 void SynchronousCompositorOutputSurface::BindFramebuffer() { | |
| 302 // This is a delegating output surface, no framebuffer/direct drawing support. | |
| 303 NOTREACHED(); | |
| 304 } | |
| 305 | |
| 306 uint32_t SynchronousCompositorOutputSurface::GetFramebufferCopyTextureFormat() { | |
| 307 // This is a delegating output surface, no framebuffer/direct drawing support. | |
| 308 NOTREACHED(); | |
| 309 return 0; | |
| 310 } | |
| 311 | |
| 312 void SynchronousCompositorOutputSurface::DemandDrawHw( | |
| 313 const gfx::Size& viewport_size, | |
| 314 const gfx::Rect& viewport_rect_for_tile_priority, | |
| 315 const gfx::Transform& transform_for_tile_priority) { | |
| 316 DCHECK(CalledOnValidThread()); | |
| 317 DCHECK(HasClient()); | |
| 318 DCHECK(context_provider_.get()); | |
| 319 CancelFallbackTick(); | |
| 320 | |
| 321 client_->SetExternalTilePriorityConstraints(viewport_rect_for_tile_priority, | |
| 322 transform_for_tile_priority); | |
| 323 InvokeComposite(gfx::Transform(), gfx::Rect(viewport_size)); | |
| 324 } | |
| 325 | |
| 326 void SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) { | |
| 327 DCHECK(CalledOnValidThread()); | |
| 328 DCHECK(canvas); | |
| 329 DCHECK(!current_sw_canvas_); | |
| 330 CancelFallbackTick(); | |
| 331 | |
| 332 base::AutoReset<SkCanvas*> canvas_resetter(¤t_sw_canvas_, canvas); | |
| 333 | |
| 334 SkIRect canvas_clip; | |
| 335 canvas->getClipDeviceBounds(&canvas_clip); | |
| 336 gfx::Rect viewport = gfx::SkIRectToRect(canvas_clip); | |
| 337 | |
| 338 gfx::Transform transform(gfx::Transform::kSkipInitialization); | |
| 339 transform.matrix() = canvas->getTotalMatrix(); // Converts 3x3 matrix to 4x4. | |
| 340 | |
| 341 base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true); | |
| 342 display_->SetExternalViewport(viewport); | |
| 343 display_->SetExternalClip(viewport); | |
| 344 software_output_surface_->SetSurfaceSize( | |
| 345 gfx::SkISizeToSize(canvas->getBaseLayerSize())); | |
| 346 InvokeComposite(transform, viewport); | |
| 347 } | |
| 348 | |
| 349 void SynchronousCompositorOutputSurface::InvokeComposite( | |
| 350 const gfx::Transform& transform, | |
| 351 const gfx::Rect& viewport) { | |
| 352 gfx::Transform adjusted_transform = transform; | |
| 353 adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0); | |
| 354 did_swap_ = false; | |
| 355 client_->OnDraw(adjusted_transform, viewport, in_software_draw_); | |
| 356 | |
| 357 if (did_swap_) { | |
| 358 // This must happen after unwinding the stack and leaving the compositor. | |
| 359 // Usually it is a separate task but we just defer it until OnDraw completes | |
| 360 // instead. | |
| 361 client_->DidSwapBuffersComplete(); | |
| 362 } | |
| 363 } | |
| 364 | |
| 365 void SynchronousCompositorOutputSurface::OnReclaimResources( | |
| 366 uint32_t output_surface_id, | |
| 367 const cc::ReturnedResourceArray& resources) { | |
| 368 // Ignore message if it's a stale one coming from a different output surface | |
| 369 // (e.g. after a lost context). | |
| 370 if (output_surface_id != output_surface_id_) | |
| 371 return; | |
| 372 client_->ReclaimResources(resources); | |
| 373 } | |
| 374 | |
| 375 void SynchronousCompositorOutputSurface::SetMemoryPolicy(size_t bytes_limit) { | |
| 376 DCHECK(CalledOnValidThread()); | |
| 377 bool became_zero = memory_policy_.bytes_limit_when_visible && !bytes_limit; | |
| 378 bool became_non_zero = | |
| 379 !memory_policy_.bytes_limit_when_visible && bytes_limit; | |
| 380 memory_policy_.bytes_limit_when_visible = bytes_limit; | |
| 381 memory_policy_.num_resources_limit = kNumResourcesLimit; | |
| 382 | |
| 383 if (client_) | |
| 384 client_->SetMemoryPolicy(memory_policy_); | |
| 385 | |
| 386 if (became_zero) { | |
| 387 // This is small hack to drop context resources without destroying it | |
| 388 // when this compositor is put into the background. | |
| 389 context_provider()->ContextSupport()->SetAggressivelyFreeResources( | |
| 390 true /* aggressively_free_resources */); | |
| 391 } else if (became_non_zero) { | |
| 392 context_provider()->ContextSupport()->SetAggressivelyFreeResources( | |
| 393 false /* aggressively_free_resources */); | |
| 394 } | |
| 395 } | |
| 396 | |
| 397 void SynchronousCompositorOutputSurface::DidActivatePendingTree() { | |
| 398 DCHECK(CalledOnValidThread()); | |
| 399 if (sync_client_) | |
| 400 sync_client_->DidActivatePendingTree(); | |
| 401 DeliverMessages(); | |
| 402 } | |
| 403 | |
| 404 void SynchronousCompositorOutputSurface::DeliverMessages() { | |
| 405 std::vector<std::unique_ptr<IPC::Message>> messages; | |
| 406 std::unique_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope = | |
| 407 frame_swap_message_queue_->AcquireSendMessageScope(); | |
| 408 frame_swap_message_queue_->DrainMessages(&messages); | |
| 409 for (auto& msg : messages) { | |
| 410 Send(msg.release()); | |
| 411 } | |
| 412 } | |
| 413 | |
| 414 bool SynchronousCompositorOutputSurface::Send(IPC::Message* message) { | |
| 415 DCHECK(CalledOnValidThread()); | |
| 416 return sender_->Send(message); | |
| 417 } | |
| 418 | |
| 419 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const { | |
| 420 return thread_checker_.CalledOnValidThread(); | |
| 421 } | |
| 422 | |
| 423 void SynchronousCompositorOutputSurface::ReturnResources( | |
| 424 const cc::ReturnedResourceArray& resources) { | |
| 425 DCHECK(resources.empty()); | |
| 426 client_->ReclaimResources(resources); | |
| 427 } | |
| 428 | |
| 429 void SynchronousCompositorOutputSurface::SetBeginFrameSource( | |
| 430 cc::BeginFrameSource* begin_frame_source) { | |
| 431 // Software output is synchronous and doesn't use a BeginFrameSource. | |
| 432 NOTREACHED(); | |
| 433 } | |
| 434 | |
| 435 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2337913003:
Fork cc::OutputSurface into cc::CompositorFrameSink. (Closed)
