cc: Add SetNeedsOneBeginImplFrame to the Scheduler

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 40 matching lines @@
       : automatic_swap_ack_(true),
         scheduler_(nullptr) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     animate_causes_redraw_ = false;
     animate_causes_animate_ = false;
+    will_begin_impl_frame_requests_one_begin_impl_frame_ = false;
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
     begin_frame_args_sent_to_children_ = BeginFrameArgs();
   }
 
   void set_scheduler(TestScheduler* scheduler) { scheduler_ = scheduler; }
 
   bool needs_begin_frames() {
     return scheduler_->frame_source().NeedsBeginFrames();
@@ skipping 10 matching lines @@
     for (size_t i = 0; i < actions_.size(); i++)
       if (!strcmp(actions_[i], action))
         return base::checked_cast<int>(i);
     return -1;
   }
 
   bool HasAction(const char* action) const {
     return ActionIndex(action) >= 0;
   }
 
+  void SetWillBeginImplFrameRequestsOneBeginImplFrame(bool request) {
+    will_begin_impl_frame_requests_one_begin_impl_frame_ = request;
+  }
   void SetAnimateCausesRedraw(bool animate_causes_redraw) {
     animate_causes_redraw_ = animate_causes_redraw;
   }
   void SetAnimateCausesAnimate(bool animate_causes_animate) {
     animate_causes_animate_ = animate_causes_animate;
   }
   void SetDrawWillHappen(bool draw_will_happen) {
     draw_will_happen_ = draw_will_happen;
   }
   void SetSwapWillHappenIfDrawHappens(bool swap_will_happen_if_draw_happens) {
     swap_will_happen_if_draw_happens_ = swap_will_happen_if_draw_happens;
   }
   void SetAutomaticSwapAck(bool automatic_swap_ack) {
     automatic_swap_ack_ = automatic_swap_ack;
   }
   // SchedulerClient implementation.
   void WillBeginImplFrame(const BeginFrameArgs& args) override {
     PushAction("WillBeginImplFrame");
+    if (will_begin_impl_frame_requests_one_begin_impl_frame_)
+      scheduler_->SetNeedsOneBeginImplFrame();
   }
   void DidFinishImplFrame() override {}
 
   void ScheduledActionSendBeginMainFrame() override {
     PushAction("ScheduledActionSendBeginMainFrame");
   }
   void ScheduledActionAnimate() override {
     PushAction("ScheduledActionAnimate");
     if (animate_causes_redraw_)
       scheduler_->SetNeedsRedraw();
@@ skipping 66 matching lines @@
     states_.push_back(scheduler_->AsValue());
   }
 
  protected:
   bool ImplFrameDeadlinePendingCallback(bool state) {
     return scheduler_->BeginImplFrameDeadlinePending() == state;
   }
 
   bool animate_causes_redraw_;
   bool animate_causes_animate_;
+  bool will_begin_impl_frame_requests_one_begin_impl_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   BeginFrameArgs begin_frame_args_sent_to_children_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
@@ skipping 2953 matching lines @@
 
   // Idle on next vsync.
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 }
 
+TEST_F(SchedulerTest, SetNeedsOneBeginImplFrame) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+
+  EXPECT_FALSE(client_->needs_begin_frames());
+
+  // Request a frame, should kick the source.
+  scheduler_->SetNeedsOneBeginImplFrame();
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
+  client_->Reset();
+
+  // The incoming WillBeginImplFrame will request another one.
+  client_->SetWillBeginImplFrameRequestsOneBeginImplFrame(true);
+
+  // Next vsync, the first requested frame happens.
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
+  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
+  client_->Reset();
+
+  // We don't request another frame here.
+
+  // Next vsync, the second requested frame happens (the one requested inside
+  // the previous frame's begin impl frame step).
+  EXPECT_SCOPED(AdvanceFrame());
+  EXPECT_ACTION("WillBeginImplFrame", client_, 0, 1);
+  EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
+  client_->Reset();
+
+  // End that frame's deadline.
+  task_runner_->RunTasksWhile(client_->ImplFrameDeadlinePending(true));
+  EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
+
+  // Scheduler shuts down the source now that no begin frame is requested.
+  EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
+  EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
+}
+
 TEST_F(SchedulerTest, SynchronousCompositorCommit) {
   scheduler_settings_.using_synchronous_renderer_compositor = true;
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   client_->Reset();
 
   // Next vsync.
@@ skipping 281 matching lines @@
   scheduler_->SetImplLatencyTakesPriority(true);
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
   EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc