[cc] Add and use BeginFrameAck for DidFinishFrame.

cc/surfaces/display_scheduler_unittest.cc

 // Copyright 2015 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/surfaces/display_scheduler.h"
 
 #include "base/logging.h"
 #include "base/test/null_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 36 matching lines @@
                        int max_pending_swaps)
       : DisplayScheduler(task_runner, max_pending_swaps),
         scheduler_begin_frame_deadline_count_(0) {
     SetBeginFrameSource(begin_frame_source);
   }
 
   base::TimeTicks DesiredBeginFrameDeadlineTimeForTest() {
     return DesiredBeginFrameDeadlineTime();
   }
 
-  void BeginFrameDeadlineForTest() { OnBeginFrameDeadline(); }
+  void BeginFrameDeadlineForTest() {
+    // Ensure that any missed BeginFrames were handled by the scheduler. We need
+    // to run the scheduled task ourselves since the NullTaskRunner won't.
+    if (!missed_begin_frame_task_.IsCancelled())
+      missed_begin_frame_task_.callback().Run();
+    OnBeginFrameDeadline();
+  }
 
   void ScheduleBeginFrameDeadline() override {
     scheduler_begin_frame_deadline_count_++;
     DisplayScheduler::ScheduleBeginFrameDeadline();
   }
 
   int scheduler_begin_frame_deadline_count() {
     return scheduler_begin_frame_deadline_count_;
   }
 
+  bool inside_begin_frame_deadline_interval() {
+    return inside_begin_frame_deadline_interval_;
+  }
+
  protected:
   int scheduler_begin_frame_deadline_count_;
 };
 
 class DisplaySchedulerTest : public testing::Test {
  public:
   DisplaySchedulerTest()
       : fake_begin_frame_source_(0.f, false),
         task_runner_(new base::NullTaskRunner),
         scheduler_(&fake_begin_frame_source_,
                    task_runner_.get(),
                    kMaxPendingSwaps) {
     now_src_.Advance(base::TimeDelta::FromMicroseconds(10000));
     scheduler_.SetClient(&client_);
   }
 
   ~DisplaySchedulerTest() override {}
 
   void SetUp() override { scheduler_.SetRootSurfaceResourcesLocked(false); }
 
   void BeginFrameForTest() {
+    now_src_.Advance(base::TimeDelta::FromMicroseconds(10000));

[brianderson, 2017/01/03 19:30:16]

To help test readability, can you make it explicit from the call sites that this
method will advance time? Either change the name of this method to
AdvanceTimeAndBeginFrameForTest or manually advance the time before calling
BeginFrameForTest.

[Eric Seckler, 2017/01/04 10:14:49]

Done.

     base::TimeTicks frame_time = now_src_.NowTicks();
     base::TimeDelta interval = BeginFrameArgs::DefaultInterval();
     base::TimeTicks deadline = frame_time + interval;
     // FakeBeginFrameSource deals with |source_id| and |sequence_number|.
     fake_begin_frame_source_.TestOnBeginFrame(
         BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, 0, 1, frame_time, deadline,
                                interval, BeginFrameArgs::NORMAL));
   }
 
  protected:
@@ skipping 20 matching lines @@
 
   scheduler_.SetVisible(true);
 
   // Go trough an initial BeginFrame cycle with the root surface.
   BeginFrameForTest();
   scheduler_.SetNewRootSurface(root_surface_id1);
   scheduler_.BeginFrameDeadlineForTest();
 
   // Resize on the next begin frame cycle should cause the deadline to wait
   // for a new root surface.
+  BeginFrameForTest();
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.DisplayResized();
   EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SetNewRootSurface(root_surface_id2);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 
   // Verify deadline goes back to normal after resize.
@@ skipping 16 matching lines @@
 
   scheduler_.SetVisible(true);
 
   // Go trough an initial BeginFrame cycle with the root surface.
   BeginFrameForTest();
   scheduler_.SetNewRootSurface(root_surface_id);
   scheduler_.BeginFrameDeadlineForTest();
 
   // Resize on the next begin frame cycle should cause the deadline to wait
   // for a new root surface.
+  BeginFrameForTest();
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.DisplayResized();
   EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SurfaceDamaged(root_surface_id);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 
   // Verify deadline goes back to normal after resize.
+  BeginFrameForTest();
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SurfaceDamaged(root_surface_id);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 }
 
 TEST_F(DisplaySchedulerTest, SurfaceDamaged) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
@@ skipping 44 matching lines @@
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SurfaceDamaged(sid2);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 
   // Make the system idle
   BeginFrameForTest();
   scheduler_.BeginFrameDeadlineForTest();
   BeginFrameForTest();
-  scheduler_.BeginFrameDeadlineForTest();
+  EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval());
 
   // Deadline should trigger early if child surfaces are idle and
   // we get damage on the root surface.
   BeginFrameForTest();
-  EXPECT_LT(now_src().NowTicks(),
-            scheduler_.DesiredBeginFrameDeadlineTimeForTest());
+  EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval());
   scheduler_.SurfaceDamaged(root_surface_id);
   EXPECT_GE(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.BeginFrameDeadlineForTest();
 }
 
 TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
                             LocalFrameId(0, base::UnguessableToken::Create()));
   SurfaceId sid1(kArbitraryFrameSinkId,
@@ skipping 154 matching lines @@
   // DrawAndSwap normally.
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   EXPECT_EQ(0, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 
   // Deadline triggers late while root resources are locked.
+  BeginFrameForTest();
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SetRootSurfaceResourcesLocked(true);
   EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
 
   // Deadline does not DrawAndSwap while root resources are locked.
   EXPECT_EQ(1, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 
   //  Deadline triggers normally when root resources are unlocked.
+  BeginFrameForTest();
   late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   scheduler_.SetRootSurfaceResourcesLocked(false);
   scheduler_.SurfaceDamaged(root_surface_id);
   EXPECT_EQ(base::TimeTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
 
   EXPECT_EQ(1, client_.draw_and_swap_count());
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(2, client_.draw_and_swap_count());
@@ skipping 27 matching lines @@
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   EXPECT_EQ(2, client_.draw_and_swap_count());
   scheduler_.SurfaceDamaged(sid1);
   scheduler_.SurfaceDamaged(sid2);
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(3, client_.draw_and_swap_count());
   scheduler_.DidSwapBuffers();
 
   // Deadline triggers late when swap throttled.
+  BeginFrameForTest();
   base::TimeTicks late_deadline =
       now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
-  BeginFrameForTest();
   // Damage surface 1, but not surface 2 so we avoid triggering deadline
   // early because all surfaces are ready.
   scheduler_.SurfaceDamaged(sid1);
   EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
 
   // Don't draw and swap in deadline while swap throttled.
   EXPECT_EQ(3, client_.draw_and_swap_count());
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(3, client_.draw_and_swap_count());
 
   // Deadline triggers normally once not swap throttled.
   // Damage from previous BeginFrame should cary over, so don't damage again.
+  scheduler_.DidReceiveSwapBuffersAck();
+  BeginFrameForTest();
   base::TimeTicks expected_deadline =
       scheduler_.LastUsedBeginFrameArgs().deadline -
       BeginFrameArgs::DefaultEstimatedParentDrawTime();
-  scheduler_.DidReceiveSwapBuffersAck();
-  BeginFrameForTest();
   EXPECT_EQ(expected_deadline,
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
   // Still waiting for surface 2. Once it updates, deadline should trigger
   // immediately again.
   scheduler_.SurfaceDamaged(sid2);
   EXPECT_EQ(scheduler_.DesiredBeginFrameDeadlineTimeForTest(),
             base::TimeTicks());
   // Draw and swap now that we aren't throttled.
   EXPECT_EQ(3, client_.draw_and_swap_count());
   scheduler_.BeginFrameDeadlineForTest();
@@ skipping 52 matching lines @@
 
   scheduler_.SetRootSurfaceResourcesLocked(true);
   EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 
   scheduler_.OutputSurfaceLost();
   EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
 }
 
 }  // namespace
 }  // namespace cc