Deprecate NonThreadSafe in components/sync in favor of SequenceChecker.

components/sync/model_impl/attachments/task_queue.h

 // Copyright 2014 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 COMPONENTS_SYNC_MODEL_IMPL_ATTACHMENTS_TASK_QUEUE_H_
 #define COMPONENTS_SYNC_MODEL_IMPL_ATTACHMENTS_TASK_QUEUE_H_
 
 #include <stddef.h>
 
 #include <deque>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
-#include "base/threading/non_thread_safe.h"
+#include "base/sequence_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/backoff_entry.h"
 
 namespace syncer {
 
 // A queue that dispatches tasks, ignores duplicates, and provides backoff
 // semantics.
 //
@@ skipping 31 matching lines @@
 //     queue.MarkAsFailed(foo);
 //     if (ShouldRetry(foo)) {
 //       queue.AddToQueue(foo);
 //     }
 //   } else {
 //     Cancel(foo);
 //   }
 // }
 //
 template <typename T>
-class TaskQueue : base::NonThreadSafe {
+class TaskQueue {
  public:
   // A callback provided by users of the TaskQueue to handle tasks.
   //
   // This callback is invoked by the queue with a task to be handled.  The
   // callee is expected to (eventually) call |MarkAsSucceeded|, |MarkAsFailed|,
   // or |Cancel| to signify completion of the task.
   using HandleTaskCallback = base::Callback<void(const T&)>;
 
   // Construct a TaskQueue.
   //
   // |callback| the callback to be invoked for handling tasks.
   //
   // |initial_backoff_delay| the initial amount of time the queue will wait
   // before dispatching tasks after a failed task (see |MarkAsFailed|).  May be
   // zero.  Subsequent failures will increase the delay up to
   // |max_backoff_delay|.
   //
   // |max_backoff_delay| the maximum amount of time the queue will wait before
   // dispatching tasks.  May be zero.  Must be greater than or equal to
   // |initial_backoff_delay|.
   TaskQueue(const HandleTaskCallback& callback,
             const base::TimeDelta& initial_backoff_delay,
             const base::TimeDelta& max_backoff_delay);
 
+  ~TaskQueue();
+
   // Add |task| to the end of the queue.
   //
   // If |task| is already present (as determined by operator==) it is not added.
   void AddToQueue(const T& task);
 
   // Mark |task| as completing successfully.
   //
   // Marking a task as completing successfully will reduce or eliminate any
   // backoff delay in effect.
   //
@@ skipping 43 matching lines @@
   std::unique_ptr<net::BackoffEntry> backoff_entry_;
   // The number of tasks currently being handled.
   int num_in_progress_;
   std::deque<T> queue_;
   // The set of tasks in queue_ or currently being handled.
   std::set<T> tasks_;
   base::Closure dispatch_closure_;
   std::unique_ptr<base::Timer> backoff_timer_;
   base::TimeDelta delay_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // Must be last data member.
   base::WeakPtrFactory<TaskQueue> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueue);
 };
 
 // The maximum number of tasks that may be concurrently executed.  Think
 // carefully before changing this value.  The desired behavior of backoff may
 // not be obvious when there is more than one concurrent task
 const int kMaxConcurrentTasks = 1;
@@ skipping 14 matching lines @@
   backoff_policy_.maximum_backoff_ms = max_backoff_delay.InMilliseconds();
   backoff_policy_.entry_lifetime_ms = -1;
   backoff_policy_.always_use_initial_delay = false;
   backoff_entry_ = base::MakeUnique<net::BackoffEntry>(&backoff_policy_);
   dispatch_closure_ =
       base::Bind(&TaskQueue::Dispatch, weak_ptr_factory_.GetWeakPtr());
   backoff_timer_ = base::MakeUnique<base::Timer>(false, false);
 }
 
 template <typename T>
+TaskQueue<T>::~TaskQueue() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+}
+
+template <typename T>
 void TaskQueue<T>::AddToQueue(const T& task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // Ignore duplicates.
   if (tasks_.find(task) == tasks_.end()) {
     queue_.push_back(task);
     tasks_.insert(task);
   }
   ScheduleDispatch();
 }
 
 template <typename T>
 void TaskQueue<T>::MarkAsSucceeded(const T& task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   FinishTask(task);
   // The task succeeded.  Stop any pending timer, reset (clear) the backoff, and
   // reschedule a dispatch.
   backoff_timer_->Stop();
   backoff_entry_->Reset();
   ScheduleDispatch();
 }
 
 template <typename T>
 void TaskQueue<T>::MarkAsFailed(const T& task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   FinishTask(task);
   backoff_entry_->InformOfRequest(false);
   ScheduleDispatch();
 }
 
 template <typename T>
 void TaskQueue<T>::Cancel(const T& task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   FinishTask(task);
   ScheduleDispatch();
 }
 
 template <typename T>
 void TaskQueue<T>::ResetBackoff() {
   backoff_timer_->Stop();
   backoff_entry_->Reset();
   ScheduleDispatch();
 }
 
 template <typename T>
 void TaskQueue<T>::SetTimerForTest(std::unique_ptr<base::Timer> timer) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(timer.get());
   backoff_timer_ = std::move(timer);
 }
 
 template <typename T>
 void TaskQueue<T>::FinishTask(const T& task) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_GE(num_in_progress_, 1);
   --num_in_progress_;
   const size_t num_erased = tasks_.erase(task);
   DCHECK_EQ(1U, num_erased);
 }
 
 template <typename T>
 void TaskQueue<T>::ScheduleDispatch() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (backoff_timer_->IsRunning() || !ShouldDispatch()) {
     return;
   }
 
   backoff_timer_->Start(FROM_HERE, backoff_entry_->GetTimeUntilRelease(),
                         dispatch_closure_);
 }
 
 template <typename T>
 void TaskQueue<T>::Dispatch() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!ShouldDispatch()) {
     return;
   }
 
   DCHECK(!queue_.empty());
   const T& task = queue_.front();
   ++num_in_progress_;
   DCHECK_LE(num_in_progress_, kMaxConcurrentTasks);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(process_callback_, task));
   queue_.pop_front();
 }
 
 template <typename T>
 bool TaskQueue<T>::ShouldDispatch() {
   return num_in_progress_ < kMaxConcurrentTasks && !queue_.empty();
 }
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_MODEL_IMPL_ATTACHMENTS_TASK_QUEUE_H_