Update Surface ID Terminology

content/browser/renderer_host/compositor_impl_android.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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 280 matching lines @@
 #endif
 
 base::LazyInstance<scoped_refptr<cc::VulkanInProcessContextProvider>>
     g_shared_vulkan_context_provider_android_ = LAZY_INSTANCE_INITIALIZER;
 
 static bool g_initialized = false;
 
 base::LazyInstance<cc::SurfaceManager> g_surface_manager =
     LAZY_INSTANCE_INITIALIZER;
 
-int g_surface_id_namespace = 0;
+int g_surface_client_id = 0;
 
 class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
  public:
   SingleThreadTaskGraphRunner() {
     Start("CompositorTileWorker1", base::SimpleThread::Options());
   }
 
   ~SingleThreadTaskGraphRunner() override {
     Shutdown();
   }
@@ skipping 23 matching lines @@
 
 // static
 cc::SurfaceManager* CompositorImpl::GetSurfaceManager() {
   return g_surface_manager.Pointer();
 }
 
 // static
 std::unique_ptr<cc::SurfaceIdAllocator>
 CompositorImpl::CreateSurfaceIdAllocator() {
   std::unique_ptr<cc::SurfaceIdAllocator> allocator(
-      new cc::SurfaceIdAllocator(++g_surface_id_namespace));
+      new cc::SurfaceIdAllocator(0 /* gpu_id */, ++g_surface_client_id));
   cc::SurfaceManager* manager = GetSurfaceManager();
   DCHECK(manager);
-  allocator->RegisterSurfaceIdNamespace(manager);
+  allocator->RegisterSurfaceClientId(manager);
   return allocator;
 }
 
 // static
 scoped_refptr<cc::VulkanInProcessContextProvider>
 CompositorImpl::SharedVulkanContextProviderAndroid() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVulkan)) {
     scoped_refptr<cc::VulkanInProcessContextProvider>* context_provider =
         g_shared_vulkan_context_provider_android_.Pointer();
@@ skipping 109 matching lines @@
   params.client = this;
   params.shared_bitmap_manager = HostSharedBitmapManager::current();
   params.gpu_memory_buffer_manager = BrowserGpuMemoryBufferManager::current();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   params.animation_host = cc::AnimationHost::CreateMainInstance();
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   DCHECK(!host_->visible());
   host_->SetRootLayer(root_layer_);
-  host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
+  host_->set_surface_client_id(surface_id_allocator_->client_id());
   host_->SetViewportSize(size_);
   host_->set_has_transparent_background(has_transparent_background_);
   host_->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
@@ skipping 209 matching lines @@
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source(
       new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_.reset(new cc::Display(
       manager, HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
-      host_->settings().renderer_settings,
-      surface_id_allocator_->id_namespace(), std::move(begin_frame_source),
-      std::move(display_output_surface), std::move(scheduler),
+      host_->settings().renderer_settings, surface_id_allocator_->client_id(),
+      std::move(begin_frame_source), std::move(display_output_surface),
+      std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner)));
 
   std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
       vulkan_context_provider
           ? new cc::SurfaceDisplayOutputSurface(
                 manager, surface_id_allocator_.get(), display_.get(),
                 static_cast<scoped_refptr<cc::VulkanContextProvider>>(
                     vulkan_context_provider))
           : new cc::SurfaceDisplayOutputSurface(
                 manager, surface_id_allocator_.get(), display_.get(),
@@ skipping 82 matching lines @@
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content