cc: Plumbing for BeginFrameSource based on Surfaces

cc/surfaces/display_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 "base/test/null_task_runner.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_factory_client.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::AnyNumber;
 
 namespace cc {
 namespace {
 
-class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
+class FakeSurfaceFactoryClient : public SurfaceFactoryClient {
  public:
+  FakeSurfaceFactoryClient() : begin_frame_source_(nullptr) {}
+
   void ReturnResources(const ReturnedResourceArray& resources) override {}
+
+  void SetBeginFrameSource(SurfaceId surface_id,
+                           BeginFrameSource* begin_frame_source) override {
+    begin_frame_source_ = begin_frame_source;
+  }
+
+  BeginFrameSource* begin_frame_source() { return begin_frame_source_; }
+
+ private:
+  BeginFrameSource* begin_frame_source_;
 };
 
 class TestSoftwareOutputDevice : public SoftwareOutputDevice {
  public:
   TestSoftwareOutputDevice() {}
 
   gfx::Rect damage_rect() const { return damage_rect_; }
   gfx::Size viewport_pixel_size() const { return viewport_pixel_size_; }
 };
 
 class DisplayTest : public testing::Test {
  public:
   DisplayTest()
-      : factory_(&manager_, &empty_client_),
+      : factory_(&manager_, &surface_factory_client_),
         software_output_device_(nullptr),
         task_runner_(new base::NullTaskRunner) {}
 
  protected:
   void SetUpContext(scoped_ptr<TestWebGraphicsContext3D> context) {
     if (context) {
       output_surface_ = FakeOutputSurface::Create3d(
           TestContextProvider::Create(context.Pass()));
     } else {
       scoped_ptr<TestSoftwareOutputDevice> output_device(
@@ skipping 10 matching lines @@
     pass_list->swap(frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
     frame->delegated_frame_data = frame_data.Pass();
 
     factory_.SubmitCompositorFrame(surface_id, frame.Pass(),
                                    SurfaceFactory::DrawCallback());
   }
 
   SurfaceManager manager_;
-  EmptySurfaceFactoryClient empty_client_;
+  FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
   TestSoftwareOutputDevice* software_output_device_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   FakeOutputSurface* output_surface_ptr_;
   FakeBeginFrameSource fake_begin_frame_source_;
   scoped_refptr<base::NullTaskRunner> task_runner_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
 };
 
 class TestDisplayClient : public DisplayClient {
  public:
   TestDisplayClient() {}
   ~TestDisplayClient() override {}
 
   void CommitVSyncParameters(base::TimeTicks timebase,
                              base::TimeDelta interval) override {}
   void OutputSurfaceLost() override {}
   void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {}
 };
 
 class TestDisplayScheduler : public DisplayScheduler {
  public:
   TestDisplayScheduler(DisplaySchedulerClient* client,
                        BeginFrameSource* begin_frame_source,
                        base::NullTaskRunner* task_runner)
       : DisplayScheduler(client, begin_frame_source, task_runner, 1),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
-        swapped(false) {}
+        swapped(false) {
+    begin_frame_source_for_children_.reset(new FakeBeginFrameSource);
+  }
 
   ~TestDisplayScheduler() override {}
 
   void DisplayResized() override { display_resized_ = true; }
 
   void SetNewRootSurface(SurfaceId root_surface_id) override {
     has_new_root_surface = true;
   }
 
   void SurfaceDamaged(SurfaceId surface_id) override {
@@ skipping 12 matching lines @@
   bool damaged;
   bool display_resized_;
   bool has_new_root_surface;
   bool swapped;
 };
 
 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) {
   *called = true;
 }
 
+// Verify Display responds to SurfaceAggregatorClient methods properly.
+TEST_F(DisplayTest, DisplayAsSurfaceAggregatorClient) {
+  SetUpContext(nullptr);
+  TestDisplayClient client;
+  RendererSettings settings;
+  Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
+                  settings);
+
+  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
+                                 task_runner_.get());
+  display.Initialize(output_surface_.Pass(), &scheduler);
+
+  SurfaceId surface_id(6);
+  factory_.Create(surface_id);
+  Surface* surface = manager_.GetSurfaceForId(surface_id);
+
+  EXPECT_EQ(nullptr, surface_factory_client_.begin_frame_source());
+  display.AddSurface(surface);
+  EXPECT_NE(nullptr, surface_factory_client_.begin_frame_source());
+  display.RemoveSurface(surface);
+  EXPECT_EQ(nullptr, surface_factory_client_.begin_frame_source());
+}
+
 // Check that frame is damaged and swapped only under correct conditions.
 TEST_F(DisplayTest, DisplayDamaged) {
   SetUpContext(nullptr);
   TestDisplayClient client;
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
   Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
                   settings);
 
@@ skipping 283 matching lines @@
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
   display.Resize(gfx::Size(250, 250));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   factory_.Destroy(surface_id);
 }
 
 }  // namespace
 }  // namespace cc