Reduce SurfaceIdAllocator usage and tie SurfaceFactory to a single FrameSinkId

ui/android/delegated_frame_host_android.cc

 // Copyright 2016 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 "ui/android/delegated_frame_host_android.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
@@ skipping 55 matching lines @@
   readback_layer->RemoveFromParent();
   result_callback.Run(std::move(copy_output_result));
 }
 
 }  // namespace
 
 DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
     ui::ViewAndroid* view,
     SkColor background_color,
     ReturnResourcesCallback return_resources_callback)
-    : view_(view),
+    : frame_sink_id_(
+          ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()),
+      view_(view),
       return_resources_callback_(return_resources_callback),
       background_layer_(cc::SolidColorLayer::Create()) {
   DCHECK(view_);
   DCHECK(!return_resources_callback_.is_null());
 
   surface_manager_ =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
-  surface_id_allocator_.reset(new cc::SurfaceIdAllocator(
-      ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()));
-  surface_manager_->RegisterFrameSinkId(surface_id_allocator_->frame_sink_id());
+  surface_id_allocator_.reset(new cc::SurfaceIdAllocator(frame_sink_id_));
+  surface_manager_->RegisterFrameSinkId(frame_sink_id_);
 
   background_layer_->SetBackgroundColor(background_color);
   view_->GetLayer()->AddChild(background_layer_);
   UpdateBackgroundLayer();
 }
 
 DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
   DestroyDelegatedContent();
   surface_factory_.reset();
   UnregisterFrameSinkHierarchy();
-  surface_manager_->InvalidateFrameSinkId(
-      surface_id_allocator_->frame_sink_id());
+  surface_manager_->InvalidateFrameSinkId(frame_sink_id_);
   background_layer_->RemoveFromParent();
 }
 
 DelegatedFrameHostAndroid::FrameData::FrameData() = default;
 
 DelegatedFrameHostAndroid::FrameData::~FrameData() = default;
 
 void DelegatedFrameHostAndroid::SubmitCompositorFrame(
     cc::CompositorFrame frame,
     cc::SurfaceFactory::DrawCallback draw_callback) {
   if (!surface_factory_) {
-    surface_factory_ =
-        base::WrapUnique(new cc::SurfaceFactory(surface_manager_, this));
+    surface_factory_ = base::WrapUnique(
+        new cc::SurfaceFactory(frame_sink_id_, surface_manager_, this));
   }
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
   if (!current_frame_ || surface_size != current_frame_->surface_size ||
       current_frame_->top_controls_height !=
           frame.metadata.top_controls_height ||
       current_frame_->top_controls_shown_ratio !=
@@ skipping 31 matching lines @@
                            !current_frame_->has_transparent_background);
     view_->GetLayer()->AddChild(content_layer_);
     UpdateBackgroundLayer();
   }
 
   surface_factory_->SubmitCompositorFrame(current_frame_->surface_id,
                                           std::move(frame), draw_callback);
 }
 
 cc::FrameSinkId DelegatedFrameHostAndroid::GetFrameSinkId() const {
-  return surface_id_allocator_->frame_sink_id();
+  return frame_sink_id_;
 }
 
 void DelegatedFrameHostAndroid::RequestCopyOfSurface(
     WindowAndroidCompositor* compositor,
     const gfx::Rect& src_subrect_in_pixel,
     cc::CopyOutputRequest::CopyOutputRequestCallback result_callback) {
   DCHECK(current_frame_);
   DCHECK(!result_callback.is_null());
 
   scoped_refptr<cc::Layer> readback_layer =
@@ skipping 46 matching lines @@
   background_layer_->SetBounds(gfx::ConvertSizeToPixel(
       gfx::DeviceDisplayInfo().GetDIPScale(), container_size_in_dip_));
   UpdateBackgroundLayer();
 }
 
 void DelegatedFrameHostAndroid::RegisterFrameSinkHierarchy(
     const cc::FrameSinkId& parent_id) {
   if (!registered_parent_frame_sink_id_.is_null())
     UnregisterFrameSinkHierarchy();
   registered_parent_frame_sink_id_ = parent_id;
-  surface_manager_->RegisterSurfaceFactoryClient(
-      surface_id_allocator_->frame_sink_id(), this);
-  surface_manager_->RegisterFrameSinkHierarchy(
-      parent_id, surface_id_allocator_->frame_sink_id());
+  surface_manager_->RegisterSurfaceFactoryClient(frame_sink_id_, this);
+  surface_manager_->RegisterFrameSinkHierarchy(parent_id, frame_sink_id_);
 }
 
 void DelegatedFrameHostAndroid::UnregisterFrameSinkHierarchy() {
   if (registered_parent_frame_sink_id_.is_null())
     return;
-  surface_manager_->UnregisterSurfaceFactoryClient(
-      surface_id_allocator_->frame_sink_id());
+  surface_manager_->UnregisterSurfaceFactoryClient(frame_sink_id_);
   surface_manager_->UnregisterFrameSinkHierarchy(
-      registered_parent_frame_sink_id_, surface_id_allocator_->frame_sink_id());
+      registered_parent_frame_sink_id_, frame_sink_id_);
   registered_parent_frame_sink_id_ = cc::FrameSinkId();
 }
 
 void DelegatedFrameHostAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   return_resources_callback_.Run(resources);
 }
 
 void DelegatedFrameHostAndroid::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
@@ skipping 16 matching lines @@
         content_size_in_dip.width() < container_size_in_dip_.width() ||
         content_size_in_dip.height() < container_size_in_dip_.height();
   } else {
     background_is_drawable = true;
   }
 
   background_layer_->SetIsDrawable(background_is_drawable);
 }
 
 }  // namespace ui