cc: Clean up max frames/swaps pending usage.

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 1453 matching lines @@
   fake_compositor_timing_history_->SetDrawDurationEstimate(slow_duration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 void SchedulerTest::ImplFrameSkippedAfterLateSwapAck(
     bool swap_ack_before_deadline) {
   // To get into a high latency state, this test disables automatic swap acks.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 4);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 4);
@@ skipping 103 matching lines @@
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_OnlyImplSideUpdatesExpected) {
   // This tests that we recover impl thread latency when there are no commits.
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // To get into a high latency state, this test disables automatic swap acks.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if there are no commits from
   // the main thread.
   auto slow_duration = base::TimeDelta::FromSeconds(1);
   fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
   auto fast_duration = base::TimeDelta::FromMilliseconds(1);
   fake_compositor_timing_history_->SetDrawDurationEstimate(fast_duration);
 
@@ skipping 43 matching lines @@
     // Deadline should be immediate.
     EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
     task_runner().RunUntilTime(now_src_->NowTicks());
     EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
     EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   }
 }
 
 void SchedulerTest::ImplFrameIsNotSkippedAfterLateSwapAck() {
   // To get into a high latency state, this test disables automatic swap acks.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
@@ skipping 90 matching lines @@
   // This test starts off with expensive estimates to prevent latency recovery
   // initially, then lowers the estimates to enable it once both the main
   // and impl threads are in a high latency mode.
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   auto slow_duration = base::TimeDelta::FromSeconds(1);
   fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
 
   // To get into a high latency state, this test disables automatic swap acks.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Impl thread hits deadline before commit finishes to make
   // MainThreadMissedLastDeadline true
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
@@ skipping 108 matching lines @@
     Deadlock_CommitMakesProgressWhileSwapTrottledAndActiveTreeNeedsFirstDraw) {
   // NPAPI plugins on Windows block the Browser UI thread on the Renderer main
   // thread. This prevents the scheduler from receiving any pending swap acks.
 
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   SetUpScheduler(true);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Get a new active tree in main-thread high latency mode and put us
   // in a swap throttled state.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
@@ skipping 50 matching lines @@
   // swap trottled and we have a pending tree and active tree that
   // still needs to be drawn for the first time.
 
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
   SetUpScheduler(true);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
@@ skipping 60 matching lines @@
 
   // Since we are simulating a long commit, set up a client with draw duration
   // estimates that prevent skipping main frames to get to low latency mode.
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.main_frame_while_swap_throttled_enabled = true;
   scheduler_settings_.main_frame_before_activation_enabled = true;
   SetUpScheduler(true);
 
   // Disables automatic swap acks so this test can force swap ack throttling
   // to simulate a blocked Browser ui thread.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Start a new commit in main-thread high latency mode and hold off on
   // activation.
   client_->Reset();
   EXPECT_FALSE(scheduler_->CommitPending());
   scheduler_->SetNeedsBeginMainFrame();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->CommitPending());
@@ skipping 375 matching lines @@
   scheduler_settings_.throttle_frame_production = throttle_frame_production;
   SetUpScheduler(true);
 
   scheduler_->SetEstimatedParentDrawTime(
       BeginFrameArgs::DefaultEstimatedParentDrawTime());
 
   // Set the draw duration estimate to zero so that deadlines are accurate.
   fake_compositor_timing_history_->SetDrawDurationEstimate(base::TimeDelta());
 
   // To test swap ack throttling, this test disables automatic swap acks.
-  scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_NO_ACTION(client_);
   client_->Reset();
 
   // Trigger the first BeginImplFrame and BeginMainFrame
   EXPECT_SCOPED(AdvanceFrame());
@@ skipping 1055 matching lines @@
 
   client_->Reset();
   EXPECT_FALSE(client_->last_begin_main_frame_args().IsValid());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->last_begin_main_frame_args().IsValid());
   EXPECT_FALSE(client_->last_begin_main_frame_args().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc