Make WebTaskRunner ThreadSafeRefCounted

third_party/WebKit/Source/platform/Timer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 22 matching lines @@
 #include "wtf/Atomics.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashSet.h"
 #include <algorithm>
 #include <limits.h>
 #include <limits>
 #include <math.h>
 
 namespace blink {
 
-TimerBase::TimerBase(WebTaskRunner* webTaskRunner)
+TimerBase::TimerBase(RefPtr<WebTaskRunner> webTaskRunner)
     : m_nextFireTime(0),
       m_repeatInterval(0),
-      m_webTaskRunner(webTaskRunner->clone()),
+      m_webTaskRunner(std::move(webTaskRunner)),
 #if DCHECK_IS_ON()
       m_thread(currentThread()),
 #endif
       m_weakPtrFactory(this) {
   ASSERT(m_webTaskRunner);
 }
 
 TimerBase::~TimerBase() {
   stop();
 }
@@ skipping 21 matching lines @@
 }
 
 double TimerBase::nextFireInterval() const {
   ASSERT(isActive());
   double current = timerMonotonicallyIncreasingTime();
   if (m_nextFireTime < current)
     return 0;
   return m_nextFireTime - current;
 }
 
-void TimerBase::moveToNewTaskRunner(WebTaskRunner* taskRunner) {
+void TimerBase::moveToNewTaskRunner(RefPtr<WebTaskRunner> taskRunner) {
 #if DCHECK_IS_ON()
   DCHECK_EQ(m_thread, currentThread());
   DCHECK(taskRunner->runsTasksOnCurrentThread());
 #endif
   // If the underlying task runner stays the same, ignore it.
   if (m_webTaskRunner->toSingleThreadTaskRunner() ==
       taskRunner->toSingleThreadTaskRunner()) {
     return;
   }
 
   bool active = isActive();
   m_weakPtrFactory.revokeAll();
-  m_webTaskRunner = taskRunner->clone();
+  m_webTaskRunner = std::move(taskRunner);
 
   if (!active)
     return;
 
   double now = timerMonotonicallyIncreasingTime();
   double nextFireTime = std::max(m_nextFireTime, now);
   m_nextFireTime = 0;
 
   setNextFireTime(now, nextFireTime - now);
 }
 
 // static
-WebTaskRunner* TimerBase::getTimerTaskRunner() {
+RefPtr<WebTaskRunner> TimerBase::getTimerTaskRunner() {
   return Platform::current()->currentThread()->scheduler()->timerTaskRunner();
 }
 
 // static
-WebTaskRunner* TimerBase::getUnthrottledTaskRunner() {
+RefPtr<WebTaskRunner> TimerBase::getUnthrottledTaskRunner() {
   return Platform::current()->currentThread()->getWebTaskRunner();
 }
 
-WebTaskRunner* TimerBase::timerTaskRunner() const {
-  return m_webTaskRunner.get();
+RefPtr<WebTaskRunner> TimerBase::timerTaskRunner() const {
+  return m_webTaskRunner;
 }
 
 void TimerBase::setNextFireTime(double now, double delay) {
 #if DCHECK_IS_ON()
   DCHECK_EQ(m_thread, currentThread());
 #endif
 
   double newTime = now + delay;
 
   if (m_nextFireTime != newTime) {
@@ skipping 43 matching lines @@
                                        const TimerBase* b) const {
   return a->m_nextFireTime < b->m_nextFireTime;
 }
 
 // static
 double TimerBase::timerMonotonicallyIncreasingTime() const {
   return timerTaskRunner()->monotonicallyIncreasingVirtualTimeSeconds();
 }
 
 }  // namespace blink