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

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 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/output/gl_renderer.h"
 
 #include <set>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 911 matching lines @@
   renderer.SetVisible(false);
   EXPECT_TRUE(context->last_call_was_set_visibility());
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   TextureStateTrackingContext() : active_texture_(GL_INVALID_ENUM) {
     test_capabilities_.gpu.egl_image_external = true;
   }
 
-  MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
+  MOCK_METHOD1(waitSyncPoint,
+               void(unsigned sync_point, const gpu::SyncToken& sync_token));
   MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
   MOCK_METHOD4(drawElements,
                void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));
 
   virtual void activeTexture(GLenum texture) {
     EXPECT_NE(texture, active_texture_);
     active_texture_ = texture;
   }
 
   GLenum active_texture() const { return active_texture_; }
@@ skipping 37 matching lines @@
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
 
   // Set up expected texture filter state transitions that match the quads
   // created in AppendOneOfEveryQuadType().
   Mock::VerifyAndClearExpectations(context);
   {
     InSequence sequence;
 
     // The sync points for all quads are waited on first. This sync point is
     // for a texture quad drawn later in the frame.
-    EXPECT_CALL(*context, waitSyncPoint(mailbox_sync_point)).Times(1);
+    EXPECT_CALL(*context, waitSyncPoint(mailbox_sync_point, gpu::SyncToken()))
+        .Times(1);
 
     // yuv_quad is drawn with the default linear filter.
     EXPECT_CALL(*context, drawElements(_, _, _, _));
 
     // tile_quad is drawn with GL_NEAREST because it is not transformed or
     // scaled.
     EXPECT_CALL(
         *context,
         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
     EXPECT_CALL(
@@ skipping 1133 matching lines @@
   void Initialize() override {
     strategies_.push_back(
         make_scoped_ptr(new OverlayStrategySingleOnTop(&validator_)));
   }
 
   SingleOverlayValidator validator_;
 };
 
 class WaitSyncPointCountingContext : public TestWebGraphicsContext3D {
  public:
-  MOCK_METHOD1(waitSyncPoint, void(unsigned sync_point));
+  MOCK_METHOD1(waitSyncPoint,
+               void(unsigned sync_point, const gpu::SyncToken& sync_Token));
 };
 
 class MockOverlayScheduler {
  public:
   MOCK_METHOD5(Schedule,
                void(int plane_z_order,
                     gfx::OverlayTransform plane_transform,
                     unsigned overlay_texture_id,
                     const gfx::Rect& display_bounds,
                     const gfx::RectF& uv_rect));
@@ skipping 58 matching lines @@
   SharedQuadState* shared_state = root_pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(), viewport_rect.size(), viewport_rect,
                        viewport_rect, false, 1, SkXfermode::kSrcOver_Mode, 0);
   overlay_quad->SetNew(shared_state, viewport_rect, viewport_rect,
                        viewport_rect, resource_id, premultiplied_alpha,
                        uv_top_left, uv_bottom_right, SK_ColorTRANSPARENT,
                        vertex_opacity, flipped, nearest_neighbor);
 
   // Verify that overlay_quad actually gets turned into an overlay, and even
   // though it's not drawn, that its sync point is waited on.
-  EXPECT_CALL(*context, waitSyncPoint(sync_point)).Times(1);
+  EXPECT_CALL(*context, waitSyncPoint(sync_point, gpu::SyncToken())).Times(1);
   EXPECT_CALL(overlay_scheduler,
               Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, viewport_rect,
                        BoundingRect(uv_top_left, uv_bottom_right))).Times(1);
 
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
 }
 
 }  // namespace
 }  // namespace cc