Modified old wait sync point functions to also accept new sync tokens.

mojo/converters/surfaces/tests/surface_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/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/resource_provider.h"
@@ skipping 384 matching lines @@
   MailboxPtr mus_mailbox = Mailbox::New();
 
   gpu::Mailbox converted_mailbox = mus_mailbox.To<gpu::Mailbox>();
   EXPECT_TRUE(converted_mailbox.IsZero());
 }
 
 TEST(SurfaceLibTest, MailboxHolder) {
   gpu::Mailbox mailbox;
   mailbox.Generate();
   uint32_t texture_target = GL_TEXTURE_2D;
-  uint32_t sync_point = 7u;
-  gpu::MailboxHolder holder(mailbox, texture_target, sync_point);
+  gpu::SyncToken sync_token(7u);
+  gpu::MailboxHolder holder(mailbox, sync_token, texture_target);
 
   MailboxHolderPtr mus_holder = MailboxHolder::From(holder);
   EXPECT_EQ(texture_target, mus_holder->texture_target);
-  EXPECT_EQ(sync_point, mus_holder->sync_point);
+  EXPECT_EQ(sync_token, mus_holder->sync_token);
 
   gpu::MailboxHolder round_trip_holder = mus_holder.To<gpu::MailboxHolder>();
   EXPECT_EQ(mailbox, round_trip_holder.mailbox);
   EXPECT_EQ(texture_target, round_trip_holder.texture_target);
-  EXPECT_EQ(sync_point, round_trip_holder.sync_point);
+  EXPECT_EQ(sync_token, round_trip_holder.sync_token);
 }
 
 TEST(SurfaceLibTest, TransferableResource) {
   uint32_t id = 7u;
   cc::ResourceFormat format = cc::BGRA_8888;
   uint32_t filter = 123u;
   gfx::Size size(17, 18);
   gpu::MailboxHolder mailbox_holder;
   bool is_software = false;
   cc::TransferableResource resource;
@@ skipping 13 matching lines @@
 
   cc::TransferableResource round_trip_resource =
       mus_resource.To<cc::TransferableResource>();
   EXPECT_EQ(id, round_trip_resource.id);
   EXPECT_EQ(format, round_trip_resource.format);
   EXPECT_EQ(filter, round_trip_resource.filter);
   EXPECT_EQ(size, round_trip_resource.size);
   EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox);
   EXPECT_EQ(mailbox_holder.texture_target,
             round_trip_resource.mailbox_holder.texture_target);
-  EXPECT_EQ(mailbox_holder.sync_point,
-            round_trip_resource.mailbox_holder.sync_point);
+  EXPECT_EQ(mailbox_holder.sync_token,
+            round_trip_resource.mailbox_holder.sync_token);
   EXPECT_EQ(is_software, round_trip_resource.is_software);
 }
 
 TEST(SurfaceLibTest, ReturnedResource) {
   uint32_t id = 5u;
-  uint32_t sync_point = 24u;
+  gpu::SyncToken sync_token(24u);
   int count = 2;
   bool lost = false;
   cc::ReturnedResource resource;
   resource.id = id;
-  resource.sync_point = sync_point;
+  resource.sync_token = sync_token;
   resource.count = count;
   resource.lost = lost;
 
   ReturnedResourcePtr mus_resource = ReturnedResource::From(resource);
   EXPECT_EQ(id, mus_resource->id);
-  EXPECT_EQ(sync_point, mus_resource->sync_point);
+  EXPECT_EQ(sync_token, mus_resource->sync_token);
   EXPECT_EQ(count, mus_resource->count);
   EXPECT_EQ(lost, mus_resource->lost);
 
   cc::ReturnedResource round_trip_resource =
       mus_resource.To<cc::ReturnedResource>();
   EXPECT_EQ(id, round_trip_resource.id);
-  EXPECT_EQ(sync_point, round_trip_resource.sync_point);
+  EXPECT_EQ(sync_token, round_trip_resource.sync_token);
   EXPECT_EQ(count, round_trip_resource.count);
   EXPECT_EQ(lost, round_trip_resource.lost);
 }
 
 TEST_F(SurfaceLibQuadTest, DebugBorderQuad) {
   cc::DebugBorderDrawQuad* debug_border_quad =
       pass->CreateAndAppendDrawQuad<cc::DebugBorderDrawQuad>();
   const SkColor arbitrary_color = SK_ColorGREEN;
   const int width = 3;
   debug_border_quad->SetAll(sqs,
@@ skipping 14 matching lines @@
   ASSERT_TRUE(mus_quad->debug_border_quad_state);
   DebugBorderQuadStatePtr& mus_debug_border_state =
       mus_quad->debug_border_quad_state;
   EXPECT_TRUE(
       Color::From(arbitrary_color).Equals(mus_debug_border_state->color));
   EXPECT_EQ(width, mus_debug_border_state->width);
 }
 
 }  // namespace
 }  // namespace mojo