cc: Throttle swaps in Scheduler instead of OutputSurface

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 "cc/output/output_surface.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
@@ skipping 41 matching lines @@
   }
 
   void BeginImplFrameForTesting() {
     OutputSurface::BeginImplFrame(BeginFrameArgs::CreateExpiredForTesting());
   }
 
   void DidSwapBuffersForTesting() {
     DidSwapBuffers();
   }
 
-  int pending_swap_buffers() {
-    return pending_swap_buffers_;
-  }
-
   void OnSwapBuffersCompleteForTesting() {
     OnSwapBuffersComplete();
   }
 
   void EnableRetroactiveBeginImplFrameDeadline(
       bool enable,
       bool override_retroactive_period,
       base::TimeDelta period_override) {
     retroactive_begin_impl_frame_deadline_enabled_ = enable;
     override_retroactive_period_ = override_retroactive_period;
@@ skipping 150 matching lines @@
   EXPECT_FALSE(output_surface.HasClient());
 
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   EXPECT_TRUE(output_surface.HasClient());
   EXPECT_FALSE(client.deferred_initialize_called());
 
   // Initialize BeginImplFrame emulation
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
-  bool throttle_frame_production = true;
   const base::TimeDelta display_refresh_interval =
       BeginFrameArgs::DefaultInterval();
 
   output_surface.InitializeBeginImplFrameEmulation(
       task_runner.get(),
-      throttle_frame_production,
       display_refresh_interval);
 
-  output_surface.SetMaxFramesPending(2);
   output_surface.EnableRetroactiveBeginImplFrameDeadline(
       false, false, base::TimeDelta());
 
   // We should start off with 0 BeginImplFrames
   EXPECT_EQ(client.begin_impl_frame_count(), 0);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // We should not have a pending task until a BeginImplFrame has been
   // requested.
   EXPECT_FALSE(task_runner->HasPendingTask());
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_TRUE(task_runner->HasPendingTask());
 
   // BeginImplFrame should be called on the first tick.
   task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // BeginImplFrame should not be called when there is a pending BeginImplFrame.
   task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
-
   // SetNeedsBeginImplFrame should clear the pending BeginImplFrame after
   // a SwapBuffers.
   output_surface.DidSwapBuffersForTesting();
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
   task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_impl_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // BeginImplFrame should be throttled by pending swap buffers.
-  output_surface.DidSwapBuffersForTesting();
-  output_surface.SetNeedsBeginImplFrame(true);
-  EXPECT_EQ(client.begin_impl_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  task_runner->RunPendingTasks();
-  EXPECT_EQ(client.begin_impl_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-
-  // SwapAck should decrement pending swap buffers and unblock BeginImplFrame
-  // again.
-  output_surface.OnSwapBuffersCompleteForTesting();
-  EXPECT_EQ(client.begin_impl_frame_count(), 2);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-  task_runner->RunPendingTasks();
-  EXPECT_EQ(client.begin_impl_frame_count(), 3);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Calling SetNeedsBeginImplFrame again indicates a swap did not occur but
   // the client still wants another BeginImplFrame.
   output_surface.SetNeedsBeginImplFrame(true);
   task_runner->RunPendingTasks();
-  EXPECT_EQ(client.begin_impl_frame_count(), 4);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
+  EXPECT_EQ(client.begin_impl_frame_count(), 3);
 
   // Disabling SetNeedsBeginImplFrame should prevent further BeginImplFrames.
   output_surface.SetNeedsBeginImplFrame(false);
   task_runner->RunPendingTasks();
   EXPECT_FALSE(task_runner->HasPendingTask());
-  EXPECT_EQ(client.begin_impl_frame_count(), 4);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
+  EXPECT_EQ(client.begin_impl_frame_count(), 3);
 }
 
 TEST(OutputSurfaceTest, OptimisticAndRetroactiveBeginImplFrames) {
   TestOutputSurface output_surface(TestContextProvider::Create());
   EXPECT_FALSE(output_surface.HasClient());
 
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   EXPECT_TRUE(output_surface.HasClient());
   EXPECT_FALSE(client.deferred_initialize_called());
 
-  output_surface.SetMaxFramesPending(2);
   output_surface.EnableRetroactiveBeginImplFrameDeadline(
       true, false, base::TimeDelta());
 
   // Optimistically injected BeginImplFrames should be throttled if
   // SetNeedsBeginImplFrame is false...
   output_surface.SetNeedsBeginImplFrame(false);
   output_surface.BeginImplFrameForTesting();
   EXPECT_EQ(client.begin_impl_frame_count(), 0);
   // ...and retroactively triggered by a SetNeedsBeginImplFrame.
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
 
   // Optimistically injected BeginImplFrames should be throttled by pending
   // BeginImplFrames...
   output_surface.BeginImplFrameForTesting();
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
   // ...and retroactively triggered by a SetNeedsBeginImplFrame.
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_EQ(client.begin_impl_frame_count(), 2);
   // ...or retroactively triggered by a Swap.
   output_surface.BeginImplFrameForTesting();
   EXPECT_EQ(client.begin_impl_frame_count(), 2);
   output_surface.DidSwapBuffersForTesting();
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_EQ(client.begin_impl_frame_count(), 3);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-
-  // Optimistically injected BeginImplFrames should be by throttled by pending
-  // swap buffers...
-  output_surface.DidSwapBuffersForTesting();
-  output_surface.SetNeedsBeginImplFrame(true);
-  EXPECT_EQ(client.begin_impl_frame_count(), 3);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  output_surface.BeginImplFrameForTesting();
-  EXPECT_EQ(client.begin_impl_frame_count(), 3);
-  // ...and retroactively triggered by OnSwapBuffersComplete
-  output_surface.OnSwapBuffersCompleteForTesting();
-  EXPECT_EQ(client.begin_impl_frame_count(), 4);
 }
 
 TEST(OutputSurfaceTest,
      RetroactiveBeginImplFrameDoesNotDoubleTickWhenEmulating) {
   scoped_refptr<TestContextProvider> context_provider =
       TestContextProvider::Create();
 
   TestOutputSurface output_surface(context_provider);
   EXPECT_FALSE(output_surface.HasClient());
 
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   EXPECT_TRUE(output_surface.HasClient());
   EXPECT_FALSE(client.deferred_initialize_called());
 
   base::TimeDelta big_interval = base::TimeDelta::FromSeconds(10);
 
   // Initialize BeginImplFrame emulation
   scoped_refptr<base::TestSimpleTaskRunner> task_runner =
       new base::TestSimpleTaskRunner;
-  bool throttle_frame_production = true;
   const base::TimeDelta display_refresh_interval = big_interval;
 
   output_surface.InitializeBeginImplFrameEmulation(
       task_runner.get(),
-      throttle_frame_production,
       display_refresh_interval);
 
   // We need to subtract an epsilon from Now() because some platforms have
   // a slow clock.
   output_surface.CommitVSyncParametersForTesting(
       gfx::FrameTime::Now() - base::TimeDelta::FromSeconds(1), big_interval);
 
-  output_surface.SetMaxFramesPending(2);
   output_surface.EnableRetroactiveBeginImplFrameDeadline(
       true, true, big_interval);
 
   // We should start off with 0 BeginImplFrames
   EXPECT_EQ(client.begin_impl_frame_count(), 0);
-  EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // The first SetNeedsBeginImplFrame(true) should start a retroactive
   // BeginImplFrame.
   EXPECT_FALSE(task_runner->HasPendingTask());
   output_surface.SetNeedsBeginImplFrame(true);
   EXPECT_TRUE(task_runner->HasPendingTask());
   EXPECT_GT(task_runner->NextPendingTaskDelay(), big_interval / 2);
   EXPECT_EQ(client.begin_impl_frame_count(), 1);
 
   output_surface.SetNeedsBeginImplFrame(false);
@@ skipping 55 matching lines @@
   EXPECT_EQ(1, software_output_device->ensure_backbuffer_count());
   EXPECT_EQ(0, software_output_device->discard_backbuffer_count());
   output_surface.DiscardBackbuffer();
 
   EXPECT_EQ(1, software_output_device->ensure_backbuffer_count());
   EXPECT_EQ(1, software_output_device->discard_backbuffer_count());
 }
 
 }  // namespace
 }  // namespace cc