Convert //sync from scoped_ptr to std::unique_ptr

sync/internal_api/public/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 SYNC_INTERNAL_API_PUBLIC_ATTACHMENTS_TASK_QUEUE_H_
 #define SYNC_INTERNAL_API_PUBLIC_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/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/non_thread_safe.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
@@ skipping 100 matching lines @@
   // Reset any backoff delay and resume dispatching of tasks.
   //
   // Useful for when you know the cause of previous failures has been resolved
   // and you want don't want to wait for the accumulated backoff delay to
   // elapse.
   void ResetBackoff();
 
   // Use |timer| for scheduled events.
   //
   // Used in tests.  See also MockTimer.
-  void SetTimerForTest(scoped_ptr<base::Timer> timer);
+  void SetTimerForTest(std::unique_ptr<base::Timer> timer);
 
  private:
   void FinishTask(const T& task);
   void ScheduleDispatch();
   void Dispatch();
   // Return true if we should dispatch tasks.
   bool ShouldDispatch();
 
   const HandleTaskCallback process_callback_;
   net::BackoffEntry::Policy backoff_policy_;
-  scoped_ptr<net::BackoffEntry> backoff_entry_;
+  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_;
-  scoped_ptr<base::Timer> backoff_timer_;
+  std::unique_ptr<base::Timer> backoff_timer_;
   base::TimeDelta delay_;
 
   // 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
@@ skipping 60 matching lines @@
 }
 
 template <typename T>
 void TaskQueue<T>::ResetBackoff() {
   backoff_timer_->Stop();
   backoff_entry_->Reset();
   ScheduleDispatch();
 }
 
 template <typename T>
-void TaskQueue<T>::SetTimerForTest(scoped_ptr<base::Timer> timer) {
+void TaskQueue<T>::SetTimerForTest(std::unique_ptr<base::Timer> timer) {
   DCHECK(CalledOnValidThread());
   DCHECK(timer.get());
   backoff_timer_ = std::move(timer);
 }
 
 template <typename T>
 void TaskQueue<T>::FinishTask(const T& task) {
   DCHECK(CalledOnValidThread());
   DCHECK_GE(num_in_progress_, 1);
   --num_in_progress_;
@@ skipping 29 matching lines @@
 }
 
 template <typename T>
 bool TaskQueue<T>::ShouldDispatch() {
   return num_in_progress_ < kMaxConcurrentTasks && !queue_.empty();
 }
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_ATTACHMENTS_TASK_QUEUE_H_