Make WebTaskRunner ThreadSafeRefCounted

third_party/WebKit/Source/platform/Timer.h

 /*
  * Copyright (C) 2006 Apple Computer, 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 28 matching lines @@
 #include "wtf/WeakPtr.h"
 
 namespace blink {
 
 // Time intervals are all in seconds.
 
 class PLATFORM_EXPORT TimerBase {
   WTF_MAKE_NONCOPYABLE(TimerBase);
 
  public:
-  explicit TimerBase(WebTaskRunner*);
+  explicit TimerBase(RefPtr<WebTaskRunner>);
   virtual ~TimerBase();
 
   void start(double nextFireInterval,
              double repeatInterval,
              const WebTraceLocation&);
 
   void startRepeating(double repeatInterval, const WebTraceLocation& caller) {
     start(repeatInterval, repeatInterval, caller);
   }
   void startOneShot(double interval, const WebTraceLocation& caller) {
     start(interval, 0, caller);
   }
 
   // Timer cancellation is fast enough that you shouldn't have to worry
   // about it unless you're canceling tens of thousands of tasks.
   virtual void stop();
   bool isActive() const;
   const WebTraceLocation& location() const { return m_location; }
 
   double nextFireInterval() const;
   double repeatInterval() const { return m_repeatInterval; }
 
   void augmentRepeatInterval(double delta) {
     double now = timerMonotonicallyIncreasingTime();
     setNextFireTime(now, std::max(m_nextFireTime - now + delta, 0.0));
     m_repeatInterval += delta;
   }
 
-  void moveToNewTaskRunner(WebTaskRunner*);
+  void moveToNewTaskRunner(RefPtr<WebTaskRunner>);
 
   struct PLATFORM_EXPORT Comparator {
     bool operator()(const TimerBase* a, const TimerBase* b) const;
   };
 
  protected:
-  static WebTaskRunner* getTimerTaskRunner();
-  static WebTaskRunner* getUnthrottledTaskRunner();
+  static RefPtr<WebTaskRunner> getTimerTaskRunner();
+  static RefPtr<WebTaskRunner> getUnthrottledTaskRunner();
 
  private:
   virtual void fired() = 0;
 
-  virtual WebTaskRunner* timerTaskRunner() const;
+  virtual RefPtr<WebTaskRunner> timerTaskRunner() const;
 
   NO_SANITIZE_ADDRESS
   virtual bool canFire() const { return true; }
 
   double timerMonotonicallyIncreasingTime() const;
 
   void setNextFireTime(double now, double delay);
 
   void runInternal();
 
   double m_nextFireTime;    // 0 if inactive
   double m_repeatInterval;  // 0 if not repeating
   WebTraceLocation m_location;
-  std::unique_ptr<WebTaskRunner> m_webTaskRunner;
+  RefPtr<WebTaskRunner> m_webTaskRunner;
 
 #if DCHECK_IS_ON()
   ThreadIdentifier m_thread;
 #endif
   WTF::WeakPtrFactory<TimerBase> m_weakPtrFactory;
 
   friend class ThreadTimers;
   friend class TimerHeapLessThanFunction;
   friend class TimerHeapReference;
 };
@@ skipping 10 matching lines @@
   static bool isHeapObjectAlive(T* objectPointer) {
     return !ThreadHeap::willObjectBeLazilySwept(objectPointer);
   }
 };
 
 template <typename TimerFiredClass>
 class TaskRunnerTimer : public TimerBase {
  public:
   using TimerFiredFunction = void (TimerFiredClass::*)(TimerBase*);
 
-  TaskRunnerTimer(WebTaskRunner* webTaskRunner,
+  TaskRunnerTimer(RefPtr<WebTaskRunner> webTaskRunner,
                   TimerFiredClass* o,
                   TimerFiredFunction f)
-      : TimerBase(webTaskRunner), m_object(o), m_function(f) {}
+      : TimerBase(std::move(webTaskRunner)), m_object(o), m_function(f) {}
 
   ~TaskRunnerTimer() override {}
 
  protected:
   void fired() override { (m_object->*m_function)(this); }
 
   NO_SANITIZE_ADDRESS
   bool canFire() const override {
     // Oilpan: if a timer fires while Oilpan heaps are being lazily
     // swept, it is not safe to proceed if the object is about to
@@ skipping 52 matching lines @@
 inline bool TimerBase::isActive() const {
 #if DCHECK_IS_ON()
   DCHECK_EQ(m_thread, currentThread());
 #endif
   return m_weakPtrFactory.hasWeakPtrs();
 }
 
 }  // namespace blink
 
 #endif  // Timer_h