Introduce cc::LocalFrameId and use in SurfaceFactory

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 65 matching lines @@
     : 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(frame_sink_id_));
+  surface_id_allocator_.reset(new cc::SurfaceIdAllocator());
   surface_manager_->RegisterFrameSinkId(frame_sink_id_);
 
   background_layer_->SetBackgroundColor(background_color);
   view_->GetLayer()->AddChild(background_layer_);
   UpdateBackgroundLayer();
 }
 
 DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
   DestroyDelegatedContent();
   surface_factory_.reset();
@@ skipping 28 matching lines @@
       current_frame_->bottom_controls_shown_ratio !=
           frame.metadata.bottom_controls_shown_ratio ||
       current_frame_->viewport_selection != frame.metadata.selection ||
       current_frame_->has_transparent_background !=
           root_pass->has_transparent_background) {
     DestroyDelegatedContent();
     DCHECK(!content_layer_);
     DCHECK(!current_frame_);
 
     current_frame_ = base::MakeUnique<FrameData>();
-    current_frame_->surface_id = surface_id_allocator_->GenerateId();
-    surface_factory_->Create(current_frame_->surface_id);
+    current_frame_->local_frame_id = surface_id_allocator_->GenerateId();
+    surface_factory_->Create(current_frame_->local_frame_id);
 
     current_frame_->surface_size = surface_size;
     current_frame_->top_controls_height = frame.metadata.top_controls_height;
     current_frame_->top_controls_shown_ratio =
         frame.metadata.top_controls_shown_ratio;
     current_frame_->bottom_controls_height =
         frame.metadata.bottom_controls_height;
     current_frame_->bottom_controls_shown_ratio =
         frame.metadata.bottom_controls_shown_ratio;
     current_frame_->has_transparent_background =
         root_pass->has_transparent_background;
 
     current_frame_->viewport_selection = frame.metadata.selection;
-    content_layer_ =
-        CreateSurfaceLayer(surface_manager_, current_frame_->surface_id,
-                           current_frame_->surface_size,
-                           !current_frame_->has_transparent_background);
+    content_layer_ = CreateSurfaceLayer(
+        surface_manager_, cc::SurfaceId(surface_factory_->frame_sink_id(),
+                                        current_frame_->local_frame_id),
+        current_frame_->surface_size,
+        !current_frame_->has_transparent_background);
     view_->GetLayer()->AddChild(content_layer_);
     UpdateBackgroundLayer();
   }
 
-  surface_factory_->SubmitCompositorFrame(current_frame_->surface_id,
+  surface_factory_->SubmitCompositorFrame(current_frame_->local_frame_id,
                                           std::move(frame), draw_callback);
 }
 
 cc::FrameSinkId DelegatedFrameHostAndroid::GetFrameSinkId() const {
   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 =
-      CreateSurfaceLayer(surface_manager_, current_frame_->surface_id,
-                         current_frame_->surface_size,
-                         !current_frame_->has_transparent_background);
+  scoped_refptr<cc::Layer> readback_layer = CreateSurfaceLayer(
+      surface_manager_, cc::SurfaceId(surface_factory_->frame_sink_id(),
+                                      current_frame_->local_frame_id),
+      current_frame_->surface_size,
+      !current_frame_->has_transparent_background);
   readback_layer->SetHideLayerAndSubtree(true);
   compositor->AttachLayerForReadback(readback_layer);
   std::unique_ptr<cc::CopyOutputRequest> copy_output_request =
       cc::CopyOutputRequest::CreateRequest(base::Bind(
           &CopyOutputRequestCallback, readback_layer, result_callback));
 
   if (!src_subrect_in_pixel.IsEmpty())
     copy_output_request->set_area(src_subrect_in_pixel);
 
   readback_layer->RequestCopyOfOutput(std::move(copy_output_request));
 }
 
 void DelegatedFrameHostAndroid::DestroyDelegatedContent() {
   if (!current_frame_)
     return;
 
   DCHECK(surface_factory_.get());
   DCHECK(content_layer_);
 
   content_layer_->RemoveFromParent();
   content_layer_ = nullptr;
-  surface_factory_->Destroy(current_frame_->surface_id);
+  surface_factory_->Destroy(current_frame_->local_frame_id);
   current_frame_.reset();
 
   UpdateBackgroundLayer();
 }
 
 bool DelegatedFrameHostAndroid::HasDelegatedContent() const {
   return current_frame_.get() != nullptr;
 }
 
 void DelegatedFrameHostAndroid::CompositorFrameSinkChanged() {
@@ skipping 57 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