Remove options to disable deadline scheduling

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"
 #include "base/memory/scoped_vector.h"
@@ skipping 188 matching lines @@
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
   EXPECT_EQ(0, client.num_actions_());
 }
 
-void RequestCommit(bool deadline_scheduling_enabled) {
+TEST(SchedulerTest, RequestCommit) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler);
 
   // SetNeedsCommit should begin the frame on the next BeginImplFrame.
   client.Reset();
   scheduler->SetNeedsCommit();
   EXPECT_TRUE(client.needs_begin_impl_frame());
-  if (deadline_scheduling_enabled) {
-    EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
-  } else {
-    EXPECT_EQ(client.num_actions_(), 2);
-    EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
-    EXPECT_TRUE(client.HasAction("SetNeedsBeginImplFrame"));
-  }
+  EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   client.Reset();
 
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
+  EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // If we don't swap on the deadline, we need to request another
   // BeginImplFrame.
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
@@ skipping 21 matching lines @@
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
   client.Reset();
 
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_FALSE(client.needs_begin_impl_frame());
   client.Reset();
 }
 
-TEST(SchedulerTest, RequestCommit) {
-  bool deadline_scheduling_enabled = false;
-  RequestCommit(deadline_scheduling_enabled);
-}
-
-TEST(SchedulerTest, RequestCommit_Deadline) {
-  bool deadline_scheduling_enabled = true;
-  RequestCommit(deadline_scheduling_enabled);
-}
-
-void RequestCommitAfterBeginMainFrameSent(
-    bool deadline_scheduling_enabled) {
+TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler);
   client.Reset();
 
   // SetNeedsCommit should begin the frame.
   scheduler->SetNeedsCommit();
-  if (deadline_scheduling_enabled) {
-    EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
-  } else {
-    EXPECT_EQ(client.num_actions_(), 2);
-    EXPECT_TRUE(client.HasAction("SetNeedsBeginImplFrame"));
-    EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
-  }
+  EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_EQ(client.num_actions_(), 2);
-    EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
-    EXPECT_TRUE(client.HasAction("PostBeginImplFrameDeadlineTask"));
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_EQ(client.num_actions_(), 2);
+  EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client.HasAction("PostBeginImplFrameDeadlineTask"));
 
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Now SetNeedsCommit again. Calling here means we need a second commit.
   scheduler->SetNeedsCommit();
   EXPECT_EQ(client.num_actions_(), 0);
   client.Reset();
 
   // Finish the first commit.
   scheduler->FinishCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
-  if (deadline_scheduling_enabled) {
-    EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
-    EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
-  } else {
-    EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3);
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 1, 3);
-    EXPECT_ACTION("SetNeedsBeginImplFrame", client, 2, 3);
-  }
+  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
+  EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
 
   // Because we just swapped, the Scheduler should also request the next
   // BeginImplFrame from the OutputSurface.
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Since another commit is needed, the next BeginImplFrame should initiate
   // the second commit.
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_EQ(client.num_actions_(), 2);
-    EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
-    EXPECT_TRUE(client.HasAction("PostBeginImplFrameDeadlineTask"));
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_EQ(client.num_actions_(), 2);
+  EXPECT_TRUE(client.HasAction("ScheduledActionSendBeginMainFrame"));
+  EXPECT_TRUE(client.HasAction("PostBeginImplFrameDeadlineTask"));
   client.Reset();
 
   // Finishing the commit before the deadline should post a new deadline task
   // to trigger the deadline early.
   scheduler->FinishCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // On the next BeginImplFrame, verify we go back to a quiescent state and
   // no longer request BeginImplFrames.
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_FALSE(client.needs_begin_impl_frame());
   client.Reset();
 }
 
-TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent) {
-  bool deadline_scheduling_enabled = false;
-  RequestCommitAfterBeginMainFrameSent(deadline_scheduling_enabled);
-}
-
-TEST(SchedulerTest, RequestCommitAfterBeginMainFrameSent_Deadline) {
-  bool deadline_scheduling_enabled = true;
-  RequestCommitAfterBeginMainFrameSent(deadline_scheduling_enabled);
-}
-
-void TextureAcquisitionCausesCommitInsteadOfDraw(
-    bool deadline_scheduling_enabled) {
+TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
 
   InitializeOutputSurfaceAndFirstCommit(scheduler);
   client.Reset();
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
@@ skipping 36 matching lines @@
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   client.Reset();
   scheduler->SetNeedsCommit();
-  if (deadline_scheduling_enabled) {
-    EXPECT_EQ(0, client.num_actions_());
-  } else {
-    EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client);
-  }
+  EXPECT_EQ(0, client.num_actions_());
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
+  EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
 
   // Commit will release the texture.
   client.Reset();
   scheduler->FinishCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(scheduler->RedrawPending());
 
   // Now we can draw again after the commit happens.
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   // Make sure we stop requesting BeginImplFrames if we don't swap.
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_FALSE(client.needs_begin_impl_frame());
 }
 
-TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw) {
-  bool deadline_scheduling_enabled = false;
-  TextureAcquisitionCausesCommitInsteadOfDraw(deadline_scheduling_enabled);
-}
-
-TEST(SchedulerTest, TextureAcquisitionCausesCommitInsteadOfDraw_Deadline) {
-  bool deadline_scheduling_enabled = true;
-  TextureAcquisitionCausesCommitInsteadOfDraw(deadline_scheduling_enabled);
-}
-
-void TextureAcquisitionCollision(bool deadline_scheduling_enabled) {
+TEST(SchedulerTest, TextureAcquisitionCollision) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   InitializeOutputSurfaceAndFirstCommit(scheduler);
 
   client.Reset();
   scheduler->SetNeedsCommit();
-if (deadline_scheduling_enabled) {
-    EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
-  } else {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
-  }
+  EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
 
   client.Reset();
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_SINGLE_ACTION(
       "ScheduledActionAcquireLayerTexturesForMainThread", client);
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
+  EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
 
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
 
   // Although the compositor cannot draw because textures are locked by main
   // thread, we continue requesting SetNeedsBeginImplFrame in anticipation of
   // the unlock.
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
@@ skipping 27 matching lines @@
   EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
   client.Reset();
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_FALSE(client.needs_begin_impl_frame());
 
   // The impl thread need an explicit commit from the main thread to lock
   // the textures.
   client.Reset();
   scheduler->SetNeedsCommit();
-  if (deadline_scheduling_enabled) {
-    EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
-  } else {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
-  }
+  EXPECT_SINGLE_ACTION("SetNeedsBeginImplFrame", client);
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-  if (deadline_scheduling_enabled) {
-    EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
-    EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
-  } else {
-    EXPECT_SINGLE_ACTION("PostBeginImplFrameDeadlineTask", client);
-  }
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
+  EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   client.Reset();
 
   // Trigger the commit, which will trigger the deadline task early.
   scheduler->FinishCommit();
   EXPECT_ACTION("ScheduledActionCommit", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 
   // Verify we draw on the next BeginImplFrame deadline
   scheduler->OnBeginImplFrameDeadline();
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginImplFrame", client, 1, 2);
   EXPECT_TRUE(client.needs_begin_impl_frame());
   client.Reset();
 }
 
-TEST(SchedulerTest, TextureAcquisitionCollision) {
-  bool deadline_scheduling_enabled = false;
-  TextureAcquisitionCollision(deadline_scheduling_enabled);
-}
-
-TEST(SchedulerTest, TextureAcquisitionCollision_Deadline) {
-  bool deadline_scheduling_enabled = true;
-  TextureAcquisitionCollision(deadline_scheduling_enabled);
-}
-
-void VisibilitySwitchWithTextureAcquisition(bool deadline_scheduling_enabled) {
+TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
   FakeSchedulerClient client;
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = deadline_scheduling_enabled;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
-  if (deadline_scheduling_enabled) {
-    scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
-    scheduler->OnBeginImplFrameDeadline();
-  }
+  scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
+  scheduler->OnBeginImplFrameDeadline();
   scheduler->FinishCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
   scheduler->SetNeedsCommit();
   client.Reset();
   // Verify that pending texture acquisition fires when visibility
   // is lost in order to avoid a deadlock.
   scheduler->SetVisible(false);
   EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                        client);
 
   client.Reset();
   scheduler->SetVisible(true);
   EXPECT_EQ(0, client.num_actions_());
   EXPECT_TRUE(client.needs_begin_impl_frame());
 
   // Regaining visibility with textures acquired by main thread while
   // compositor is waiting for first draw should result in a request
   // for a new frame in order to escape a deadlock.
   client.Reset();
   scheduler->BeginImplFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client, 0, 2);
   EXPECT_ACTION("PostBeginImplFrameDeadlineTask", client, 1, 2);
 }
 
-TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
-  bool deadline_scheduling_enabled = false;
-  VisibilitySwitchWithTextureAcquisition(deadline_scheduling_enabled);
-}
-
-TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition_Deadline) {
-  bool deadline_scheduling_enabled = true;
-  VisibilitySwitchWithTextureAcquisition(deadline_scheduling_enabled);
-}
-
 class SchedulerClientThatsetNeedsDrawInsideDraw : public FakeSchedulerClient {
  public:
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {}
   virtual DrawSwapReadbackResult ScheduledActionDrawAndSwapIfPossible()
       OVERRIDE {
     // Only SetNeedsRedraw the first time this is called
     if (!num_draws_)
       scheduler_->SetNeedsRedraw();
     return FakeSchedulerClient::ScheduledActionDrawAndSwapIfPossible();
   }
@@ skipping 539 matching lines @@
 void MainFrameInHighLatencyMode(int64 begin_main_frame_to_commit_estimate_in_ms,
                                 int64 commit_to_activate_estimate_in_ms,
                                 bool should_send_begin_main_frame) {
   // Set up client with specified estimates (draw duration is set to 1).
   SchedulerClientWithFixedEstimates client(
       base::TimeDelta::FromMilliseconds(1),
       base::TimeDelta::FromMilliseconds(
           begin_main_frame_to_commit_estimate_in_ms),
       base::TimeDelta::FromMilliseconds(commit_to_activate_estimate_in_ms));
   SchedulerSettings scheduler_settings;
-  scheduler_settings.deadline_scheduling_enabled = true;
   scheduler_settings.switch_to_low_latency_if_possible = true;
   Scheduler* scheduler = client.CreateScheduler(scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
   InitializeOutputSurfaceAndFirstCommit(scheduler);
 
   // Impl thread hits deadline before commit finishes.
   client.Reset();
   scheduler->SetNeedsCommit();
@@ skipping 85 matching lines @@
     SpinForMillis(interval * 2);
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 }
 
 }  // namespace
 }  // namespace cc