Update Surface ID Terminology

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/surface_aggregator.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 19 matching lines @@
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/test/surface_aggregator_test_helpers.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace cc {
 namespace {
 
+static constexpr uint32_t kArbitraryGpuId = 0;
+static constexpr uint32_t kArbitraryClientId = 0;
+
 SurfaceId InvalidSurfaceId() {
-  static SurfaceId invalid(0, 0xdeadbeef, 0);
+  static SurfaceId invalid(kArbitraryGpuId, kArbitraryClientId, 0xdeadbeef, 0);
   return invalid;
 }
 
 gfx::Size SurfaceSize() {
   static gfx::Size size(100, 100);
   return size;
 }
 
 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  public:
@@ skipping 20 matching lines @@
   SurfaceAggregatorTest() : SurfaceAggregatorTest(false) {}
 
  protected:
   SurfaceManager manager_;
   EmptySurfaceFactoryClient empty_client_;
   SurfaceFactory factory_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
-  SurfaceId one_id(0, 7, 0);
+  SurfaceId one_id(kArbitraryGpuId, kArbitraryClientId, 7, 0);
   factory_.Create(one_id);
 
   CompositorFrame frame = aggregator_.Aggregate(one_id);
   EXPECT_FALSE(frame.delegated_frame_data);
 
   factory_.Destroy(one_id);
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
  public:
   explicit SurfaceAggregatorValidSurfaceTest(bool use_damage_rect)
       : SurfaceAggregatorTest(use_damage_rect),
-        allocator_(1u),
-        child_allocator_(2u) {}
+        allocator_(kArbitraryGpuId, 1u),
+        child_allocator_(kArbitraryGpuId, 2u) {}
   SurfaceAggregatorValidSurfaceTest()
       : SurfaceAggregatorValidSurfaceTest(false) {}
 
   void SetUp() override {
     SurfaceAggregatorTest::SetUp();
     root_surface_id_ = allocator_.GenerateId();
     factory_.Create(root_surface_id_);
     root_surface_ = manager_.GetSurfaceForId(root_surface_id_);
   }
 
@@ skipping 24 matching lines @@
 
     EXPECT_EQ(expected_surface_count,
               aggregator_.previous_contained_surfaces().size());
     for (size_t i = 0; i < expected_surface_count; i++) {
       EXPECT_TRUE(
           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
           aggregator_.previous_contained_surfaces().end());
     }
   }
 
-  void SubmitPassListAsFrame(SurfaceId surface_id, RenderPassList* pass_list) {
+  void SubmitPassListAsFrame(const SurfaceId& surface_id,
+                             RenderPassList* pass_list) {
     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());
   }
 
   void SubmitCompositorFrame(test::Pass* passes,
                              size_t pass_count,
-                             SurfaceId surface_id) {
+                             const SurfaceId& surface_id) {
     RenderPassList pass_list;
     AddPasses(&pass_list, gfx::Rect(SurfaceSize()), passes, pass_count);
     SubmitPassListAsFrame(surface_id, &pass_list);
   }
 
   void QueuePassAsFrame(std::unique_ptr<RenderPass> pass,
-                        SurfaceId surface_id) {
+                        const SurfaceId& surface_id) {
     std::unique_ptr<DelegatedFrameData> delegated_frame_data(
         new DelegatedFrameData);
     delegated_frame_data->render_pass_list.push_back(std::move(pass));
 
     CompositorFrame child_frame;
     child_frame.delegated_frame_data = std::move(delegated_frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(child_frame),
                                    SurfaceFactory::DrawCallback());
   }
@@ skipping 1738 matching lines @@
   frame_data->render_pass_list.push_back(std::move(pass));
   CompositorFrame frame;
   frame.delegated_frame_data = std::move(frame_data);
   factory->SubmitCompositorFrame(surface_id, std::move(frame),
                                  SurfaceFactory::DrawCallback());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId surface_id(0, 7u, 0);
+  SurfaceId surface_id(kArbitraryGpuId, kArbitraryClientId, 7u, 0);
   factory.Create(surface_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface_id);
 
   CompositorFrame frame = aggregator_->Aggregate(surface_id);
 
   // Nothing should be available to be returned yet.
   EXPECT_TRUE(client.returned_resources().empty());
 
   SubmitCompositorFrameWithResources(NULL, 0u, true, SurfaceId(), &factory,
                                      surface_id);
 
   frame = aggregator_->Aggregate(surface_id);
 
   ASSERT_EQ(3u, client.returned_resources().size());
   ResourceId returned_ids[3];
   for (size_t i = 0; i < 3; ++i) {
     returned_ids[i] = client.returned_resources()[i].id;
   }
   EXPECT_THAT(returned_ids,
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   factory.Destroy(surface_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeInvalidResources) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId surface_id(0, 7u, 0);
+  SurfaceId surface_id(kArbitraryGpuId, kArbitraryClientId, 7u, 0);
   factory.Create(surface_id);
 
   std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   std::unique_ptr<RenderPass> pass = RenderPass::Create();
   pass->id = RenderPassId(1, 1);
   TransferableResource resource;
   resource.id = 11;
   // ResourceProvider is software but resource is not, so it should be
   // ignored.
   resource.is_software = false;
@@ skipping 13 matching lines @@
                                      surface_id);
   ASSERT_EQ(1u, client.returned_resources().size());
   EXPECT_EQ(11u, client.returned_resources()[0].id);
 
   factory.Destroy(surface_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TwoSurfaces) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId surface1_id(0, 7u, 0);
+  SurfaceId surface1_id(kArbitraryGpuId, kArbitraryClientId, 7u, 0);
   factory.Create(surface1_id);
 
-  SurfaceId surface2_id(0, 8u, 0);
+  SurfaceId surface2_id(kArbitraryGpuId, kArbitraryClientId, 8u, 0);
   factory.Create(surface2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
   ResourceId ids2[] = {14, 15, 16};
   SubmitCompositorFrameWithResources(ids2, arraysize(ids2), true, SurfaceId(),
                                      &factory, surface2_id);
 
   CompositorFrame frame = aggregator_->Aggregate(surface1_id);
@@ skipping 17 matching lines @@
   EXPECT_EQ(3u, resource_provider_->num_resources());
   factory.Destroy(surface1_id);
   factory.Destroy(surface2_id);
 }
 
 // Ensure that aggregator completely ignores Surfaces that reference invalid
 // resources.
 TEST_F(SurfaceAggregatorWithResourcesTest, InvalidChildSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId root_surface_id(0, 7u, 0);
+  SurfaceId root_surface_id(kArbitraryGpuId, kArbitraryClientId, 7u, 0);
   factory.Create(root_surface_id);
-  SurfaceId middle_surface_id(0, 8u, 0);
+  SurfaceId middle_surface_id(kArbitraryGpuId, kArbitraryClientId, 8u, 0);
   factory.Create(middle_surface_id);
-  SurfaceId child_surface_id(0, 9u, 0);
+  SurfaceId child_surface_id(kArbitraryGpuId, kArbitraryClientId, 9u, 0);
   factory.Create(child_surface_id);
 
   ResourceId ids[] = {14, 15, 16};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, child_surface_id);
 
   ResourceId ids2[] = {17, 18, 19};
   SubmitCompositorFrameWithResources(ids2, arraysize(ids2), false,
                                      child_surface_id, &factory,
                                      middle_surface_id);
@@ skipping 23 matching lines @@
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, SecureOutputTexture) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
-  SurfaceId surface1_id(0, 7u, 0);
+  SurfaceId surface1_id(kArbitraryGpuId, kArbitraryClientId, 7u, 0);
   factory.Create(surface1_id);
 
-  SurfaceId surface2_id(0, 8u, 0);
+  SurfaceId surface2_id(kArbitraryGpuId, kArbitraryClientId, 8u, 0);
   factory.Create(surface2_id);
 
   ResourceId ids[] = {11, 12, 13};
   SubmitCompositorFrameWithResources(ids, arraysize(ids), true, SurfaceId(),
                                      &factory, surface1_id);
 
   CompositorFrame frame = aggregator_->Aggregate(surface1_id);
 
   RenderPass* render_pass =
       frame.delegated_frame_data->render_pass_list.back().get();
@@ skipping 42 matching lines @@
   // Output is insecure, so texture should be drawn.
   EXPECT_EQ(DrawQuad::SOLID_COLOR, render_pass->quad_list.back()->material);
 
   factory.Destroy(surface1_id);
   factory.Destroy(surface2_id);
 }
 
 }  // namespace
 }  // namespace cc