Rename SurfaceIdAllocator to LocalSurfaceIdAllocator

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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/renderer/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_sink_client.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_frame.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/output/software_output_device.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/compositor_frame_sink_support.h"
 #include "cc/surfaces/display.h"
-#include "cc/surfaces/surface_id_allocator.h"
+#include "cc/surfaces/local_surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/renderer/android/synchronous_compositor_filter.h"
 #include "content/renderer/android/synchronous_compositor_registry.h"
 #include "content/renderer/gpu/frame_swap_message_queue.h"
 #include "content/renderer/render_thread_impl.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "ipc/ipc_message.h"
@@ skipping 79 matching lines @@
                               gpu_memory_buffer_manager,
                               nullptr),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
       shared_bitmap_manager_(shared_bitmap_manager),
       sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue),
       surface_manager_(new cc::SurfaceManager),
-      surface_id_allocator_(new cc::SurfaceIdAllocator()),
+      local_surface_id_allocator_(new cc::LocalSurfaceIdAllocator()),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorFrameSink::~SynchronousCompositorFrameSink() = default;
@@ skipping 69 matching lines @@
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   begin_frame_source_ = nullptr;
   registry_->UnregisterCompositorFrameSink(routing_id_, this);
   client_->SetTreeActivationCallback(base::Closure());
   root_support_.reset();
   child_support_.reset();
   software_output_surface_ = nullptr;
   display_ = nullptr;
-  surface_id_allocator_ = nullptr;
+  local_surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
 void SynchronousCompositorFrameSink::SubmitCompositorFrame(
     cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
   if (fallback_tick_running_) {
     DCHECK(frame.resource_list.empty());
     cc::ReturnedResourceArray return_resources;
     ReclaimResources(return_resources);
     did_submit_frame_ = true;
     return;
   }
 
   cc::CompositorFrame submit_frame;
 
   if (in_software_draw_) {
     // The frame we send to the client is actually just the metadata. Preserve
     // the |frame| for the software path below.
     submit_frame.metadata = frame.metadata.Clone();
 
     if (!root_local_surface_id_.is_valid()) {
-      root_local_surface_id_ = surface_id_allocator_->GenerateId();
-      child_local_surface_id_ = surface_id_allocator_->GenerateId();
+      root_local_surface_id_ = local_surface_id_allocator_->GenerateId();
+      child_local_surface_id_ = local_surface_id_allocator_->GenerateId();
     }
 
     display_->SetLocalSurfaceId(root_local_surface_id_,
                                 frame.metadata.device_scale_factor);
 
     // The layer compositor should be giving a frame that covers the
     // |sw_viewport_for_current_draw_| but at 0,0.
     gfx::Size child_size = sw_viewport_for_current_draw_.size();
     DCHECK(gfx::Rect(child_size) == frame.render_pass_list.back()->output_rect);
 
@@ skipping 212 matching lines @@
     const cc::ReturnedResourceArray& resources) {
   DCHECK(resources.empty());
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::WillDrawSurface(
     const cc::LocalSurfaceId& local_surface_id,
     const gfx::Rect& damage_rect) {}
 
 }  // namespace content