Make WebTaskRunner ThreadSafeRefCounted

third_party/WebKit/Source/platform/TimerTest.cpp

 // 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 "platform/Timer.h"
 
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/child/web_task_runner_impl.h"
 #include "platform/scheduler/renderer/renderer_scheduler_impl.h"
 #include "platform/testing/TestingPlatformSupport.h"
@@ skipping 508 matching lines @@
 }
 
 template <typename TimerFiredClass>
 class TimerForTest : public TaskRunnerTimer<TimerFiredClass> {
  public:
   using TimerFiredFunction =
       typename TaskRunnerTimer<TimerFiredClass>::TimerFiredFunction;
 
   ~TimerForTest() override {}
 
-  TimerForTest(WebTaskRunner* webTaskRunner,
+  TimerForTest(RefPtr<WebTaskRunner> webTaskRunner,
                TimerFiredClass* timerFiredClass,
                TimerFiredFunction timerFiredFunction)
-      : TaskRunnerTimer<TimerFiredClass>(webTaskRunner,
+      : TaskRunnerTimer<TimerFiredClass>(std::move(webTaskRunner),
                                          timerFiredClass,
                                          timerFiredFunction) {}
 };
 
 TEST_F(TimerTest, UserSuppliedWebTaskRunner) {
   scoped_refptr<scheduler::TaskQueue> taskRunner(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner(taskRunner);
-  TimerForTest<TimerTest> timer(&webTaskRunner, this, &TimerTest::countingTask);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner =
+      scheduler::WebTaskRunnerImpl::create(taskRunner);
+  TimerForTest<TimerTest> timer(webTaskRunner, this, &TimerTest::countingTask);
   timer.startOneShot(0, BLINK_FROM_HERE);
 
   // Make sure the task was posted on taskRunner.
   EXPECT_FALSE(taskRunner->IsEmpty());
 }
 
 TEST_F(TimerTest, RunOnHeapTimer) {
   RefPtr<OnHeapTimerOwner::Record> record = OnHeapTimerOwner::Record::create();
   Persistent<OnHeapTimerOwner> owner = new OnHeapTimerOwner(record);
 
@@ skipping 40 matching lines @@
     m_platform.runUntilIdle();
     EXPECT_FALSE(record->timerHasFired());
     EXPECT_FALSE(record->ownerIsDestructed());
   }
 }
 
 namespace {
 
 class TaskObserver : public base::MessageLoop::TaskObserver {
  public:
-  TaskObserver(WebTaskRunner* task_runner,
-               std::vector<WebTaskRunner*>* runOrder)
-      : m_taskRunner(task_runner), m_runOrder(runOrder) {}
+  TaskObserver(RefPtr<WebTaskRunner> task_runner,
+               std::vector<RefPtr<WebTaskRunner>>* runOrder)
+      : m_taskRunner(std::move(task_runner)), m_runOrder(runOrder) {}
 
   void WillProcessTask(const base::PendingTask&) {}
 
   void DidProcessTask(const base::PendingTask&) {
     m_runOrder->push_back(m_taskRunner);
   }
 
  private:
-  WebTaskRunner* m_taskRunner;
-  std::vector<WebTaskRunner*>* m_runOrder;
+  RefPtr<WebTaskRunner> m_taskRunner;
+  std::vector<RefPtr<WebTaskRunner>>* m_runOrder;
 };
 
 }  // namespace
 
 TEST_F(TimerTest, MoveToNewTaskRunnerOneShot) {
-  std::vector<WebTaskRunner*> runOrder;
+  std::vector<RefPtr<WebTaskRunner>> runOrder;
 
   scoped_refptr<scheduler::TaskQueue> taskRunner1(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner1(taskRunner1);
-  TaskObserver taskObserver1(&webTaskRunner1, &runOrder);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner1 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner1);
+  TaskObserver taskObserver1(webTaskRunner1, &runOrder);
   taskRunner1->AddTaskObserver(&taskObserver1);
 
   scoped_refptr<scheduler::TaskQueue> taskRunner2(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner2(taskRunner2);
-  TaskObserver taskObserver2(&webTaskRunner2, &runOrder);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner2 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner2);
+  TaskObserver taskObserver2(webTaskRunner2, &runOrder);
   taskRunner2->AddTaskObserver(&taskObserver2);
 
-  TimerForTest<TimerTest> timer(&webTaskRunner1, this,
-                                &TimerTest::countingTask);
+  TimerForTest<TimerTest> timer(webTaskRunner1, this, &TimerTest::countingTask);
 
   double startTime = monotonicallyIncreasingTime();
 
   timer.startOneShot(1, BLINK_FROM_HERE);
 
   m_platform.runForPeriodSeconds(0.5);
 
-  timer.moveToNewTaskRunner(&webTaskRunner2);
+  timer.moveToNewTaskRunner(webTaskRunner2);
 
   m_platform.runUntilIdle();
 
   EXPECT_THAT(m_runTimes, ElementsAre(startTime + 1.0));
 
-  EXPECT_THAT(runOrder, ElementsAre(&webTaskRunner2));
+  EXPECT_THAT(runOrder, ElementsAre(webTaskRunner2));
 
   EXPECT_TRUE(taskRunner1->IsEmpty());
   EXPECT_TRUE(taskRunner2->IsEmpty());
 }
 
 TEST_F(TimerTest, MoveToNewTaskRunnerRepeating) {
-  std::vector<WebTaskRunner*> runOrder;
+  std::vector<RefPtr<WebTaskRunner>> runOrder;
 
   scoped_refptr<scheduler::TaskQueue> taskRunner1(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner1(taskRunner1);
-  TaskObserver taskObserver1(&webTaskRunner1, &runOrder);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner1 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner1);
+  TaskObserver taskObserver1(webTaskRunner1, &runOrder);
   taskRunner1->AddTaskObserver(&taskObserver1);
 
   scoped_refptr<scheduler::TaskQueue> taskRunner2(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner2(taskRunner2);
-  TaskObserver taskObserver2(&webTaskRunner2, &runOrder);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner2 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner2);
+  TaskObserver taskObserver2(webTaskRunner2, &runOrder);
   taskRunner2->AddTaskObserver(&taskObserver2);
 
-  TimerForTest<TimerTest> timer(&webTaskRunner1, this,
-                                &TimerTest::countingTask);
+  TimerForTest<TimerTest> timer(webTaskRunner1, this, &TimerTest::countingTask);
 
   double startTime = monotonicallyIncreasingTime();
 
   timer.startRepeating(1, BLINK_FROM_HERE);
 
   m_platform.runForPeriodSeconds(2.5);
 
-  timer.moveToNewTaskRunner(&webTaskRunner2);
+  timer.moveToNewTaskRunner(webTaskRunner2);
 
   m_platform.runForPeriodSeconds(2);
 
   EXPECT_THAT(m_runTimes, ElementsAre(startTime + 1.0, startTime + 2.0,
                                       startTime + 3.0, startTime + 4.0));
 
-  EXPECT_THAT(runOrder, ElementsAre(&webTaskRunner1, &webTaskRunner1,
-                                    &webTaskRunner2, &webTaskRunner2));
+  EXPECT_THAT(runOrder, ElementsAre(webTaskRunner1, webTaskRunner1,
+                                    webTaskRunner2, webTaskRunner2));
 
   EXPECT_TRUE(taskRunner1->IsEmpty());
   EXPECT_FALSE(taskRunner2->IsEmpty());
 }
 
 // This test checks that when inactive timer is moved to a different task
 // runner it isn't activated.
 TEST_F(TimerTest, MoveToNewTaskRunnerWithoutTasks) {
   scoped_refptr<scheduler::TaskQueue> taskRunner1(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner1(taskRunner1);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner1 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner1);
 
   scoped_refptr<scheduler::TaskQueue> taskRunner2(
       m_platform.rendererScheduler()->NewTimerTaskRunner(
           scheduler::TaskQueue::QueueType::TEST));
-  scheduler::WebTaskRunnerImpl webTaskRunner2(taskRunner2);
+  RefPtr<scheduler::WebTaskRunnerImpl> webTaskRunner2 =
+      scheduler::WebTaskRunnerImpl::create(taskRunner2);
 
-  TimerForTest<TimerTest> timer(&webTaskRunner1, this,
-                                &TimerTest::countingTask);
+  TimerForTest<TimerTest> timer(webTaskRunner1, this, &TimerTest::countingTask);
 
   m_platform.runUntilIdle();
   EXPECT_TRUE(!m_runTimes.size());
   EXPECT_TRUE(taskRunner1->IsEmpty());
   EXPECT_TRUE(taskRunner2->IsEmpty());
 }
 
 }  // namespace
 }  // namespace blink