cc: Remove unnecessary task runner refptrs from schedulers.

cc/surfaces/display_scheduler_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_scheduler.h"
 
 #include "base/logging.h"
 #include "base/test/null_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/surfaces/display.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
+const int kMaxPendingSwaps = 1;
+
 class FakeDisplaySchedulerClient : public DisplaySchedulerClient {
  public:
   FakeDisplaySchedulerClient() : draw_and_swap_count_(0) {}
 
   ~FakeDisplaySchedulerClient() override {}
 
   bool DrawAndSwap() override {
     draw_and_swap_count_++;
     return true;
   }
 
   void Reset() { draw_and_swap_count_ = 0; }
 
   int draw_and_swap_count() const { return draw_and_swap_count_; }
 
  protected:
   int draw_and_swap_count_;
 };
 
 class TestDisplayScheduler : public DisplayScheduler {
  public:
   TestDisplayScheduler(DisplaySchedulerClient* client,
                        BeginFrameSource* begin_frame_source,
-                       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                       base::SingleThreadTaskRunner* task_runner,
                        int max_pending_swaps)
       : DisplayScheduler(client,
                          begin_frame_source,
                          task_runner,
                          max_pending_swaps),
         scheduler_begin_frame_deadline_count_(0) {}
 
   base::TimeTicks DesiredBeginFrameDeadlineTimeForTest() {
     return DesiredBeginFrameDeadlineTime();
   }
 
   void BeginFrameDeadlineForTest() { OnBeginFrameDeadline(); }
 
   void ScheduleBeginFrameDeadline() override {
     scheduler_begin_frame_deadline_count_++;
     DisplayScheduler::ScheduleBeginFrameDeadline();
   }
 
   int scheduler_begin_frame_deadline_count() {
     return scheduler_begin_frame_deadline_count_;
   }
 
  protected:
   int scheduler_begin_frame_deadline_count_;
 };
 
 class DisplaySchedulerTest : public testing::Test {
  public:
-  DisplaySchedulerTest() : now_src_(new base::SimpleTestTickClock()) {
-    const int max_pending_swaps = 1;
+  DisplaySchedulerTest()
+      : now_src_(new base::SimpleTestTickClock()),
+        task_runner_(new base::NullTaskRunner),
+        client_(new FakeDisplaySchedulerClient),
+        scheduler_(new TestDisplayScheduler(client_.get(),
+                                            &fake_begin_frame_source_,
+                                            task_runner_.get(),
+                                            kMaxPendingSwaps)) {
     now_src_->Advance(base::TimeDelta::FromMicroseconds(10000));
-    null_task_runner_ = make_scoped_refptr(new base::NullTaskRunner);
-    client_ = make_scoped_ptr(new FakeDisplaySchedulerClient);
-    scheduler_ = make_scoped_ptr(
-        new TestDisplayScheduler(client_.get(), &fake_begin_frame_source_,
-                                 null_task_runner_, max_pending_swaps));
   }
 
   ~DisplaySchedulerTest() override {}
 
   void SetUp() override { scheduler_->SetRootSurfaceResourcesLocked(false); }
 
   void BeginFrameForTest() {
     base::TimeTicks frame_time = now_src_->NowTicks();
     base::TimeDelta interval = BeginFrameArgs::DefaultInterval();
     base::TimeTicks deadline = frame_time + interval;
     fake_begin_frame_source_.TestOnBeginFrame(
         BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                interval, BeginFrameArgs::NORMAL));
   }
 
  protected:
   base::SimpleTestTickClock& now_src() { return *now_src_; }
   FakeDisplaySchedulerClient& client() { return *client_; }
   DisplayScheduler& scheduler() { return *scheduler_; }
 
+  FakeBeginFrameSource fake_begin_frame_source_;
+
   scoped_ptr<base::SimpleTestTickClock> now_src_;
-  scoped_refptr<base::NullTaskRunner> null_task_runner_;
-
-  FakeBeginFrameSource fake_begin_frame_source_;
+  scoped_refptr<base::NullTaskRunner> task_runner_;
   scoped_ptr<FakeDisplaySchedulerClient> client_;
   scoped_ptr<TestDisplayScheduler> scheduler_;
 };
 
 TEST_F(DisplaySchedulerTest, EntireDisplayDamagedDrawsImmediately) {
   SurfaceId root_surface_id(1);
   BeginFrameForTest();
   EXPECT_LT(now_src().NowTicks(),
             scheduler_->DesiredBeginFrameDeadlineTimeForTest());
   scheduler_->EntireDisplayDamaged(root_surface_id);
@@ skipping 222 matching lines @@
 
   scheduler_->SetRootSurfaceResourcesLocked(true);
   EXPECT_EQ(count++, scheduler_->scheduler_begin_frame_deadline_count());
 
   scheduler_->OutputSurfaceLost();
   EXPECT_EQ(count++, scheduler_->scheduler_begin_frame_deadline_count());
 }
 
 }  // namespace
 }  // namespace cc