Update Surface ID Terminology

cc/ipc/struct_traits_unittest.cc

 // Copyright 2016 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 "base/message_loop/message_loop.h"
 #include "cc/input/selection.h"
 #include "cc/ipc/traits_test_service.mojom.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 270 matching lines @@
   selection.end.set_visible(false);
   selection.end.set_type(gfx::SelectionBound::RIGHT);
   selection.is_editable = true;
   selection.is_empty_text_form_control = true;
   ui::LatencyInfo latency_info;
   latency_info.AddLatencyNumber(
       ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT, 1337, 7331);
   std::vector<ui::LatencyInfo> latency_infos = {latency_info};
   std::vector<uint32_t> satisfies_sequences = {1234, 1337};
   std::vector<SurfaceId> referenced_surfaces;
-  SurfaceId id(1234, 5678, 9101112);
+  SurfaceId id(2345, 1234, 5678, 9101112);
   referenced_surfaces.push_back(id);
 
   CompositorFrameMetadata input;
   input.device_scale_factor = device_scale_factor;
   input.root_scroll_offset = root_scroll_offset;
   input.page_scale_factor = page_scale_factor;
   input.scrollable_viewport_size = scrollable_viewport_size;
   input.root_layer_size = root_layer_size;
   input.min_page_scale_factor = min_page_scale_factor;
   input.max_page_scale_factor = max_page_scale_factor;
@@ skipping 123 matching lines @@
   debug_quad->SetNew(&sqs, rect1, rect1, color1, width1);
 
   const gfx::Rect rect2(2468, 8642, 4321, 1234);
   const uint32_t color2 = 0xffffffff;
   const bool force_anti_aliasing_off = true;
   SolidColorDrawQuad* solid_quad =
       input.AllocateAndConstruct<SolidColorDrawQuad>();
   solid_quad->SetNew(&sqs, rect2, rect2, color2, force_anti_aliasing_off);
 
   const gfx::Rect rect3(1029, 3847, 5610, 2938);
-  const SurfaceId surface_id(1234, 5678, 2468);
+  const SurfaceId surface_id(2345, 1234, 5678, 2468);
   SurfaceDrawQuad* surface_quad = input.AllocateAndConstruct<SurfaceDrawQuad>();
   surface_quad->SetNew(&sqs, rect3, rect3, surface_id);
 
   const gfx::Rect rect4(1234, 5678, 9101112, 13141516);
   const ResourceId resource_id4(1337);
   const RenderPassId render_pass_id(1234, 5678);
   const gfx::Vector2dF mask_uv_scale(1337.1f, 1234.2f);
   const gfx::Size mask_texture_size(1234, 5678);
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(0.f));
@@ skipping 149 matching lines @@
   SolidColorDrawQuad* color_quad =
       input->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   const gfx::Rect color_quad_rect(123, 456, 789, 101);
   color_quad->SetNew(shared_state_2, color_quad_rect, color_quad_rect,
                      SK_ColorRED, true);
 
   SurfaceDrawQuad* surface_quad =
       input->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   const gfx::Rect surface_quad_rect(1337, 2448, 1234, 5678);
   surface_quad->SetNew(shared_state_2, surface_quad_rect, surface_quad_rect,
-                       SurfaceId(1337, 1234, 2468));
+                       SurfaceId(1234, 1337, 1234, 2468));
 
   std::unique_ptr<RenderPass> output;
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   proxy->EchoRenderPass(input, &output);
 
   EXPECT_EQ(input->quad_list.size(), output->quad_list.size());
   EXPECT_EQ(input->shared_quad_state_list.size(),
             output->shared_quad_state_list.size());
   EXPECT_EQ(id, output->id);
   EXPECT_EQ(output_rect, output->output_rect);
@@ skipping 106 matching lines @@
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   Selection<gfx::SelectionBound> output;
   proxy->EchoSelection(input, &output);
   EXPECT_EQ(start, output.start);
   EXPECT_EQ(end, output.end);
   EXPECT_EQ(is_editable, output.is_editable);
   EXPECT_EQ(is_empty_text_form_control, output.is_empty_text_form_control);
 }
 
 TEST_F(StructTraitsTest, SurfaceId) {
-  const uint32_t id_namespace = 1337;
+  const uint32_t gpu_id = 1234;
+  const uint32_t client_id = 1337;
   const uint32_t local_id = 0xfbadbeef;
   const uint64_t nonce = 0xdeadbeef;
-  SurfaceId input(id_namespace, local_id, nonce);
+  SurfaceId input(gpu_id, client_id, local_id, nonce);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   SurfaceId output;
   proxy->EchoSurfaceId(input, &output);
-  EXPECT_EQ(id_namespace, output.id_namespace());
+  EXPECT_EQ(gpu_id, output.gpu_id());
+  EXPECT_EQ(client_id, output.client_id());
   EXPECT_EQ(local_id, output.local_id());
   EXPECT_EQ(nonce, output.nonce());
 }
 
 TEST_F(StructTraitsTest, SurfaceSequence) {
-  const uint32_t id_namespace = 2016;
+  const uint32_t client_id = 2016;
   const uint32_t sequence = 0xfbadbeef;
-  SurfaceSequence input(id_namespace, sequence);
+  SurfaceSequence input(client_id, sequence);
   mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
   SurfaceSequence output;
   proxy->EchoSurfaceSequence(input, &output);
-  EXPECT_EQ(id_namespace, output.id_namespace);
+  EXPECT_EQ(client_id, output.client_id);
   EXPECT_EQ(sequence, output.sequence);
 }
 
 TEST_F(StructTraitsTest, SharedQuadState) {
   const gfx::Transform quad_to_target_transform(1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
                                                 7.f, 8.f, 9.f, 10.f, 11.f, 12.f,
                                                 13.f, 14.f, 15.f, 16.f);
   const gfx::Size layer_bounds(1234, 5678);
   const gfx::Rect visible_layer_rect(12, 34, 56, 78);
   const gfx::Rect clip_rect(123, 456, 789, 101112);
@@ skipping 115 matching lines @@
   EXPECT_EQ(y_plane_resource_id, out_quad->y_plane_resource_id());
   EXPECT_EQ(u_plane_resource_id, out_quad->u_plane_resource_id());
   EXPECT_EQ(v_plane_resource_id, out_quad->v_plane_resource_id());
   EXPECT_EQ(a_plane_resource_id, out_quad->a_plane_resource_id());
   EXPECT_EQ(color_space, out_quad->color_space);
   EXPECT_EQ(resource_offset, out_quad->resource_offset);
   EXPECT_EQ(resource_multiplier, out_quad->resource_multiplier);
 }
 
 }  // namespace cc