cc: Create ProxyBeginFrameSource

cc/trees/layer_tree_host_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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 2129 matching lines @@
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           NULL,
                                           settings,
                                           base::MessageLoopProxy::current(),
+                                          nullptr,
                                           nullptr);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
   settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           NULL,
                                           settings,
                                           base::MessageLoopProxy::current(),
+                                          nullptr,
                                           nullptr);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
   settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           NULL,
                                           settings,
                                           base::MessageLoopProxy::current(),
+                                          nullptr,
                                           nullptr);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(0u, host->MaxPartialTextureUpdates());
 }
 
 TEST(LayerTreeHostTest,
      PartialUpdatesWithDelegatingRendererAndSoftwareContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
   settings.single_thread_proxy_scheduler = false;
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHost> host =
       LayerTreeHost::CreateSingleThreaded(&client,
                                           &client,
                                           shared_bitmap_manager.get(),
                                           NULL,
                                           settings,
                                           base::MessageLoopProxy::current(),
+                                          nullptr,
                                           nullptr);
   client.SetLayerTreeHost(host.get());
   host->Composite(base::TimeTicks::Now());
 
   EXPECT_EQ(0u, host->MaxPartialTextureUpdates());
 }
 
 // TODO(sohanjg) : Remove it once impl-side painting ships everywhere.
 class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
     : public LayerTreeHostTest {
@@ skipping 3052 matching lines @@
   int num_draws_;
   const gfx::Size bounds_;
   FakeContentLayerClient client_;
   scoped_refptr<ContentLayerWithUpdateTracking> content_layer_;
   scoped_refptr<FakePictureLayer> picture_layer_;
   Layer* child_layer_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousPainting);
 
+class TestBeginFrameObserver : public BeginFrameObserverMixIn {
+ public:
+  TestBeginFrameObserver() {}
+  ~TestBeginFrameObserver() override {}
+
+ protected:
+  bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override {
+    return true;
+  }
+};
+
 class LayerTreeHostTestSendBeginFramesToChildren : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSendBeginFramesToChildren()
       : begin_frame_sent_to_children_(false) {
+    begin_frame_observer_.reset(new TestBeginFrameObserver);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->forward_begin_frames_to_children = true;
   }
 
   void BeginTest() override {
     // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_sent_to_children_ = true;
     EndTest();
   }
 
   void DidBeginMainFrame() override {
-    // Children requested BeginFrames.
-    layer_tree_host()->SetChildrenNeedBeginFrames(true);
+    // Add observer will trigger BeginFrame.
+    proxy_begin_frame_source()->AddObserver(begin_frame_observer_.get());
   }
 
   void AfterTest() override {
     // Ensure that BeginFrame message is sent to children during parent
     // scheduler handles its BeginFrame.
     EXPECT_TRUE(begin_frame_sent_to_children_);
+    proxy_begin_frame_source()->RemoveObserver(begin_frame_observer_.get());
   }
 
  private:
   bool begin_frame_sent_to_children_;
+  scoped_ptr<TestBeginFrameObserver> begin_frame_observer_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestSendBeginFramesToChildren);
 
 class LayerTreeHostTestSendBeginFramesToChildrenWithExternalBFS
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSendBeginFramesToChildrenWithExternalBFS()
       : begin_frame_sent_to_children_(false) {
+    begin_frame_observer_.reset(new TestBeginFrameObserver);
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->use_external_begin_frame_source = true;
     settings->forward_begin_frames_to_children = true;
   }
 
   void BeginTest() override {
     // Kick off the test with a commit.
     PostSetNeedsCommitToMainThread();
   }
 
   void SendBeginFramesToChildren(const BeginFrameArgs& args) override {
     begin_frame_sent_to_children_ = true;
     EndTest();
   }
 
   void DidBeginMainFrame() override {
-    // Children requested BeginFrames.
-    layer_tree_host()->SetChildrenNeedBeginFrames(true);
+    // Add observer will trigger BeginFrame.
+    proxy_begin_frame_source()->AddObserver(begin_frame_observer_.get());
   }
 
   void AfterTest() override {
     // Ensure that BeginFrame message is sent to children during parent
     // scheduler handles its BeginFrame.
     EXPECT_TRUE(begin_frame_sent_to_children_);
+    proxy_begin_frame_source()->RemoveObserver(begin_frame_observer_.get());
   }
 
  private:
   bool begin_frame_sent_to_children_;
+  scoped_ptr<TestBeginFrameObserver> begin_frame_observer_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestSendBeginFramesToChildrenWithExternalBFS);
 
 class LayerTreeHostTestActivateOnInvisible : public LayerTreeHostTest {
  public:
   LayerTreeHostTestActivateOnInvisible()
       : activation_count_(0), visible_(true) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
@@ skipping 800 matching lines @@
 
   void AfterTest() override { EXPECT_TRUE(did_commit_); }
 
  private:
   bool did_commit_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoTasksBetweenWillAndDidCommit);
 
 }  // namespace cc