cc: Add BeginFrameArgs

cc/output/output_surface_unittest.cc

 // Copyright 2013 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/test/test_simple_task_runner.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
@@ skipping 24 matching lines @@
 
   bool HasClientForTesting() {
     return HasClient();
   }
 
   void OnVSyncParametersChangedForTesting(base::TimeTicks timebase,
                                           base::TimeDelta interval) {
     OnVSyncParametersChanged(timebase, interval);
   }
 
-  void BeginFrameForTesting(base::TimeTicks frame_time) {
-    BeginFrame(frame_time);
+  void BeginFrameForTesting() {
+    BeginFrame(BeginFrameArgs::CreateForTesting());
   }
 
   void DidSwapBuffersForTesting() {
     DidSwapBuffers();
   }
 
   int pending_swap_buffers() {
     return pending_swap_buffers_;
   }
 
   void OnSwapBuffersCompleteForTesting() {
     OnSwapBuffersComplete(NULL);
   }
 };
 
 class FakeOutputSurfaceClient : public OutputSurfaceClient {
  public:
   FakeOutputSurfaceClient()
       : begin_frame_count_(0),
         deferred_initialize_result_(true),
         deferred_initialize_called_(false),
         did_lose_output_surface_called_(false) {}
 
   virtual bool DeferredInitialize(
       scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
     deferred_initialize_called_ = true;
     return deferred_initialize_result_;
   }
   virtual void SetNeedsRedrawRect(gfx::Rect damage_rect) OVERRIDE {}
-  virtual void BeginFrame(base::TimeTicks frame_time) OVERRIDE {
+  virtual void BeginFrame(const BeginFrameArgs& args) OVERRIDE {
     begin_frame_count_++;
   }
   virtual void OnSwapBuffersComplete(const CompositorFrameAck* ack) OVERRIDE {}
   virtual void DidLoseOutputSurface() OVERRIDE {
     did_lose_output_surface_called_ = true;
   }
   virtual void SetExternalDrawConstraints(const gfx::Transform& transform,
                                           gfx::Rect viewport) OVERRIDE {}
 
   int begin_frame_count() {
@@ skipping 119 matching lines @@
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   EXPECT_TRUE(output_surface.HasClientForTesting());
   EXPECT_FALSE(client.deferred_initialize_called());
 
   // Initialize BeginFrame emulation
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
   bool throttle_frame_production = true;
   const base::TimeDelta display_refresh_interval =
-      base::TimeDelta::FromMicroseconds(16666);
+      BeginFrameArgs::DefaultInterval();
 
   output_surface.InitializeBeginFrameEmulation(
       task_runner.get(),
       throttle_frame_production,
       display_refresh_interval);
 
   output_surface.SetMaxFramesPending(2);
 
   // We should start off with 0 BeginFrames
   EXPECT_EQ(client.begin_frame_count(), 0);
@@ skipping 47 matching lines @@
 
   // Disabling SetNeedsBeginFrame should prevent further BeginFrames.
   output_surface.SetNeedsBeginFrame(false);
   task_runner->RunPendingTasks();
   EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_EQ(client.begin_frame_count(), 4);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should be
   // allowed.
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
+  output_surface.BeginFrameForTesting();
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
   // still be throttled by pending begin frames however.
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
+  output_surface.BeginFrameForTesting();
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
   // also be throttled by pending swap buffers.
   output_surface.DidSwapBuffersForTesting();
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  output_surface.BeginFrameForTesting(base::TimeTicks::Now());
+  output_surface.BeginFrameForTesting();
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
 }
 
 }  // namespace
 }  // namespace cc