cc: Remove unnecessary task runner refptrs from schedulers.

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"
@@ skipping 15 matching lines @@
 namespace cc {
 namespace {
 
 class EmptySurfaceFactoryClient : public SurfaceFactoryClient {
  public:
   void ReturnResources(const ReturnedResourceArray& resources) override {}
 };
 
 class DisplayTest : public testing::Test {
  public:
-  DisplayTest() : factory_(&manager_, &empty_client_) {}
+  DisplayTest()
+      : factory_(&manager_, &empty_client_),
+        task_runner_(new base::NullTaskRunner) {}
 
  protected:
   void SetUpContext(scoped_ptr<TestWebGraphicsContext3D> context) {
     if (context) {
       output_surface_ = FakeOutputSurface::Create3d(
           TestContextProvider::Create(context.Pass()));
     } else {
       output_surface_ = FakeOutputSurface::CreateSoftware(
           make_scoped_ptr(new SoftwareOutputDevice));
     }
@@ skipping 11 matching lines @@
     factory_.SubmitFrame(surface_id, frame.Pass(),
                          SurfaceFactory::DrawCallback());
   }
 
   SurfaceManager manager_;
   EmptySurfaceFactoryClient empty_client_;
   SurfaceFactory factory_;
   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)
-      : DisplayScheduler(client,
-                         begin_frame_source,
-                         make_scoped_refptr(new base::NullTaskRunner),
-                         1),
+                       BeginFrameSource* begin_frame_source,
+                       base::NullTaskRunner* task_runner)
+      : DisplayScheduler(client, begin_frame_source, task_runner, 1),
         damaged(false),
         entire_display_damaged(false),
         swapped(false) {}
 
   ~TestDisplayScheduler() override {}
 
   void EntireDisplayDamaged(SurfaceId root_surface_id) override {
     entire_display_damaged = true;
   }
 
@@ skipping 21 matching lines @@
 // 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);
 
-  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_);
+  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
+                                 task_runner_.get());
   display.Initialize(output_surface_.Pass(), &scheduler);
 
   SurfaceId surface_id(7u);
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_FALSE(scheduler.entire_display_damaged);
   display.SetSurfaceId(surface_id, 1.f);
   EXPECT_FALSE(scheduler.damaged);
   EXPECT_TRUE(scheduler.entire_display_damaged);
 
   scheduler.ResetDamageForTest();
@@ skipping 186 matching lines @@
   SetUpContext(context.Pass());
 
   EXPECT_CALL(*context_ptr, shallowFinishCHROMIUM()).Times(0);
   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_);
+  TestDisplayScheduler scheduler(&display, &fake_begin_frame_source_,
+                                 task_runner_.get());
   display.Initialize(output_surface_.Pass(), &scheduler);
 
   SurfaceId surface_id(7u);
   display.SetSurfaceId(surface_id, 1.f);
 
   display.Resize(gfx::Size(100, 100));
   factory_.Create(surface_id);
 
   {
     RenderPassList pass_list;
@@ skipping 38 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