Replace usage of SurfaceId's client_id with FrameSinkId

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 312 matching lines @@
         gpu::VulkanSurface::CreateViewSurface(widget));
     if (!surface->Initialize(vulkan_context_provider()->GetDeviceQueue(),
                              gpu::VulkanSurface::DEFAULT_SURFACE_FORMAT)) {
       return false;
     }
     surface_ = std::move(surface);
 
     return true;
   }
 
-  bool BindToClient(cc::OutputSurfaceClient* client) override {
+  bool BindToClient(cc::OutputFrameSink* client) override {

[boliu, 2016/09/30 21:06:06]

does this compile? this is still an OutputSurface, not FrameSink?

[Fady Samuel, 2016/09/30 21:49:30]

Done.

[danakj, 2016/09/30 23:10:43]

We don't actually build with ENABLE_VULKAN anywhere atm, but it's nice to try
keep this code not insanely wrong I guess.

     if (!OutputSurface::BindToClient(client))
       return false;
     return true;
   }
 
   void SwapBuffers(cc::CompositorFrame frame) override {
     surface_->SwapBuffers();
     PostSwapBuffersComplete();
   }
 
@@ skipping 47 matching lines @@
   g_initialized = true;
 }
 
 // static
 bool CompositorImpl::IsInitialized() {
   return g_initialized;
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
-    : surface_id_allocator_(
-          new cc::SurfaceIdAllocator(ui::ContextProviderFactory::GetInstance()
-                                         ->AllocateSurfaceClientId())),
+    : surface_id_allocator_(new cc::SurfaceIdAllocator(
+          ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId())),
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       compositor_frame_sink_request_pending_(false),
       needs_begin_frames_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
-      ->RegisterSurfaceClientId(surface_id_allocator_->client_id());
+      ->RegisterFrameSinkId(surface_id_allocator_->frame_sink_id());
   DCHECK(client);
   DCHECK(root_window);
   DCHECK(root_window->GetLayer() == nullptr);
   root_window->SetLayer(cc::Layer::Create());
   readback_layer_tree_ = cc::Layer::Create();
   readback_layer_tree_->SetHideLayerAndSubtree(true);
   root_window->GetLayer()->AddChild(readback_layer_tree_);
   root_window->AttachCompositor(this);
   CreateLayerTreeHost();
   resource_manager_.Init(host_->GetUIResourceManager());
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   root_window_->SetLayer(nullptr);
   // Clean-up any surface references.
   SetSurface(NULL);
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
-      ->InvalidateSurfaceClientId(surface_id_allocator_->client_id());
+      ->InvalidateFrameSinkId(surface_id_allocator_->frame_sink_id());
 }
 
 ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
   return *this;
 }
 
 ui::ResourceManager& CompositorImpl::GetResourceManager() {
   return resource_manager_;
 }
 
@@ skipping 64 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::LayerTreeHostInProcess::CreateSingleThreaded(this, &params);
   DCHECK(!host_->IsVisible());
   host_->GetLayerTree()->SetRootLayer(root_window_->GetLayer());
-  host_->SetSurfaceClientId(surface_id_allocator_->client_id());
+  host_->SetFrameSinkId(surface_id_allocator_->frame_sink_id());
   host_->GetLayerTree()->SetViewportSize(size_);
   host_->GetLayerTree()->set_has_transparent_background(
       has_transparent_background_);
   host_->GetLayerTree()->set_background_color(SK_ColorBLACK);
   host_->GetLayerTree()->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
@@ skipping 289 matching lines @@
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content