Hook up ui::Compositor to Display's BeginFrameSource

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 "cc/surfaces/display.h"
 
 #include <utility>
 
 #include "base/test/null_task_runner.h"
 #include "cc/output/compositor_frame.h"
@@ skipping 39 matching lines @@
   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_, &surface_factory_client_),
+        id_allocator_(kArbitrarySurfaceNamespace),
         software_output_device_(nullptr),
-        task_runner_(new base::NullTaskRunner) {}
+        task_runner_(new base::NullTaskRunner) {
+    id_allocator_.RegisterSurfaceIdNamespace(&manager_);
+  }
 
  protected:
   void SetUpContext(scoped_ptr<TestWebGraphicsContext3D> context) {
     if (context) {
       output_surface_ = FakeOutputSurface::Create3d(
           TestContextProvider::Create(std::move(context)));
     } else {
       scoped_ptr<TestSoftwareOutputDevice> output_device(
           new TestSoftwareOutputDevice);
       software_output_device_ = output_device.get();
       output_surface_ =
           FakeOutputSurface::CreateSoftware(std::move(output_device));
     }
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     output_surface_ptr_ = output_surface_.get();
   }
 
   void SubmitCompositorFrame(RenderPassList* pass_list, SurfaceId surface_id) {
     scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list->swap(frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> frame(new CompositorFrame);
     frame->delegated_frame_data = std::move(frame_data);
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
   }
 
+  enum { kArbitrarySurfaceNamespace = 3 };
+
   SurfaceManager manager_;
   FakeSurfaceFactoryClient surface_factory_client_;
   SurfaceFactory factory_;
+  SurfaceIdAllocator id_allocator_;
   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)
+                       base::SingleThreadTaskRunner* task_runner)
       : DisplayScheduler(client, begin_frame_source, task_runner, 1),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
-        swapped(false) {
-    begin_frame_source_for_children_.reset(new FakeBeginFrameSource);
-  }
+        swapped(false) {}
 
   ~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 {
     damaged = true;
     needs_draw_ = true;
   }
 
   void DidSwapBuffers() override { swapped = true; }
 
   void ResetDamageForTest() {
     damaged = false;
     display_resized_ = false;
     has_new_root_surface = false;
   }
 
   bool damaged;
   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) {
   *called = true;
 }
 
 // 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);
+  TestDisplay display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
+                      settings, id_allocator_.id_namespace());
+  display.Initialize(std::move(output_surface_), task_runner_.get());
+  TestDisplayScheduler& scheduler = display.scheduler();
 
-  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
-                                 task_runner_.get());
-  display.Initialize(std::move(output_surface_), &scheduler);
-
-  SurfaceId surface_id(7u);
+  SurfaceId surface_id(id_allocator_.GenerateId());
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.has_new_root_surface);
   display.SetSurfaceId(surface_id, 1.f);
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.display_resized_);
   EXPECT_TRUE(scheduler.has_new_root_surface);
 
   scheduler.ResetDamageForTest();
   display.Resize(gfx::Size(100, 100));
   EXPECT_FALSE(scheduler.damaged);
@@ skipping 234 matching lines @@
  public:
   MOCK_METHOD0(shallowFinishCHROMIUM, void());
 };
 
 TEST_F(DisplayTest, Finish) {
   scoped_ptr<MockedContext> context(new MockedContext());
   MockedContext* context_ptr = context.get();
   SetUpContext(std::move(context));
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
+
+  SurfaceId surface_id(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);
+  TestDisplay display(&client, &manager_, shared_bitmap_manager_.get(), nullptr,
+                      settings, surface_id.id_namespace());
+  display.Initialize(std::move(output_surface_), task_runner_.get());
 
-  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
-                                 task_runner_.get());
-  display.Initialize(std::move(output_surface_), &scheduler);
-
-  SurfaceId surface_id(7u);
   display.SetSurfaceId(surface_id, 1.f);
 
   display.Resize(gfx::Size(100, 100));
   factory_.Create(surface_id);
 
   {
     RenderPassList pass_list;
     scoped_ptr<RenderPass> pass = RenderPass::Create();
     pass->output_rect = gfx::Rect(0, 0, 100, 100);
     pass->damage_rect = gfx::Rect(10, 10, 1, 1);
@@ skipping 35 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