Reduce SurfaceIdAllocator usage and tie SurfaceFactory to a single FrameSinkId

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 27 matching lines @@
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
 namespace content {
 
 namespace {
 
 const int64_t kFallbackTickTimeoutInMilliseconds = 100;
-const cc::FrameSinkId kCompositorFrameSinkId(1, 1);
+const cc::FrameSinkId kFrameSinkId(1, 1);
 
 // Do not limit number of resources, so use an unrealistically high value.
 const size_t kNumResourcesLimit = 10 * 1000 * 1000;
 
 class SoftwareDevice : public cc::SoftwareOutputDevice {
  public:
   SoftwareDevice(SkCanvas** canvas) : canvas_(canvas) {}
 
   void Resize(const gfx::Size& pixel_size, float scale_factor) override {
     // Intentional no-op: canvas size is controlled by the embedder.
@@ skipping 54 matching lines @@
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::CompositorFrameSink(std::move(context_provider),
                               std::move(worker_context_provider)),
       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(kCompositorFrameSinkId)),
-      surface_factory_(new cc::SurfaceFactory(surface_manager_.get(), this)),
+      surface_id_allocator_(new cc::SurfaceIdAllocator(kFrameSinkId)),
+      surface_factory_(
+          new cc::SurfaceFactory(kFrameSinkId, surface_manager_.get(), this)),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorFrameSink::~SynchronousCompositorFrameSink() = default;
@@ skipping 25 matching lines @@
 
   DCHECK(begin_frame_source_);
   client_->SetBeginFrameSource(begin_frame_source_.get());
   client_->SetMemoryPolicy(memory_policy_);
   client_->SetTreeActivationCallback(
       base::Bind(&SynchronousCompositorFrameSink::DidActivatePendingTree,
                  base::Unretained(this)));
   registry_->RegisterCompositorFrameSink(routing_id_, this);
   registered_ = true;
 
-  surface_manager_->RegisterFrameSinkId(surface_id_allocator_->frame_sink_id());
-  surface_manager_->RegisterSurfaceFactoryClient(
-      surface_id_allocator_->frame_sink_id(), this);
+  surface_manager_->RegisterFrameSinkId(kFrameSinkId);
+  surface_manager_->RegisterSurfaceFactoryClient(kFrameSinkId, this);
 
   cc::RendererSettings software_renderer_settings;
 
   std::unique_ptr<SoftwareOutputSurface> compositor_frame_sink(
       new SoftwareOutputSurface(
           base::MakeUnique<SoftwareDevice>(&current_sw_canvas_)));
   software_compositor_frame_sink_ = compositor_frame_sink.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(compositor_frame_sink),
       nullptr /* scheduler */, nullptr /* texture_mailbox_deleter */));
-  display_->Initialize(&display_client_, surface_manager_.get(),
-                       surface_id_allocator_->frame_sink_id());
+  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;
   if (registered_)
     registry_->UnregisterCompositorFrameSink(routing_id_, this);
   client_->SetTreeActivationCallback(base::Closure());
   if (!delegated_surface_id_.is_null())
     surface_factory_->Destroy(delegated_surface_id_);
-  surface_manager_->UnregisterSurfaceFactoryClient(
-      surface_id_allocator_->frame_sink_id());
-  surface_manager_->InvalidateFrameSinkId(
-      surface_id_allocator_->frame_sink_id());
+  surface_manager_->UnregisterSurfaceFactoryClient(kFrameSinkId);
+  surface_manager_->InvalidateFrameSinkId(kFrameSinkId);
   software_compositor_frame_sink_ = nullptr;
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
 static void NoOpDrawCallback() {}
@@ skipping 193 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