Hook up ui::Compositor to Display's BeginFrameSource

cc/surfaces/display_unittest.cc

Index: cc/surfaces/display_unittest.cc
diff --git a/cc/surfaces/display_unittest.cc b/cc/surfaces/display_unittest.cc
index cbc7e34e378d4d6cf74faf92fb87d72fabd91550..52bb317588643fb965a211a3257ff10c7d7de32a 100644
--- a/cc/surfaces/display_unittest.cc
+++ b/cc/surfaces/display_unittest.cc
@@ -93,7 +93,6 @@ class DisplayTest : public testing::Test {
   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_;
 };
@@ -103,8 +102,6 @@ class TestDisplayClient : public DisplayClient {
   TestDisplayClient() {}
   ~TestDisplayClient() override {}
 
-  void CommitVSyncParameters(base::TimeTicks timebase,
-                             base::TimeDelta interval) override {}
   void OutputSurfaceLost() override {}
   void SetMemoryPolicy(const ManagedMemoryPolicy& policy) override {}
 };
@@ -113,14 +110,12 @@ class TestDisplayScheduler : public DisplayScheduler {
  public:
   TestDisplayScheduler(DisplaySchedulerClient* client,
                        BeginFrameSource* begin_frame_source,
-                       base::NullTaskRunner* task_runner)
-      : DisplayScheduler(client, begin_frame_source, task_runner, 1),
+                       base::SingleThreadTaskRunner* task_runner)
+      : DisplayScheduler(client, begin_frame_source, task_runner, 1, settings_),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
-        swapped(false) {
-    begin_frame_source_for_children_.reset(new FakeBeginFrameSource);
-  }
+        swapped(false) {}
 
   ~TestDisplayScheduler() override {}
 
@@ -147,6 +142,35 @@ class TestDisplayScheduler : public DisplayScheduler {
   bool display_resized_;
   bool has_new_root_surface;
   bool swapped;
+
+ private:
+  RendererSettings settings_;
+};
+
+class TestDisplay : public Display {
+ public:
+  TestDisplay(DisplayClient* client,
+              SurfaceManager* manager,
+              SharedBitmapManager* bitmap_manager,
+              gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+              const RendererSettings& settings,
+              uint32_t compositor_surface_namespace)
+      : Display(client,
+                manager,
+                bitmap_manager,
+                gpu_memory_buffer_manager,
+                settings,
+                compositor_surface_namespace) {}
+
+  TestDisplayScheduler& scheduler() {
+    return *static_cast<TestDisplayScheduler*>(scheduler_.get());
+  }
+
+ protected:
+  void CreateScheduler(base::SingleThreadTaskRunner* task_runner) override {
+    scheduler_.reset(
+        new TestDisplayScheduler(this, vsync_begin_frame_source_, task_runner));
+  }
 };
 
 void CopyCallback(bool* called, scoped_ptr<CopyOutputResult> result) {
@@ -160,14 +184,14 @@ TEST_F(DisplayTest, DisplayDamaged) {
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
-  Display display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
-                  settings);
-
-  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
-                                 task_runner_.get());
-  display.Initialize(std::move(output_surface_), &scheduler);
-
-  SurfaceId surface_id(7u);
+  SurfaceIdAllocator allocator(3);

[sunnyps, 2016/03/28 23:09:48]

nit: Why 3? Can we abstract this into a method on the test class so that we
never have to remember what the next valid namespace is?

[enne (OOO), 2016/03/29 20:39:52]

It's an arbitrary number.  Put it in a constant to make this more obvious.

+  allocator.RegisterSurfaceIdNamespace(&manager_);
+  TestDisplay display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
+                      settings, allocator.id_namespace());
+  display.Initialize(std::move(output_surface_), task_runner_.get());
+  TestDisplayScheduler& scheduler = display.scheduler();
+
+  SurfaceId surface_id(allocator.GenerateId());
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.has_new_root_surface);
   display.SetSurfaceId(surface_id, 1.f);
@@ -422,18 +446,19 @@ TEST_F(DisplayTest, Finish) {
   SetUpContext(std::move(context));
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
+
+  SurfaceIdAllocator allocator(3);
+  allocator.RegisterSurfaceIdNamespace(&manager_);
+  SurfaceId surface_id(allocator.GenerateId());
+
   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);
-
-  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
-                                 task_runner_.get());
-  display.Initialize(std::move(output_surface_), &scheduler);
+  TestDisplay display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
+                      settings, surface_id.id_namespace());
+  display.Initialize(std::move(output_surface_), task_runner_.get());
 
-  SurfaceId surface_id(7u);
   display.SetSurfaceId(surface_id, 1.f);
 
   display.Resize(gfx::Size(100, 100));