Update Surface ID Terminology

cc/surfaces/display_unittest.cc

 // Copyright 2015 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 "cc/surfaces/display.h"
 
 #include <utility>
 
 #include "base/test/null_task_runner.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 52 matching lines @@
       : DisplayScheduler(begin_frame_source, task_runner, 1),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
         swapped(false) {}
 
   ~TestDisplayScheduler() override {}
 
   void DisplayResized() override { display_resized_ = true; }
 
-  void SetNewRootSurface(SurfaceId root_surface_id) override {
+  void SetNewRootSurface(const SurfaceId& root_surface_id) override {
     has_new_root_surface = true;
   }
 
-  void SurfaceDamaged(SurfaceId surface_id) override {
+  void SurfaceDamaged(const SurfaceId& surface_id) override {
     damaged = true;
     needs_draw_ = true;
   }
 
   void DidSwapBuffers() override { swapped = true; }
 
   void ResetDamageForTest() {
     damaged = false;
     display_resized_ = false;
     has_new_root_surface = false;
   }
 
   bool damaged;
   bool display_resized_;
   bool has_new_root_surface;
   bool swapped;
 };
 
 class DisplayTest : public testing::Test {
  public:
   DisplayTest()
       : factory_(&manager_, &surface_factory_client_),
-        id_allocator_(kArbitrarySurfaceNamespace),
+        id_allocator_(kArbitraryClientId),
         task_runner_(new base::NullTaskRunner) {
-    id_allocator_.RegisterSurfaceIdNamespace(&manager_);
+    id_allocator_.RegisterSurfaceClientId(&manager_);
   }
 
   void SetUpDisplay(const RendererSettings& settings,
                     std::unique_ptr<TestWebGraphicsContext3D> context) {
     std::unique_ptr<BeginFrameSource> begin_frame_source(
         new StubBeginFrameSource);
 
     std::unique_ptr<FakeOutputSurface> output_surface;
     if (context) {
       output_surface = FakeOutputSurface::Create3d(std::move(context));
     } else {
       std::unique_ptr<TestSoftwareOutputDevice> device(
           new TestSoftwareOutputDevice);
       software_output_device_ = device.get();
       output_surface = FakeOutputSurface::CreateSoftware(std::move(device));
     }
     output_surface_ = output_surface.get();
 
     std::unique_ptr<TestDisplayScheduler> scheduler(
         new TestDisplayScheduler(begin_frame_source.get(), task_runner_.get()));
     scheduler_ = scheduler.get();
 
     display_ = base::MakeUnique<Display>(
         &manager_, &shared_bitmap_manager_,
         nullptr /* gpu_memory_buffer_manager */, settings,
-        id_allocator_.id_namespace(), std::move(begin_frame_source),
+        id_allocator_.client_id(), std::move(begin_frame_source),
         std::move(output_surface), std::move(scheduler),
         base::MakeUnique<TextureMailboxDeleter>(task_runner_.get()));
   }
 
  protected:
-  void SubmitCompositorFrame(RenderPassList* pass_list, SurfaceId surface_id) {
+  void SubmitCompositorFrame(RenderPassList* pass_list,
+                             const SurfaceId& surface_id) {
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
     CompositorFrame frame;
     frame.delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
-  static constexpr int kArbitrarySurfaceNamespace = 3;
+  static constexpr int kArbitraryClientId = 3;
 
   SurfaceManager manager_;
   FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
   SurfaceIdAllocator id_allocator_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
   TestSharedBitmapManager shared_bitmap_manager_;
   std::unique_ptr<Display> display_;
   TestSoftwareOutputDevice* software_output_device_ = nullptr;
   FakeOutputSurface* output_surface_ = nullptr;
@@ skipping 331 matching lines @@
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
   display_->Resize(gfx::Size(250, 250));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   factory_.Destroy(surface_id);
 }
 
 }  // namespace
 }  // namespace cc