Transform RefCountedDeleteOnMessageLoop to RefCountedDeleteOnSequence.

base/memory/ref_counted_delete_on_sequence.h

 // Copyright 2013 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 BASE_MEMORY_REF_COUNTED_DELETE_ON_MESSAGE_LOOP_H_
-#define BASE_MEMORY_REF_COUNTED_DELETE_ON_MESSAGE_LOOP_H_
+#ifndef BASE_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_
+#define BASE_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_
+
+#include <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
+#include "base/sequenced_task_runner.h"
 
 namespace base {
 
-// RefCountedDeleteOnMessageLoop is similar to RefCountedThreadSafe, and ensures
-// that the object will be deleted on a specified message loop.
+// RefCountedDeleteOnSequence is similar to RefCountedThreadSafe, and ensures
+// that the object will be deleted on a specified sequence.
 //
 // Sample usage:
-// class Foo : public RefCountedDeleteOnMessageLoop<Foo> {
+// class Foo : public RefCountedDeleteOnSequence<Foo> {
 //
-//   Foo(scoped_refptr<SingleThreadTaskRunner> loop)
-//       : RefCountedDeleteOnMessageLoop<Foo>(std::move(loop)) {}
+//   Foo(scoped_refptr<SequencedTaskRunner> task_runner)
+//       : RefCountedDeleteOnSequence<Foo>(std::move(task_runner)) {}
 //   ...
 //  private:
-//   friend class RefCountedDeleteOnMessageLoop<Foo>;
+//   friend class RefCountedDeleteOnSequence<Foo>;
 //   friend class DeleteHelper<Foo>;
 //
 //   ~Foo();
 // };
-
-// TODO(skyostil): Rename this to RefCountedDeleteOnTaskRunner.
 template <class T>
-class RefCountedDeleteOnMessageLoop : public subtle::RefCountedThreadSafeBase {
+class RefCountedDeleteOnSequence : public subtle::RefCountedThreadSafeBase {
  public:
-  // A SingleThreadTaskRunner for the current thread can be acquired by calling
-  // ThreadTaskRunnerHandle::Get().
-  RefCountedDeleteOnMessageLoop(
-      scoped_refptr<SingleThreadTaskRunner> task_runner)
+  // A SequencedTaskRunner for the current sequence can be acquired by calling
+  // SequencedTaskRunnerHandle::Get().
+  RefCountedDeleteOnSequence(scoped_refptr<SequencedTaskRunner> task_runner)
       : task_runner_(std::move(task_runner)) {
     DCHECK(task_runner_);
   }
 
-  void AddRef() const {
-    subtle::RefCountedThreadSafeBase::AddRef();
-  }
+  void AddRef() const { subtle::RefCountedThreadSafeBase::AddRef(); }
 
   void Release() const {
     if (subtle::RefCountedThreadSafeBase::Release())
-      DestructOnMessageLoop();
+      DestructOnSequence();
   }
 
  protected:
-  friend class DeleteHelper<RefCountedDeleteOnMessageLoop>;
-  ~RefCountedDeleteOnMessageLoop() {}
+  friend class DeleteHelper<RefCountedDeleteOnSequence>;
+  ~RefCountedDeleteOnSequence() = default;
 
-  void DestructOnMessageLoop() const {
+ private:
+  void DestructOnSequence() const {
     const T* t = static_cast<const T*>(this);
-    if (task_runner_->BelongsToCurrentThread())
+    if (task_runner_->RunsTasksOnCurrentThread())
       delete t;
     else
       task_runner_->DeleteSoon(FROM_HERE, t);
   }
 
-  scoped_refptr<SingleThreadTaskRunner> task_runner_;
+  const scoped_refptr<SequencedTaskRunner> task_runner_;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(RefCountedDeleteOnMessageLoop);
+  DISALLOW_COPY_AND_ASSIGN(RefCountedDeleteOnSequence);
 };
 
 }  // namespace base
 
-#endif  // BASE_MEMORY_REF_COUNTED_DELETE_ON_MESSAGE_LOOP_H_
+#endif  // BASE_MEMORY_REF_COUNTED_DELETE_ON_SEQUENCE_H_