Revert of Revert "cc: Make scheduler run incoming frame after previous deadline."

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 <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 379 matching lines @@
   // called inside EXPECT_SCOPED like so;
   //   EXPECT_SCOPED(client.AdvanceFrame());
   void AdvanceFrame() {
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"),
                  "FakeSchedulerClient::AdvanceFrame");
 
     // Send the next BeginFrame message if using an external source, otherwise
     // it will be already in the task queue.
     if (scheduler_->begin_frame_source() ==
         fake_external_begin_frame_source_.get()) {
+      // Run pending task for previous deadline first.
+      task_runner_->RunPendingTasks();
       EXPECT_TRUE(scheduler_->begin_frames_expected());
       SendNextBeginFrame();
     } else {
+      // Begin frame might be queued up and posted after the previous deadline
+      // runs so run tasks until we get to the next frame.
       task_runner_->RunTasksWhile(client_->FrameHasNotAdvancedCallback());
     }
   }
 
   BeginFrameArgs SendNextBeginFrame() {
     DCHECK_EQ(scheduler_->begin_frame_source(),
               fake_external_begin_frame_source_.get());
     // Creep the time forward so that any BeginFrameArgs is not equal to the
     // last one otherwise we violate the BeginFrameSource contract.
     now_src_->Advance(BeginFrameArgs::DefaultInterval());
@@ skipping 3090 matching lines @@
   client_->Reset();
 
   SendNextBeginFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
   EXPECT_TRUE(client_->IsInsideBeginImplFrame());
   // Until tiles were prepared, further proactive BeginFrames are expected.
   EXPECT_TRUE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // Send the next BeginFrame before the previous one's deadline was executed.
-  // This should trigger the previous BeginFrame's deadline synchronously,
-  // during which tiles will be prepared. As a result of that, no further
-  // BeginFrames will be needed, and the new BeginFrame should be dropped.
+  // This will wait for the previous deadline after which no further BeginFrames
+  // will be needed, and the new BeginFrame should be dropped.
   BeginFrameArgs args = SendNextBeginFrame();
+
+  task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 0, 3);
   EXPECT_ACTION("RemoveObserver(this)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(client_->IsInsideBeginImplFrame());
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   client_->Reset();
 
   // Latest ack should be for the dropped BeginFrame. Since we don't have
   // further updates, its |latest_confirmed_sequence_number| should be for the
   // dropped BeginFrame, too.
@@ skipping 146 matching lines @@
   // |latest_confirmed_sequence_number| should be set to invalid.
   uint64_t latest_confirmed_sequence_number =
       BeginFrameArgs::kInvalidFrameNumber;
   bool has_damage = false;
   EXPECT_EQ(
       BeginFrameAck(args.source_id, args.sequence_number,
                     latest_confirmed_sequence_number, has_damage),
       fake_external_begin_frame_source_->LastAckForObserver(scheduler_.get()));
 }
 
+TEST_F(SchedulerTest, BeginFrameWhilePreviousDeadlinePending) {
+  SetUpScheduler(EXTERNAL_BFS);
+
+  scheduler_->SetNeedsRedraw();
+
+  client_->Reset();
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
+
+  // Do not run pending deadline but send a new begin frame. The begin frame is
+  // saved and run when the previous frame is over.
+  client_->Reset();
+  SendNextBeginFrame();
+  EXPECT_NO_ACTION(client_);
+
+  task_runner_->RunPendingTasks();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
+
+  // The saved begin frame is posted as a task.
+  client_->Reset();
+  task_runner_->RunPendingTasks();
+  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
+}
+
+TEST_F(SchedulerTest, IncomingBeginFrameReplacesSavedBeginFrame) {
+  SetUpScheduler(EXTERNAL_BFS);
+
+  scheduler_->SetNeedsRedraw();
+
+  client_->Reset();
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
+
+  // Send two BeginFrames while deadline is pending.
+  client_->Reset();
+  SendNextBeginFrame();
+  EXPECT_NO_ACTION(client_);
+
+  SendNextBeginFrame();
+  EXPECT_NO_ACTION(client_);
+
+  task_runner_->RunPendingTasks();
+  EXPECT_SINGLE_ACTION("ScheduledActionDrawIfPossible", client_);
+
+  // Only the last BeginFrame runs.
+  client_->Reset();
+  task_runner_->RunPendingTasks();
+  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
+
+  client_->Reset();
+  task_runner_->RunPendingTasks();
+  EXPECT_ACTION("RemoveObserver(this)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
+}
+
 }  // namespace
 }  // namespace cc