Introduce cc::LocalFrameId and use in SurfaceFactory

blimp/client/core/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 56 matching lines @@
       frame_sink_id_(compositor_dependencies_->GetEmbedderDependencies()
                          ->AllocateFrameSinkId()),
       proxy_client_(nullptr),
       compositor_frame_sink_request_pending_(false),
       layer_(cc::Layer::Create()),
       remote_proto_channel_receiver_(nullptr),
       outstanding_commits_(0U),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  surface_id_allocator_ =
-      base::MakeUnique<cc::SurfaceIdAllocator>(frame_sink_id_);
+  surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>();
   GetEmbedderDeps()->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
   CreateLayerTreeHost();
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
 
@@ skipping 126 matching lines @@
 }
 
 void BlimpCompositor::SwapCompositorFrame(cc::CompositorFrame frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   cc::RenderPass* root_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
   gfx::Size surface_size = root_pass->output_rect.size();
 
-  if (surface_id_.is_null() || current_surface_size_ != surface_size) {
+  if (local_frame_id_.is_null() || current_surface_size_ != surface_size) {
     DestroyDelegatedContent();
     DCHECK(layer_->children().empty());
 
-    surface_id_ = surface_id_allocator_->GenerateId();
-    surface_factory_->Create(surface_id_);
+    local_frame_id_ = surface_id_allocator_->GenerateId();
+    surface_factory_->Create(local_frame_id_);
     current_surface_size_ = surface_size;
 
     // manager must outlive compositors using it.
     cc::SurfaceManager* surface_manager =
         GetEmbedderDeps()->GetSurfaceManager();
     scoped_refptr<cc::SurfaceLayer> content_layer = cc::SurfaceLayer::Create(
         base::Bind(&SatisfyCallback, base::Unretained(surface_manager)),
         base::Bind(&RequireCallback, base::Unretained(surface_manager)));
-    content_layer->SetSurfaceId(surface_id_, 1.f, surface_size);
+    content_layer->SetSurfaceId(
+        cc::SurfaceId(surface_factory_->frame_sink_id(), local_frame_id_), 1.f,
+        surface_size);
     content_layer->SetBounds(current_surface_size_);
     content_layer->SetIsDrawable(true);
     content_layer->SetContentsOpaque(true);
 
     layer_->AddChild(content_layer);
   }
 
-  surface_factory_->SubmitCompositorFrame(surface_id_, std::move(frame),
+  surface_factory_->SubmitCompositorFrame(local_frame_id_, std::move(frame),
                                           base::Closure());
 }
 
 void BlimpCompositor::UnbindProxyClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(surface_factory_);
 
   DestroyDelegatedContent();
   surface_factory_.reset();
   proxy_client_ = nullptr;
 }
 
 void BlimpCompositor::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
   DCHECK(surface_factory_);
   compositor_dependencies_->GetCompositorTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &BlimpCompositorFrameSinkProxyClient::ReclaimCompositorResources,
           proxy_client_, resources));
 }
 
 CompositorDependencies* BlimpCompositor::GetEmbedderDeps() {
   return compositor_dependencies_->GetEmbedderDependencies();
 }
 
 void BlimpCompositor::DestroyDelegatedContent() {
-  if (surface_id_.is_null())
+  if (local_frame_id_.is_null())
     return;
 
-  // Remove any references for the surface layer that uses this |surface_id_|.
+  // Remove any references for the surface layer that uses this
+  // |local_frame_id_|.
   layer_->RemoveAllChildren();
-  surface_factory_->Destroy(surface_id_);
-  surface_id_ = cc::SurfaceId();
+  surface_factory_->Destroy(local_frame_id_);
+  local_frame_id_ = cc::LocalFrameId();
 }
 
 void BlimpCompositor::CreateLayerTreeHost() {
   DCHECK(!host_);
   VLOG(1) << "Creating LayerTreeHost for render widget: " << render_widget_id_;
 
   // Create the LayerTreeHost
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
@@ skipping 57 matching lines @@
       it->second.Run();
       it = pending_commit_trackers_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 }  // namespace client
 }  // namespace blimp