Update from https://crrev.com/317530

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 143 matching lines @@
   base::TimeDelta CommitToActivateDurationEstimate() override {
     return base::TimeDelta();
   }
 
   void DidBeginImplFrameDeadline() override {}
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_is_sent_to_children_ = true;
   }
 
+  void SendBeginMainFrameNotExpectedSoon() override {
+    PushAction("SendBeginMainFrameNotExpectedSoon");
+  }
+
   base::Callback<bool(void)> ImplFrameDeadlinePending(bool state) {
     return base::Bind(&FakeSchedulerClient::ImplFrameDeadlinePendingCallback,
                       base::Unretained(this),
                       state);
   }
 
   bool begin_frame_is_sent_to_children() const {
     return begin_frame_is_sent_to_children_;
   }
 
@@ skipping 336 matching lines @@
   client_->Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, RequestCommitAfterSetDeferCommit) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
@@ skipping 463 matching lines @@
   EXPECT_FALSE(scheduler_->PrepareTilesPending());
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 
   // We need a BeginImplFrame where we don't swap to go idle.
   client->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_EQ(0, client->num_draws());
 
   // Now trigger a PrepareTiles outside of a draw. We will then need
   // a begin-frame for the PrepareTiles, but we don't need a draw.
   client->Reset();
   EXPECT_FALSE(client->needs_begin_frames());
   scheduler_->SetNeedsPrepareTiles();
   EXPECT_TRUE(client->needs_begin_frames());
   EXPECT_TRUE(scheduler_->PrepareTilesPending());
@@ skipping 354 matching lines @@
   client_->Reset();
 
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
   task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, BeginRetroFrame_SwapThrottled) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetEstimatedParentDrawTime(base::TimeDelta::FromMicroseconds(1));
 
   // To test swap ack throttling, this test disables automatic swap acks.
@@ skipping 230 matching lines @@
   // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
   // to avoid excessive toggles.
   task_runner().RunPendingTasks();  // Run posted BeginFrame.
   EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 
   // Make sure SetNeedsBeginFrame isn't called on the client
   // when the BeginFrame is no longer needed.
   task_runner().RunPendingTasks();  // Run posted deadline.
-  EXPECT_NO_ACTION(client_);
+  EXPECT_SINGLE_ACTION("SendBeginMainFrameNotExpectedSoon", client_);
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SyntheticBeginFrames) {
   bool use_external_begin_frame_source = false;
   bool throttle_frame_production = true;
   BeginFramesNotFromClient(use_external_begin_frame_source,
                            throttle_frame_production);
 }
 
@@ skipping 135 matching lines @@
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   client_->Reset();
   scheduler_->DidLoseOutputSurface();
   // Do nothing when impl frame is in deadine pending state.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 1);
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
 }
@@ skipping 10 matching lines @@
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   client_->Reset();
   scheduler_->DidLoseOutputSurface();
   // Do nothing when impl frame is in deadine pending state.
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 
   client_->Reset();
   // Run posted deadline.
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   // OnBeginImplFrameDeadline didn't schedule any actions because main frame is
   // not yet completed.
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 
@@ skipping 46 matching lines @@
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
 
   client_->Reset();
   scheduler_->DidLoseOutputSurface();
   if (impl_side_painting) {
     // Sync tree should be forced to activate.
-    EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 0, 2);
-    EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 2);
+    EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 0, 3);
+    EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
+    EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   } else {
-    EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+    EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+    EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   }
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
 }
 
 TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterReadyToCommit) {
   DidLoseOutputSurfaceAfterReadyToCommit(false);
 }
@@ skipping 11 matching lines @@
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   client_->Reset();
   scheduler_->DidLoseOutputSurface();
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionPrepareTiles", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 1, 2);
 }
 
 TEST_F(SchedulerTest, DidLoseOutputSurfaceAfterBeginRetroFramePosted) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
@@ skipping 30 matching lines @@
   // NotifyReadyToCommit should trigger the commit.
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
   client_->Reset();
   EXPECT_FALSE(scheduler_->IsBeginRetroFrameArgsEmpty());
   scheduler_->DidLoseOutputSurface();
-  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 2);
-  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 2);
+  EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_TRUE(scheduler_->IsBeginRetroFrameArgsEmpty());
 
   // Posted BeginRetroFrame is aborted.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, DidLoseOutputSurfaceDuringBeginRetroFrameRunning) {
   scheduler_settings_.use_external_begin_frame_source = true;
@@ skipping 39 matching lines @@
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted BeginRetroFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client_->needs_begin_frames());
 
   client_->Reset();
   EXPECT_FALSE(scheduler_->IsBeginRetroFrameArgsEmpty());
   scheduler_->DidLoseOutputSurface();
-  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(false)", client_);
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_TRUE(scheduler_->IsBeginRetroFrameArgsEmpty());
 
   // BeginImplFrame deadline should abort drawing.
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_FALSE(client_->needs_begin_frames());
 
   // No more BeginRetroFrame because BeginRetroFrame queue is cleared.
@@ skipping 20 matching lines @@
 
   // NotifyReadyToCommit should trigger the commit.
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client_);
   EXPECT_TRUE(scheduler_->frame_source().NeedsBeginFrames());
 
   client_->Reset();
   scheduler_->DidLoseOutputSurface();
-  EXPECT_NO_ACTION(client_);
+  EXPECT_SINGLE_ACTION("SendBeginMainFrameNotExpectedSoon", client_);
   EXPECT_FALSE(scheduler_->frame_source().NeedsBeginFrames());
 
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
   EXPECT_FALSE(scheduler_->frame_source().NeedsBeginFrames());
 }
 
 TEST_F(SchedulerTest, ScheduledActionActivateAfterBecomingInvisible) {
   scheduler_settings_.impl_side_painting = true;
@@ skipping 257 matching lines @@
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client_->needs_begin_frames());
   client_->Reset();
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 0, 1);
 }
 
+// Tests to ensure that we send a BeginMainFrameNotExpectedSoon when expected.
+TEST_F(SchedulerTest, SendBeginMainFrameNotExpectedSoon) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+
+  // SetNeedsCommit should begin the frame on the next BeginImplFrame.
+  scheduler_->SetNeedsCommit();
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
+  client_->Reset();
+
+  // Trigger a frame draw.
+  EXPECT_SCOPED(AdvanceFrame());
+  scheduler_->NotifyBeginMainFrameStarted();
+  scheduler_->NotifyReadyToCommit();
+  task_runner().RunPendingTasks();
+  EXPECT_ACTION("WillBeginImplFrame", client_, 0, 5);
+  EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 5);
+  EXPECT_ACTION("ScheduledActionCommit", client_, 2, 5);
+  EXPECT_ACTION("ScheduledActionAnimate", client_, 3, 5);
+  EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 4, 5);
+  client_->Reset();
+
+  // The following BeginImplFrame deadline should SetNeedsBeginFrame(false)
+  // and send a SendBeginMainFrameNotExpectedSoon.
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
+  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
+  client_->Reset();
+
+  task_runner().RunPendingTasks();  // Run posted deadline.
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
+  client_->Reset();
+}
+
 }  // namespace
 }  // namespace cc