Make WebTaskRunner ThreadSafeRefCounted

third_party/WebKit/Source/platform/WebTaskRunner.h

 // 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.
 
 #ifndef WebTaskRunner_h
 #define WebTaskRunner_h
 
 #include "base/callback_forward.h"
 #include "public/platform/WebCommon.h"
 #include "public/platform/WebTraceLocation.h"
@@ skipping 38 matching lines @@
   class Runner;
 
  private:
   friend class WebTaskRunner;
 
   explicit TaskHandle(RefPtr<Runner>);
   RefPtr<Runner> m_runner;
 };
 
 // The blink representation of a chromium SingleThreadTaskRunner.
-class BLINK_PLATFORM_EXPORT WebTaskRunner {
+class BLINK_PLATFORM_EXPORT WebTaskRunner
+    : public ThreadSafeRefCounted<WebTaskRunner> {
  public:
-  virtual ~WebTaskRunner() {}
-
   class BLINK_PLATFORM_EXPORT Task {
    public:
     virtual ~Task() {}
     virtual void run() = 0;
   };
 
   // Schedule a task to be run on the the associated WebThread.
   // Takes ownership of |Task|. Can be called from any thread.
   virtual void postTask(const WebTraceLocation&, Task*) = 0;
 
   // Schedule a task to be run after |delayMs| on the the associated WebThread.
   // Takes ownership of |Task|. Can be called from any thread.
   virtual void postDelayedTask(const WebTraceLocation&,
                                Task*,
                                double delayMs) = 0;
 
   // Schedule a task to be run after |delayMs| on the the associated WebThread.
   // Can be called from any thread.
   virtual void postDelayedTask(const WebTraceLocation&,
                                const base::Closure&,
                                double delayMs) = 0;
 
-  // Returns a clone of the WebTaskRunner.
-  virtual std::unique_ptr<WebTaskRunner> clone() = 0;
-
   // Returns true if the current thread is a thread on which a task may be run.
   // Can be called from any thread.
   virtual bool runsTasksOnCurrentThread() = 0;
 
   // ---
 
   // Headless Chrome virtualises time for determinism and performance (fast
   // forwarding of timers). To make this work some parts of blink (e.g. Timers)
   // need to use virtual time, however by default new code should use the normal
   // non-virtual time APIs.
@@ skipping 28 matching lines @@
                        long long delayMs);
 
   // For same-thread cancellable task posting. Returns a TaskHandle object for
   // cancellation.
   WARN_UNUSED_RESULT TaskHandle
   postCancellableTask(const WebTraceLocation&, std::unique_ptr<WTF::Closure>);
   WARN_UNUSED_RESULT TaskHandle
   postDelayedCancellableTask(const WebTraceLocation&,
                              std::unique_ptr<WTF::Closure>,
                              long long delayMs);
+
+ protected:
+  friend ThreadSafeRefCounted<WebTaskRunner>;
+  WebTaskRunner() = default;
+  virtual ~WebTaskRunner();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WebTaskRunner);
 };
 
 }  // namespace blink
 
 #endif  // WebTaskRunner_h