cc: Create ProxyBeginFrameSource

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 33 matching lines @@
     statements;                   \
   }
 
 namespace cc {
 namespace {
 
 class FakeSchedulerClient : public SchedulerClient {
  public:
   FakeSchedulerClient()
       : automatic_swap_ack_(true),
-        begin_frame_is_sent_to_children_(false),
         scheduler_(nullptr) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
     states_.clear();
     draw_will_happen_ = true;
     swap_will_happen_if_draw_happens_ = true;
     num_draws_ = 0;
     log_anticipated_draw_time_change_ = false;
-    begin_frame_is_sent_to_children_ = false;
   }
 
   void set_scheduler(TestScheduler* scheduler) { scheduler_ = scheduler; }
-
   // Most tests don't care about DidAnticipatedDrawTimeChange, so only record it
   // for tests that do.
   void set_log_anticipated_draw_time_change(bool log) {
     log_anticipated_draw_time_change_ = log;
   }
   bool needs_begin_frames() {
     return scheduler_->frame_source().NeedsBeginFrames();
   }
   int num_draws() const { return num_draws_; }
   int num_actions_() const { return static_cast<int>(actions_.size()); }
@@ skipping 69 matching lines @@
   base::TimeDelta DrawDurationEstimate() override { return base::TimeDelta(); }
   base::TimeDelta BeginMainFrameToCommitDurationEstimate() override {
     return base::TimeDelta();
   }
   base::TimeDelta CommitToActivateDurationEstimate() override {
     return base::TimeDelta();
   }
 
   void DidBeginImplFrameDeadline() override {}
 
-  void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
-    begin_frame_is_sent_to_children_ = true;
-  }
-
   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_;
-  }
-
   void PushAction(const char* description) {
     actions_.push_back(description);
     states_.push_back(scheduler_->AsValue());
   }
 
  protected:
   bool ImplFrameDeadlinePendingCallback(bool state) {
     return scheduler_->BeginImplFrameDeadlinePending() == state;
   }
 
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   bool log_anticipated_draw_time_change_;
-  bool begin_frame_is_sent_to_children_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
   std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat>> states_;
   TestScheduler* scheduler_;
 };
 
+class FakeProxyBeginFrameSource : public ProxyBeginFrameSource {
+ public:
+  FakeProxyBeginFrameSource() : begin_frame_is_sent_to_children_(false) {}
+  ~FakeProxyBeginFrameSource() override {}
+
+  bool begin_frame_is_sent_to_children() {
+    return begin_frame_is_sent_to_children_;
+  }
+
+  void BeginFrames(const BeginFrameArgs& args) override {
+    begin_frame_is_sent_to_children_ = true;
+  }
+
+ private:
+  bool begin_frame_is_sent_to_children_;
+};
 class FakePowerMonitorSource : public base::PowerMonitorSource {
  public:
   FakePowerMonitorSource() {}
   ~FakePowerMonitorSource() override {}
   void GeneratePowerStateEvent(bool on_battery_power) {
     on_battery_power_impl_ = on_battery_power;
     ProcessPowerEvent(POWER_STATE_EVENT);
     base::MessageLoop::current()->RunUntilIdle();
   }
   bool IsOnBatteryPowerImpl() override { return on_battery_power_impl_; }
@@ skipping 43 matching lines @@
 
  protected:
   TestScheduler* CreateScheduler() {
     scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source;
     if (scheduler_settings_.use_external_begin_frame_source) {
       fake_external_begin_frame_source.reset(
           new FakeExternalBeginFrameSource(client_.get()));
       fake_external_begin_frame_source_ =
           fake_external_begin_frame_source.get();
     }
+
+    if (scheduler_settings_.forward_begin_frames_to_children) {
+      fake_proxy_begin_frame_source_.reset(new FakeProxyBeginFrameSource);
+    }
     scheduler_ = TestScheduler::Create(
         now_src_, client_.get(), scheduler_settings_, 0, task_runner_,
-        &power_monitor_, fake_external_begin_frame_source.Pass());
+        &power_monitor_, fake_external_begin_frame_source.Pass(),
+        fake_proxy_begin_frame_source_.get());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
     SetUpScheduler(make_scoped_ptr(new FakeSchedulerClient), initSurface);
   }
 
   void SetUpScheduler(scoped_ptr<FakeSchedulerClient> client,
                       bool initSurface) {
     client_ = client.Pass();
     if (initSurface)
       CreateSchedulerAndInitSurface();
     else
       CreateScheduler();
   }
 
+  bool begin_frame_is_sent_to_children() const {
+    return fake_proxy_begin_frame_source_->begin_frame_is_sent_to_children();
+  }
+
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
   TestNowSource* now_src() { return now_src_.get(); }
 
   // As this function contains EXPECT macros, to allow debugging it should be
   // called inside EXPECT_SCOPED like so;
   //   EXPECT_SCOPED(client.InitializeOutputSurfaceAndFirstCommit(scheduler));
   void InitializeOutputSurfaceAndFirstCommit() {
     TRACE_EVENT0("cc",
                  "SchedulerUnitTest::InitializeOutputSurfaceAndFirstCommit");
     DCHECK(scheduler_);
@@ skipping 107 matching lines @@
       bool throttle_frame_production);
   void DidLoseOutputSurfaceAfterBeginFrameStartedWithHighLatency(
       bool impl_side_painting);
   void DidLoseOutputSurfaceAfterReadyToCommit(bool impl_side_painting);
 
   scoped_refptr<TestNowSource> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
   FakePowerMonitorSource* fake_power_monitor_source_;
   base::PowerMonitor power_monitor_;
+  scoped_ptr<FakeProxyBeginFrameSource> fake_proxy_begin_frame_source_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
   scheduler_->SetCanStart();
   scheduler_->SetVisible(true);
   scheduler_->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_);
   client_->Reset();
   scheduler_->DidCreateAndInitializeOutputSurface();
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, SendBeginFramesToChildren) {
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.forward_begin_frames_to_children = true;
   SetUpScheduler(true);
 
-  EXPECT_FALSE(client_->begin_frame_is_sent_to_children());
+  EXPECT_FALSE(begin_frame_is_sent_to_children());
   scheduler_->SetNeedsCommit();
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
+  EXPECT_TRUE(begin_frame_is_sent_to_children());
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(client_->needs_begin_frames());
 }
 
 TEST_F(SchedulerTest, SendBeginFramesToChildrenWithoutCommit) {
   scheduler_settings_.use_external_begin_frame_source = true;
   scheduler_settings_.forward_begin_frames_to_children = true;
   SetUpScheduler(true);
 
   EXPECT_FALSE(client_->needs_begin_frames());
   scheduler_->SetChildrenNeedBeginFrames(true);
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
+  EXPECT_TRUE(begin_frame_is_sent_to_children());
 }
 
 TEST_F(SchedulerTest, RequestCommit) {
   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();
@@ skipping 1797 matching lines @@
   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);
 }
 
 }  // namespace
 }  // namespace cc