cc: Enable use of render surfaces for Android WebView

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 89 matching lines @@
   unsigned GetOverlayTextureId() const override { return 0; }
   bool SurfaceIsSuspendForRecycle() const override { return false; }
   bool HasExternalStencilTest() const override { return false; }
   void ApplyExternalStencil() override {}
 };
 
 SynchronousCompositorFrameSink::SynchronousCompositorFrameSink(
     scoped_refptr<cc::ContextProvider> context_provider,
     scoped_refptr<cc::ContextProvider> worker_context_provider,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+    cc::SharedBitmapManager* shared_bitmap_manager,
     int routing_id,
     uint32_t compositor_frame_sink_id,
     std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
     SynchronousCompositorRegistry* registry,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::CompositorFrameSink(std::move(context_provider),
                               std::move(worker_context_provider),
                               gpu_memory_buffer_manager,
                               nullptr),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
+      shared_bitmap_manager_(shared_bitmap_manager),
       sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue),
       surface_manager_(new cc::SurfaceManager),
       surface_id_allocator_(new cc::SurfaceIdAllocator()),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
@@ skipping 46 matching lines @@
   child_support_.reset(new cc::CompositorFrameSinkSupport(
       this, surface_manager_.get(), kChildFrameSinkId, child_support_is_root,
       handles_frame_sink_id_invalidation, needs_sync_points));
 
   cc::RendererSettings software_renderer_settings;
 
   auto output_surface = base::MakeUnique<SoftwareOutputSurface>(
       base::MakeUnique<SoftwareDevice>(&current_sw_canvas_));
   software_output_surface_ = output_surface.get();
 
-  // The shared_bitmap_manager and gpu_memory_buffer_manager here are null as
-  // this Display is only used for resourcesless software draws, where no
-  // resources are included in the frame swapped from the compositor. So there
-  // is no need for these.
+  // The gpu_memory_buffer_manager here is null as the Display is only used for
+  // resourcesless software draws, where no resources are included in the frame
+  // swapped from the compositor. So there is no need for it.
+  // The shared_bitmap_manager_ is provided for the Display to allocate
+  // resources.
+  // TODO(crbug.com/692814): The Display never sends its resources out of
+  // process so there is no reason for it to use a SharedBitmapManager.
   display_.reset(new cc::Display(
-      nullptr /* shared_bitmap_manager */,
-      nullptr /* gpu_memory_buffer_manager */, software_renderer_settings,
-      kRootFrameSinkId, nullptr /* begin_frame_source */,
-      std::move(output_surface), nullptr /* scheduler */,
-      nullptr /* texture_mailbox_deleter */));
+      shared_bitmap_manager_, nullptr /* gpu_memory_buffer_manager */,
+      software_renderer_settings, kRootFrameSinkId,
+      nullptr /* begin_frame_source */, std::move(output_surface),
+      nullptr /* scheduler */, nullptr /* texture_mailbox_deleter */));
   display_->Initialize(&display_client_, surface_manager_.get());
   display_->SetVisible(true);
   return true;
 }
 
 void SynchronousCompositorFrameSink::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   begin_frame_source_ = nullptr;
@@ skipping 254 matching lines @@
 
 void SynchronousCompositorFrameSink::ReclaimResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(resources.empty());
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::WillDrawSurface() {}
 
 }  // namespace content