cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

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>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/test/begin_frame_args_test.h"
+#include "cc/test/fake_external_begin_frame_source.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_ACTION(action, client, action_index, expected_num_actions)  \
   do {                                                                     \
     EXPECT_EQ(expected_num_actions, client->num_actions_());               \
     if (action_index >= 0) {                                               \
       ASSERT_LT(action_index, client->num_actions_()) << scheduler_.get(); \
@@ skipping 162 matching lines @@
   bool automatic_swap_ack_;
   int num_draws_;
   BeginFrameArgs last_begin_main_frame_args_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<std::unique_ptr<base::trace_event::ConvertableToTraceFormat>>
       states_;
   TestScheduler* scheduler_;
 };
 
-class FakeExternalBeginFrameSource : public BeginFrameSourceBase {
+class BeginSourceToSchedulerClientProxy

[enne (OOO), 2016/06/15 19:46:56]

class BeginSourceToSchedulerClientProxy : public
FakeExternalBeginFrameSource::Client makes my head hurt.

Maybe at least Begin*Frame*Source, even though it's wordier or
SchedulerObserverTracker?

[danakj, 2016/06/15 20:35:56]

OK I made FakeSchedulerClient also be a FakeExternalBeginFrameSource::Client.

+    : public FakeExternalBeginFrameSource::Client {
  public:
-  explicit FakeExternalBeginFrameSource(FakeSchedulerClient* client)
+  explicit BeginSourceToSchedulerClientProxy(FakeSchedulerClient* client)
       : client_(client) {}
-  ~FakeExternalBeginFrameSource() override {}
 
-  void AddObserver(BeginFrameObserver* obs) override {
+  // FakeExternalBeginFrameSource::Client implementation.
+  void OnAddObserver(BeginFrameObserver* obs) override {
     client_->PushAction("AddObserver(this)");
-    BeginFrameSourceBase::AddObserver(obs);
+  }
+  void OnRemoveObserver(BeginFrameObserver* obs) override {
+    client_->PushAction("RemoveObserver(this)");
   }
 
-  void RemoveObserver(BeginFrameObserver* obs) override {
-    client_->PushAction("RemoveObserver(this)");
-    BeginFrameSourceBase::RemoveObserver(obs);
-  }
-
-  // TODO(sunnyps): Use using CallOnBeginFrame, SetBeginFrameSourcePaused.
-  void TestOnBeginFrame(const BeginFrameArgs& args) {
-    return CallOnBeginFrame(args);
-  }
-
-  void SetPaused(bool paused) { SetBeginFrameSourcePaused(paused); }
-
  private:
-  FakeSchedulerClient* client_;
+  FakeSchedulerClient* const client_;
 };
 
 class SchedulerTest : public testing::Test {
  public:
   SchedulerTest()
       : now_src_(new base::SimpleTestTickClock()),
         task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)),
         fake_external_begin_frame_source_(nullptr) {
     now_src_->Advance(base::TimeDelta::FromMicroseconds(10000));
     // A bunch of tests require NowTicks()
     // to be > BeginFrameArgs::DefaultInterval()
     now_src_->Advance(base::TimeDelta::FromMilliseconds(100));
     // Fail if we need to run 100 tasks in a row.
     task_runner_->SetRunTaskLimit(100);
   }
 
   ~SchedulerTest() override {}
 
  protected:
   TestScheduler* CreateScheduler() {
     BeginFrameSource* frame_source;
-    unthrottled_frame_source_.reset(
-        new TestBackToBackBeginFrameSource(now_src_.get(), task_runner_.get()));
+    unthrottled_frame_source_.reset(new BackToBackBeginFrameSource(
+        base::MakeUnique<TestDelayBasedTimeSource>(now_src_.get(),
+                                                   task_runner_.get())));
     fake_external_begin_frame_source_.reset(
-        new FakeExternalBeginFrameSource(client_.get()));
-    synthetic_frame_source_.reset(new TestSyntheticBeginFrameSource(
-        now_src_.get(), task_runner_.get(), BeginFrameArgs::DefaultInterval()));
+        new FakeExternalBeginFrameSource(0.f, false));
+    fake_external_begin_frame_source_->SetClient(client_proxy_.get());
+    synthetic_frame_source_.reset(new DelayBasedBeginFrameSource(
+        base::MakeUnique<TestDelayBasedTimeSource>(now_src_.get(),
+                                                   task_runner_.get())));
     if (!scheduler_settings_.throttle_frame_production) {
       frame_source = unthrottled_frame_source_.get();
     } else if (scheduler_settings_.use_external_begin_frame_source) {
       frame_source = fake_external_begin_frame_source_.get();
     } else {
       frame_source = synthetic_frame_source_.get();
     }
 
     std::unique_ptr<FakeCompositorTimingHistory>
         fake_compositor_timing_history = FakeCompositorTimingHistory::Create(
@@ skipping 18 matching lines @@
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
     SetUpScheduler(base::WrapUnique(new FakeSchedulerClient), initSurface);
   }
 
   void SetUpScheduler(std::unique_ptr<FakeSchedulerClient> client,
                       bool initSurface) {
     client_ = std::move(client);
+    client_proxy_.reset(new BeginSourceToSchedulerClientProxy(client_.get()));
     if (initSurface)
       CreateSchedulerAndInitSurface();
     else
       CreateScheduler();
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   base::SimpleTestTickClock* now_src() { return now_src_.get(); }
 
   // As this function contains EXPECT macros, to allow debugging it should be
@@ skipping 120 matching lines @@
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
   bool BeginMainFrameOnCriticalPath(TreePriority tree_priority,
                                     ScrollHandlerState scroll_handler_state,
                                     base::TimeDelta durations);
 
   std::unique_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   std::unique_ptr<FakeExternalBeginFrameSource>
       fake_external_begin_frame_source_;
-  std::unique_ptr<TestSyntheticBeginFrameSource> synthetic_frame_source_;
-  std::unique_ptr<TestBackToBackBeginFrameSource> unthrottled_frame_source_;
+  std::unique_ptr<SyntheticBeginFrameSource> synthetic_frame_source_;
+  std::unique_ptr<SyntheticBeginFrameSource> unthrottled_frame_source_;
   SchedulerSettings scheduler_settings_;
+  std::unique_ptr<BeginSourceToSchedulerClientProxy> client_proxy_;
   std::unique_ptr<FakeSchedulerClient> client_;
   std::unique_ptr<TestScheduler> scheduler_;
   FakeCompositorTimingHistory* fake_compositor_timing_history_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
@@ skipping 2317 matching lines @@
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_FALSE(scheduler_->begin_frames_expected());
 
   // No more BeginRetroFrame because BeginRetroFrame queue is cleared.
   client_->Reset();
   task_runner().RunPendingTasks();
   EXPECT_NO_ACTION(client_);
 }
 
-TEST_F(SchedulerTest, DidLoseOutputSurfaceWithSyntheticBeginFrameSource) {
+TEST_F(SchedulerTest, DidLoseOutputSurfaceWithDelayBasedBeginFrameSource) {
   SetUpScheduler(true);
 
   // SetNeedsBeginMainFrame should begin the frame on the next BeginImplFrame.
   EXPECT_FALSE(scheduler_->begin_frames_expected());
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->begin_frames_expected());
 
   client_->Reset();
   AdvanceFrame();
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
@@ skipping 912 matching lines @@
 }
 
 TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
   EXPECT_FALSE(BeginMainFrameOnCriticalPath(
       SMOOTHNESS_TAKES_PRIORITY,
       ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc