[Sync] Rewriting ".reset(new" pattern to use "= base::MakeUnique" instead.

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/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
@@ skipping 148 matching lines @@
       num_in_progress_(0),
       weak_ptr_factory_(this) {
   DCHECK_LE(initial_backoff_delay.InMicroseconds(),
             max_backoff_delay.InMicroseconds());
   backoff_policy_.initial_delay_ms = initial_backoff_delay.InMilliseconds();
   backoff_policy_.multiply_factor = 2.0;
   backoff_policy_.jitter_factor = 0.1;
   backoff_policy_.maximum_backoff_ms = max_backoff_delay.InMilliseconds();
   backoff_policy_.entry_lifetime_ms = -1;
   backoff_policy_.always_use_initial_delay = false;
-  backoff_entry_.reset(new net::BackoffEntry(&backoff_policy_));
+  backoff_entry_ = base::MakeUnique<net::BackoffEntry>(&backoff_policy_);
   dispatch_closure_ =
       base::Bind(&TaskQueue::Dispatch, weak_ptr_factory_.GetWeakPtr());
-  backoff_timer_.reset(new base::Timer(false, false));
+  backoff_timer_ = base::MakeUnique<base::Timer>(false, false);
 }
 
 template <typename T>
 void TaskQueue<T>::AddToQueue(const T& task) {
   DCHECK(CalledOnValidThread());
   // Ignore duplicates.
   if (tasks_.find(task) == tasks_.end()) {
     queue_.push_back(task);
     tasks_.insert(task);
   }
@@ skipping 77 matching lines @@
 }
 
 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_