Get rid of virtual Display::CreateScheduler.

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 810479bd92154596db171a897cd548155988aac6..3a7ede8e5425ab48ed51136cf85a2096cc73b715 100644
--- a/cc/surfaces/display_unittest.cc
+++ b/cc/surfaces/display_unittest.cc
@@ -10,9 +10,12 @@
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/delegated_frame_data.h"
+#include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/render_pass.h"
 #include "cc/resources/shared_bitmap_manager.h"
+#include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/display_client.h"
+#include "cc/surfaces/display_scheduler.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_factory.h"
 #include "cc/surfaces/surface_factory_client.h"
@@ -53,68 +56,11 @@ class TestSoftwareOutputDevice : public SoftwareOutputDevice {
   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) {
-    id_allocator_.RegisterSurfaceIdNamespace(&manager_);
-  }
-
- protected:
-  void SetUpContext(std::unique_ptr<TestWebGraphicsContext3D> context) {
-    if (context) {
-      output_surface_ = FakeOutputSurface::Create3d(
-          TestContextProvider::Create(std::move(context)));
-    } else {
-      std::unique_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) {
-    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
-    pass_list->swap(frame_data->render_pass_list);
-
-    std::unique_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_;
-  std::unique_ptr<FakeOutputSurface> output_surface_;
-  FakeOutputSurface* output_surface_ptr_;
-  scoped_refptr<base::NullTaskRunner> task_runner_;
-  std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
-};
-
-class StubDisplayClient : public DisplayClient {
- public:
-  void DisplayOutputSurfaceLost() override {}
-  void DisplaySetMemoryPolicy(const ManagedMemoryPolicy& policy) override {}
-};
-
 class TestDisplayScheduler : public DisplayScheduler {
  public:
-  TestDisplayScheduler(DisplaySchedulerClient* client,
-                       BeginFrameSource* begin_frame_source,
+  TestDisplayScheduler(BeginFrameSource* begin_frame_source,
                        base::SingleThreadTaskRunner* task_runner)
-      : DisplayScheduler(client, begin_frame_source, task_runner, 1),
+      : DisplayScheduler(begin_frame_source, task_runner, 1),
         damaged(false),
         display_resized_(false),
         has_new_root_surface(false),
@@ -145,41 +91,75 @@ class TestDisplayScheduler : public DisplayScheduler {
   bool display_resized_;
   bool has_new_root_surface;
   bool swapped;
-
- private:
-  RendererSettings settings_;
 };
 
-class TestDisplay : public Display {
+class DisplayTest : public testing::Test {
  public:
-  TestDisplay(SurfaceManager* manager,
-              SharedBitmapManager* bitmap_manager,
-              gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-              const RendererSettings& settings,
-              uint32_t compositor_surface_namespace,
-              base::SingleThreadTaskRunner* task_runner,
-              std::unique_ptr<OutputSurface> output_surface)
-      : Display(manager,
-                bitmap_manager,
-                gpu_memory_buffer_manager,
-                settings,
-                compositor_surface_namespace,
-                task_runner,
-                std::move(output_surface)),
-        task_runner_(task_runner) {}
-
-  TestDisplayScheduler& scheduler() {
-    return *static_cast<TestDisplayScheduler*>(scheduler_.get());
+  DisplayTest()
+      : factory_(&manager_, &surface_factory_client_),
+        id_allocator_(kArbitrarySurfaceNamespace),
+        task_runner_(new base::NullTaskRunner) {
+    id_allocator_.RegisterSurfaceIdNamespace(&manager_);
+  }
+
+  void SetUpDisplay(const RendererSettings& settings,
+                    std::unique_ptr<TestWebGraphicsContext3D> context) {
+    std::unique_ptr<BeginFrameSource> begin_frame_source(
+        new StubBeginFrameSource);
+
+    std::unique_ptr<FakeOutputSurface> output_surface;
+    if (context) {
+      output_surface = FakeOutputSurface::Create3d(std::move(context));
+    } else {
+      std::unique_ptr<TestSoftwareOutputDevice> device(
+          new TestSoftwareOutputDevice);
+      software_output_device_ = device.get();
+      output_surface = FakeOutputSurface::CreateSoftware(std::move(device));
+    }
+    output_surface_ = output_surface.get();
+
+    std::unique_ptr<TestDisplayScheduler> scheduler(
+        new TestDisplayScheduler(begin_frame_source.get(), task_runner_.get()));
+    scheduler_ = scheduler.get();
+
+    display_ = base::MakeUnique<Display>(
+        &manager_, &shared_bitmap_manager_,
+        nullptr /* gpu_memory_buffer_manager */, settings,
+        id_allocator_.id_namespace(), std::move(begin_frame_source),
+        std::move(output_surface), std::move(scheduler),
+        base::MakeUnique<TextureMailboxDeleter>(task_runner_.get()));
   }
 
  protected:
-  void CreateScheduler() override {
-    scheduler_.reset(new TestDisplayScheduler(this, vsync_begin_frame_source_,
-                                              task_runner_));
+  void SubmitCompositorFrame(RenderPassList* pass_list, SurfaceId surface_id) {
+    std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
+    pass_list->swap(frame_data->render_pass_list);
+
+    std::unique_ptr<CompositorFrame> frame(new CompositorFrame);
+    frame->delegated_frame_data = std::move(frame_data);
+
+    factory_.SubmitCompositorFrame(surface_id, std::move(frame),
+                                   SurfaceFactory::DrawCallback());
   }
 
- private:
-  base::SingleThreadTaskRunner* task_runner_;
+  static constexpr int kArbitrarySurfaceNamespace = 3;
+
+  SurfaceManager manager_;
+  FakeSurfaceFactoryClient surface_factory_client_;
+  SurfaceFactory factory_;
+  SurfaceIdAllocator id_allocator_;
+  scoped_refptr<base::NullTaskRunner> task_runner_;
+  TestSharedBitmapManager shared_bitmap_manager_;
+  std::unique_ptr<Display> display_;
+  TestSoftwareOutputDevice* software_output_device_ = nullptr;
+  FakeOutputSurface* output_surface_ = nullptr;
+  TestDisplayScheduler* scheduler_ = nullptr;
+};
+
+class StubDisplayClient : public DisplayClient {
+ public:
+  void DisplayOutputSurfaceLost() override {}
+  void DisplaySetMemoryPolicy(const ManagedMemoryPolicy& policy) override {}
 };
 
 void CopyCallback(bool* called, std::unique_ptr<CopyOutputResult> result) {
@@ -188,30 +168,27 @@ void CopyCallback(bool* called, std::unique_ptr<CopyOutputResult> result) {
 
 // Check that frame is damaged and swapped only under correct conditions.
 TEST_F(DisplayTest, DisplayDamaged) {
-  SetUpContext(nullptr);
-  StubDisplayClient client;
   RendererSettings settings;
   settings.partial_swap_enabled = true;
   settings.finish_rendering_on_resize = true;
-  TestDisplay display(&manager_, shared_bitmap_manager_.get(), nullptr,
-                      settings, id_allocator_.id_namespace(),
-                      task_runner_.get(), std::move(output_surface_));
-  display.Initialize(&client);
-  TestDisplayScheduler& scheduler = display.scheduler();
+  SetUpDisplay(settings, nullptr);
+
+  StubDisplayClient client;
+  display_->Initialize(&client);
 
   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);
-  EXPECT_TRUE(scheduler.display_resized_);
-  EXPECT_FALSE(scheduler.has_new_root_surface);
+  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);
+  EXPECT_TRUE(scheduler_->display_resized_);
+  EXPECT_FALSE(scheduler_->has_new_root_surface);
 
   factory_.Create(surface_id);
 
@@ -223,17 +200,17 @@ TEST_F(DisplayTest, DisplayDamaged) {
   pass->id = RenderPassId(1, 1);
   pass_list.push_back(std::move(pass));
 
-  scheduler.ResetDamageForTest();
+  scheduler_->ResetDamageForTest();
   SubmitCompositorFrame(&pass_list, surface_id);
-  EXPECT_TRUE(scheduler.damaged);
-  EXPECT_FALSE(scheduler.display_resized_);
-  EXPECT_FALSE(scheduler.has_new_root_surface);
-
-  EXPECT_FALSE(scheduler.swapped);
-  EXPECT_EQ(0u, output_surface_ptr_->num_sent_frames());
-  display.DrawAndSwap();
-  EXPECT_TRUE(scheduler.swapped);
-  EXPECT_EQ(1u, output_surface_ptr_->num_sent_frames());
+  EXPECT_TRUE(scheduler_->damaged);
+  EXPECT_FALSE(scheduler_->display_resized_);
+  EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+  EXPECT_FALSE(scheduler_->swapped);
+  EXPECT_EQ(0u, output_surface_->num_sent_frames());
+  display_->DrawAndSwap();
+  EXPECT_TRUE(scheduler_->swapped);
+  EXPECT_EQ(1u, output_surface_->num_sent_frames());
   EXPECT_EQ(gfx::Size(100, 100),
             software_output_device_->viewport_pixel_size());
   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), software_output_device_->damage_rect());
@@ -246,16 +223,16 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(2u, output_surface_->num_sent_frames());
     EXPECT_EQ(gfx::Size(100, 100),
               software_output_device_->viewport_pixel_size());
     EXPECT_EQ(gfx::Rect(10, 10, 1, 1), software_output_device_->damage_rect());
@@ -269,16 +246,16 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(2u, output_surface_->num_sent_frames());
   }
 
   {
@@ -289,16 +266,16 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(2u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(2u, output_surface_->num_sent_frames());
   }
 
   {
@@ -309,16 +286,16 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(3u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(3u, output_surface_->num_sent_frames());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
               software_output_device_->damage_rect());
   }
@@ -334,16 +311,16 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(4u, output_surface_->num_sent_frames());
     EXPECT_TRUE(copy_called);
   }
 
@@ -356,7 +333,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list.swap(frame_data->render_pass_list);
 
@@ -366,22 +343,22 @@ TEST_F(DisplayTest, DisplayDamaged) {
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(4u, output_surface_->num_sent_frames());
   }
 
   // Resize should cause a swap if no frame was swapped at the previous size.
   {
-    scheduler.swapped = false;
-    display.Resize(gfx::Size(200, 200));
-    EXPECT_FALSE(scheduler.swapped);
-    EXPECT_EQ(4u, output_surface_ptr_->num_sent_frames());
+    scheduler_->swapped = false;
+    display_->Resize(gfx::Size(200, 200));
+    EXPECT_FALSE(scheduler_->swapped);
+    EXPECT_EQ(4u, output_surface_->num_sent_frames());
 
     pass = RenderPass::Create();
     pass->output_rect = gfx::Rect(0, 0, 200, 200);
@@ -389,7 +366,7 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     std::unique_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
     pass_list.swap(frame_data->render_pass_list);
 
@@ -398,19 +375,18 @@ TEST_F(DisplayTest, DisplayDamaged) {
 
     factory_.SubmitCompositorFrame(surface_id, std::move(frame),
                                    SurfaceFactory::DrawCallback());
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
 
-    scheduler.swapped = false;
-    display.Resize(gfx::Size(100, 100));
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(5u, output_surface_ptr_->num_sent_frames());
+    scheduler_->swapped = false;
+    display_->Resize(gfx::Size(100, 100));
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(5u, output_surface_->num_sent_frames());
 
     // Latency info from previous frame should be sent now.
-    EXPECT_EQ(
-        1u,
-        output_surface_ptr_->last_sent_frame().metadata.latency_info.size());
+    EXPECT_EQ(1u,
+              output_surface_->last_sent_frame().metadata.latency_info.size());
   }
 
   {
@@ -421,23 +397,22 @@ TEST_F(DisplayTest, DisplayDamaged) {
     pass->id = RenderPassId(1, 1);
 
     pass_list.push_back(std::move(pass));
-    scheduler.ResetDamageForTest();
+    scheduler_->ResetDamageForTest();
     SubmitCompositorFrame(&pass_list, surface_id);
-    EXPECT_TRUE(scheduler.damaged);
-    EXPECT_FALSE(scheduler.display_resized_);
-    EXPECT_FALSE(scheduler.has_new_root_surface);
-
-    scheduler.swapped = false;
-    display.DrawAndSwap();
-    EXPECT_TRUE(scheduler.swapped);
-    EXPECT_EQ(6u, output_surface_ptr_->num_sent_frames());
+    EXPECT_TRUE(scheduler_->damaged);
+    EXPECT_FALSE(scheduler_->display_resized_);
+    EXPECT_FALSE(scheduler_->has_new_root_surface);
+
+    scheduler_->swapped = false;
+    display_->DrawAndSwap();
+    EXPECT_TRUE(scheduler_->swapped);
+    EXPECT_EQ(6u, output_surface_->num_sent_frames());
     EXPECT_EQ(gfx::Size(100, 100),
               software_output_device_->viewport_pixel_size());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
               software_output_device_->damage_rect());
-    EXPECT_EQ(
-        0u,
-        output_surface_ptr_->last_sent_frame().metadata.latency_info.size());
+    EXPECT_EQ(0u,
+              output_surface_->last_sent_frame().metadata.latency_info.size());
   }
 
   factory_.Destroy(surface_id);
@@ -449,26 +424,24 @@ class MockedContext : public TestWebGraphicsContext3D {
 };
 
 TEST_F(DisplayTest, Finish) {
+  SurfaceId surface_id(id_allocator_.GenerateId());
+
+  RendererSettings settings;
+  settings.partial_swap_enabled = true;
+  settings.finish_rendering_on_resize = true;
+
   std::unique_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());
+  SetUpDisplay(settings, std::move(context));
 
   StubDisplayClient client;
-  RendererSettings settings;
-  settings.partial_swap_enabled = true;
-  settings.finish_rendering_on_resize = true;
-  TestDisplay display(&manager_, shared_bitmap_manager_.get(), nullptr,
-                      settings, surface_id.id_namespace(), task_runner_.get(),
-                      std::move(output_surface_));
-  display.Initialize(&client);
+  display_->Initialize(&client);
 
-  display.SetSurfaceId(surface_id, 1.f);
+  display_->SetSurfaceId(surface_id, 1.f);
 
-  display.Resize(gfx::Size(100, 100));
+  display_->Resize(gfx::Size(100, 100));
   factory_.Create(surface_id);
 
   {
@@ -482,18 +455,18 @@ TEST_F(DisplayTest, Finish) {
     SubmitCompositorFrame(&pass_list, surface_id);
   }
 
-  display.DrawAndSwap();
+  display_->DrawAndSwap();
 
   // First resize and draw shouldn't finish.
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
-  display.Resize(gfx::Size(150, 150));
+  display_->Resize(gfx::Size(150, 150));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   // Another resize without a swap doesn't need to finish.
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
-  display.Resize(gfx::Size(200, 200));
+  display_->Resize(gfx::Size(200, 200));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
@@ -508,12 +481,12 @@ TEST_F(DisplayTest, Finish) {
     SubmitCompositorFrame(&pass_list, surface_id);
   }
 
-  display.DrawAndSwap();
+  display_->DrawAndSwap();
 
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM());
-  display.Resize(gfx::Size(250, 250));
+  display_->Resize(gfx::Size(250, 250));
   testing::Mock::VerifyAndClearExpectations(context_ptr);
 
   factory_.Destroy(surface_id);