cc: Introduce BeginFrame sequence numbers and acknowledgements.

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/memory/ptr_util.h"
 #include "base/test/null_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/surfaces/display.h"
+#include "cc/surfaces/display_begin_frame_source.h"
 #include "cc/test/fake_external_begin_frame_source.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 const int kMaxPendingSwaps = 1;
 
 static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
@@ skipping 10 matching lines @@
   }
 
   void Reset() { draw_and_swap_count_ = 0; }
 
   int draw_and_swap_count() const { return draw_and_swap_count_; }
 
  protected:
   int draw_and_swap_count_;
 };
 
+// TODO(eseckler): Test with a mocked DisplayBeginFrameSource.
+// TODO(eseckler): Replace/add tests around expected child damage.
+// TODO(eseckler): Add tests for DisplayBeginFrameSource (elsewhere).
+
 class TestDisplayScheduler : public DisplayScheduler {
  public:
-  TestDisplayScheduler(BeginFrameSource* begin_frame_source,
+  TestDisplayScheduler(DisplayBeginFrameSource* begin_frame_source,
                        base::SingleThreadTaskRunner* task_runner,
                        int max_pending_swaps)
-      : DisplayScheduler(begin_frame_source, task_runner, max_pending_swaps),
-        scheduler_begin_frame_deadline_count_(0) {}
+      : 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 ScheduleBeginFrameDeadline() override {
     scheduler_begin_frame_deadline_count_++;
     DisplayScheduler::ScheduleBeginFrameDeadline();
   }
 
   int scheduler_begin_frame_deadline_count() {
     return scheduler_begin_frame_deadline_count_;
   }
 
  protected:
   int scheduler_begin_frame_deadline_count_;
 };
 
+// TODO(eseckler): Update all these tests. Consider mocking out DisplayBFS and
+// testing it separately?
 class DisplaySchedulerTest : public testing::Test {
  public:
   DisplaySchedulerTest()
-      : fake_begin_frame_source_(0.f, false),
+      : display_begin_frame_source_(nullptr),
+        next_begin_frame_number_(BeginFrameArgs::kStartingFrameNumber),
         task_runner_(new base::NullTaskRunner),
-        scheduler_(&fake_begin_frame_source_,
+        scheduler_(&display_begin_frame_source_,
                    task_runner_.get(),
                    kMaxPendingSwaps) {
+    std::unique_ptr<BeginFrameSource> fake_begin_frame_source =
+        base::MakeUnique<FakeExternalBeginFrameSource>(0.f, false);
+    fake_begin_frame_source_ = static_cast<FakeExternalBeginFrameSource*>(
+        fake_begin_frame_source.get());
+    display_begin_frame_source_.SwapWrappedSource(&fake_begin_frame_source);
     now_src_.Advance(base::TimeDelta::FromMicroseconds(10000));
     scheduler_.SetClient(&client_);
   }
 
   ~DisplaySchedulerTest() override {}
 
   void SetUp() override { scheduler_.SetRootSurfaceResourcesLocked(false); }
 
   void BeginFrameForTest() {
     base::TimeTicks frame_time = now_src_.NowTicks();
     base::TimeDelta interval = BeginFrameArgs::DefaultInterval();
     base::TimeTicks deadline = frame_time + interval;
-    fake_begin_frame_source_.TestOnBeginFrame(
-        BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
-                               interval, BeginFrameArgs::NORMAL));
+    fake_begin_frame_source_->TestOnBeginFrame(BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, fake_begin_frame_source_->source_id(),
+        next_begin_frame_number_++, frame_time, deadline, interval,
+        BeginFrameArgs::NORMAL));
   }
 
  protected:
   base::SimpleTestTickClock& now_src() { return now_src_; }
   FakeDisplaySchedulerClient& client() { return client_; }
   DisplayScheduler& scheduler() { return scheduler_; }
 
-  FakeExternalBeginFrameSource fake_begin_frame_source_;
+  FakeExternalBeginFrameSource* fake_begin_frame_source_;  // Not owned.
+  DisplayBeginFrameSource display_begin_frame_source_;
+  uint64_t next_begin_frame_number_;
 
   base::SimpleTestTickClock now_src_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
   FakeDisplaySchedulerClient client_;
   TestDisplayScheduler scheduler_;
 };
 
 TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilNewRootSurface) {
   SurfaceId root_surface_id1(kArbitraryFrameSinkId,
                              LocalFrameId(1, base::UnguessableToken::Create()));
@@ skipping 175 matching lines @@
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
 }
 
 TEST_F(DisplaySchedulerTest, VisibleWithoutDamageNoTicks) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
                             LocalFrameId(0, base::UnguessableToken::Create()));
   SurfaceId sid1(kArbitraryFrameSinkId,
                  LocalFrameId(1, base::UnguessableToken::Create()));
 
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
   scheduler_.SetVisible(true);
 
   // When becoming visible, don't start listening for begin frames until there
   // is some damage.
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
   scheduler_.SetNewRootSurface(root_surface_id);
 
-  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(1u, fake_begin_frame_source_->num_observers());
 }
 
 TEST_F(DisplaySchedulerTest, VisibleWithDamageTicks) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
                             LocalFrameId(0, base::UnguessableToken::Create()));
   SurfaceId sid1(kArbitraryFrameSinkId,
                  LocalFrameId(1, base::UnguessableToken::Create()));
 
   scheduler_.SetNewRootSurface(root_surface_id);
 
   // When there is damage, start listening for begin frames once becoming
   // visible.
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
   scheduler_.SetVisible(true);
 
-  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(1u, fake_begin_frame_source_->num_observers());
 }
 
 TEST_F(DisplaySchedulerTest, Visibility) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
                             LocalFrameId(0, base::UnguessableToken::Create()));
   SurfaceId sid1(kArbitraryFrameSinkId,
                  LocalFrameId(1, base::UnguessableToken::Create()));
 
   scheduler_.SetNewRootSurface(root_surface_id);
   scheduler_.SetVisible(true);
-  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(1u, fake_begin_frame_source_->num_observers());
 
   // 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());
 
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_.DesiredBeginFrameDeadlineTimeForTest());
 
   // Become not visible.
   scheduler_.SetVisible(false);
 
   // It will stop listening for begin frames after the current deadline.
-  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(1u, fake_begin_frame_source_->num_observers());
 
   // Deadline does not DrawAndSwap when not visible.
   EXPECT_EQ(1, client_.draw_and_swap_count());
   scheduler_.BeginFrameDeadlineForTest();
   EXPECT_EQ(1, client_.draw_and_swap_count());
   // Now it stops listening for begin frames.
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
 
   // Does not start listening for begin frames when becoming visible without
   // damage.
   scheduler_.SetVisible(true);
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
   scheduler_.SetVisible(false);
 
   // Does not start listening for begin frames when damage arrives.
   scheduler_.SurfaceDamaged(sid1);
-  EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(0u, fake_begin_frame_source_->num_observers());
 
   // But does when becoming visible with damage again.
   scheduler_.SetVisible(true);
-  EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
+  EXPECT_EQ(1u, fake_begin_frame_source_->num_observers());
 }
 
 TEST_F(DisplaySchedulerTest, ResizeCausesSwap) {
   SurfaceId root_surface_id(kArbitraryFrameSinkId,
                             LocalFrameId(0, base::UnguessableToken::Create()));
   SurfaceId sid1(kArbitraryFrameSinkId,
                  LocalFrameId(1, base::UnguessableToken::Create()));
 
   scheduler_.SetVisible(true);
 
@@ skipping 186 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