Reduce SurfaceIdAllocator usage and tie SurfaceFactory to a single FrameSinkId

ui/compositor/compositor.cc

 // Copyright (c) 2012 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/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 63 matching lines @@
 Compositor::Compositor(ui::ContextFactory* context_factory,
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       root_layer_(NULL),
       widget_(gfx::kNullAcceleratedWidget),
 #if defined(USE_AURA)
       window_(nullptr),
 #endif
       widget_valid_(false),
       compositor_frame_sink_requested_(false),
-      surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
-          context_factory->AllocateFrameSinkId())),
+      frame_sink_id_(context_factory->AllocateFrameSinkId()),
+      surface_id_allocator_(
+          base::MakeUnique<cc::SurfaceIdAllocator>(frame_sink_id_)),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       locks_will_time_out_(true),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
-  context_factory->GetSurfaceManager()->RegisterFrameSinkId(
-      surface_id_allocator_->frame_sink_id());
+  context_factory->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // This will ensure PictureLayers always can have LCD text, to match the
   // previous behaviour with ContentLayers, where LCD-not-allowed notifications
   // were ignored.
   settings.layers_always_allowed_lcd_text = true;
@@ skipping 94 matching lines @@
   host_ = cc::LayerTreeHostInProcess::CreateSingleThreaded(this, &params);
   UMA_HISTOGRAM_TIMES("GPU.CreateBrowserCompositor",
                       base::TimeTicks::Now() - before_create);
 
   animation_timeline_ =
       cc::AnimationTimeline::Create(cc::AnimationIdProvider::NextTimelineId());
   host_->GetLayerTree()->animation_host()->AddAnimationTimeline(
       animation_timeline_.get());
 
   host_->GetLayerTree()->SetRootLayer(root_web_layer_);
-  host_->SetFrameSinkId(surface_id_allocator_->frame_sink_id());
+  host_->SetFrameSinkId(frame_sink_id_);
   host_->SetVisible(true);
 }
 
 Compositor::~Compositor() {
   TRACE_EVENT0("shutdown", "Compositor::destructor");
 
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingShuttingDown(this));
 
   FOR_EACH_OBSERVER(CompositorAnimationObserver, animation_observer_list_,
                     OnCompositingShuttingDown(this));
 
   if (root_layer_)
     root_layer_->ResetCompositor();
 
   if (animation_timeline_)
     host_->GetLayerTree()->animation_host()->RemoveAnimationTimeline(
         animation_timeline_.get());
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
   host_.reset();
 
   context_factory_->RemoveCompositor(this);
   auto* manager = context_factory_->GetSurfaceManager();
-  for (auto& client : frame_sinks_) {
-    DCHECK(!client.second.is_null());
-    manager->UnregisterFrameSinkHierarchy(client.second, client.first);
+  for (auto& client : child_frame_sinks_) {
+    DCHECK(!client.is_null());
+    manager->UnregisterFrameSinkHierarchy(frame_sink_id_, client);
   }
-  manager->InvalidateFrameSinkId(surface_id_allocator_->frame_sink_id());
+  manager->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void Compositor::AddFrameSink(const cc::FrameSinkId& frame_sink_id) {
-  const cc::FrameSinkId& parent_frame_sink_id =
-      surface_id_allocator_->frame_sink_id();
   context_factory_->GetSurfaceManager()->RegisterFrameSinkHierarchy(
-      parent_frame_sink_id, frame_sink_id);
-  frame_sinks_[frame_sink_id] = parent_frame_sink_id;
+      frame_sink_id_, frame_sink_id);
+  child_frame_sinks_.insert(frame_sink_id);
 }
 
 void Compositor::RemoveFrameSink(const cc::FrameSinkId& frame_sink_id) {
-  auto it = frame_sinks_.find(frame_sink_id);
-  DCHECK(it != frame_sinks_.end());
-  DCHECK(!it->second.is_null());
+  auto it = child_frame_sinks_.find(frame_sink_id);
+  DCHECK(it != child_frame_sinks_.end());
+  DCHECK(!it->is_null());
   context_factory_->GetSurfaceManager()->UnregisterFrameSinkHierarchy(
-      it->second, it->first);
-  frame_sinks_.erase(it);
+      frame_sink_id_, *it);
+  child_frame_sinks_.erase(it);
 }
 
 void Compositor::SetCompositorFrameSink(
     std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
   compositor_frame_sink_requested_ = false;
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
   // Display properties are reset when the output surface is lost, so update it
   // to match the Compositor's.
   context_factory_->SetDisplayVisible(this, host_->IsVisible());
   context_factory_->SetDisplayColorSpace(this, color_space_);
@@ skipping 278 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui