Move GpuMemoryBufferManager and SharedBitmapManager to CompositorFrameSink

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 86 matching lines @@
   bool IsDisplayedAsOverlayPlane() const override { return false; }
   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,
     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)),
+                              std::move(worker_context_provider),
+                              gpu_memory_buffer_manager,
+                              nullptr),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
       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()),
       surface_factory_(
           new cc::SurfaceFactory(kFrameSinkId, surface_manager_.get(), this)),
@@ skipping 43 matching lines @@
 
   surface_manager_->RegisterFrameSinkId(kFrameSinkId);
   surface_manager_->RegisterSurfaceFactoryClient(kFrameSinkId, this);
 
   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.
   display_.reset(new cc::Display(
-      nullptr /* shared_bitmap_manager */,
-      nullptr /* gpu_memory_buffer_manager */, software_renderer_settings,
-      nullptr /* begin_frame_source */, std::move(output_surface),
-      nullptr /* scheduler */, nullptr /* texture_mailbox_deleter */));
+      nullptr /* shared_bitmap_manager */, gpu_memory_buffer_manager(),

[danakj, 2016/10/28 01:33:20]

In this one they were both null before because its for resourceless software
draw. If anything it'd need SBM but actually neither is needed. (There was a bit
comment about this, maybe it'd make sense to leave this both null and put that
back.)

[piman, 2016/10/28 22:08:33]

Done.

+      software_renderer_settings, nullptr /* begin_frame_source */,
+      std::move(output_surface), nullptr /* scheduler */,
+      nullptr /* texture_mailbox_deleter */));
   display_->Initialize(&display_client_, surface_manager_.get(), kFrameSinkId);
   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 268 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content