Replace usage of SurfaceId's client_id with 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 10 matching lines @@
 #include "ui/gfx/geometry/dip_util.h"
 
 namespace ui {
 
 namespace {
 
 void SatisfyCallback(cc::SurfaceManager* manager,
                      const cc::SurfaceSequence& sequence) {
   std::vector<uint32_t> sequences;
   sequences.push_back(sequence.sequence);
-  manager->DidSatisfySequences(sequence.client_id, &sequences);
+  manager->DidSatisfySequences(sequence.frame_sink_id, &sequences);
 }
 
 void RequireCallback(cc::SurfaceManager* manager,
                      const cc::SurfaceId& id,
                      const cc::SurfaceSequence& sequence) {
   cc::Surface* surface = manager->GetSurfaceForId(id);
   if (!surface) {
     LOG(ERROR) << "Attempting to require callback on nonexistent surface";
     return;
   }
@@ skipping 33 matching lines @@
     ReturnResourcesCallback return_resources_callback)
     : 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()->AllocateSurfaceClientId()));
-  surface_manager_->RegisterSurfaceClientId(surface_id_allocator_->client_id());
+      ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()));
+  surface_manager_->RegisterFrameSinkId(surface_id_allocator_->frame_sink_id());
 
   background_layer_->SetBackgroundColor(background_color);
   view_->GetLayer()->AddChild(background_layer_);
   UpdateBackgroundLayer();
 }
 
 DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
   DestroyDelegatedContent();
   surface_factory_.reset();
-  UnregisterSurfaceNamespaceHierarchy();
-  surface_manager_->InvalidateSurfaceClientId(
-      surface_id_allocator_->client_id());
+  UnregisterFrameSinkHierarchy();
+  surface_manager_->InvalidateFrameSinkId(
+      surface_id_allocator_->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) {
@@ skipping 43 matching lines @@
                            current_frame_->surface_size,
                            !current_frame_->has_transparent_background);
     view_->GetLayer()->AddChild(content_layer_);
     UpdateBackgroundLayer();
   }
 
   surface_factory_->SubmitCompositorFrame(current_frame_->surface_id,
                                           std::move(frame), draw_callback);
 }
 
-uint32_t DelegatedFrameHostAndroid::GetSurfaceClientId() const {
-  return surface_id_allocator_->client_id();
+cc::FrameSinkId DelegatedFrameHostAndroid::GetFrameSinkId() const {
+  return surface_id_allocator_->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 41 matching lines @@
 }
 
 void DelegatedFrameHostAndroid::UpdateContainerSizeinDIP(
     const gfx::Size& size_in_dip) {
   container_size_in_dip_ = size_in_dip;
   background_layer_->SetBounds(gfx::ConvertSizeToPixel(
       gfx::DeviceDisplayInfo().GetDIPScale(), container_size_in_dip_));
   UpdateBackgroundLayer();
 }
 
-void DelegatedFrameHostAndroid::RegisterSurfaceNamespaceHierarchy(
-    uint32_t parent_id) {
-  if (registered_parent_client_id_ != 0u)
-    UnregisterSurfaceNamespaceHierarchy();
-  registered_parent_client_id_ = parent_id;
+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_->client_id(), this);
-  surface_manager_->RegisterSurfaceNamespaceHierarchy(
-      parent_id, surface_id_allocator_->client_id());
+      surface_id_allocator_->frame_sink_id(), this);
+  surface_manager_->RegisterFrameSinkHierarchy(
+      parent_id, surface_id_allocator_->frame_sink_id());
 }
 
-void DelegatedFrameHostAndroid::UnregisterSurfaceNamespaceHierarchy() {
-  if (registered_parent_client_id_ == 0u)
+void DelegatedFrameHostAndroid::UnregisterFrameSinkHierarchy() {
+  if (registered_parent_frame_sink_id_.is_null())
     return;
   surface_manager_->UnregisterSurfaceFactoryClient(
-      surface_id_allocator_->client_id());
-  surface_manager_->UnregisterSurfaceNamespaceHierarchy(
-      registered_parent_client_id_, surface_id_allocator_->client_id());
-  registered_parent_client_id_ = 0u;
+      surface_id_allocator_->frame_sink_id());
+  surface_manager_->UnregisterFrameSinkHierarchy(
+      registered_parent_frame_sink_id_, surface_id_allocator_->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) {
   // TODO(enne): hook this up instead of making RWHVAndroid a
@@ skipping 15 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