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

components/sync/engine_impl/sync_scheduler_impl.cc

 // Copyright (c) 2012 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.
 
 #include "components/sync/engine_impl/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/sync/base/data_type_histogram.h"
 #include "components/sync/base/logging.h"
 #include "components/sync/engine_impl/backoff_delay_provider.h"
 #include "components/sync/protocol/proto_enum_conversions.h"
 #include "components/sync/protocol/sync.pb.h"
 
 using base::TimeDelta;
@@ skipping 292 matching lines @@
   // for a pending configure job.
   DCHECK(!pending_configure_params_);
 
   ModelSafeRoutingInfo restricted_routes;
   BuildModelSafeParams(params.types_to_download, params.routing_info,
                        &restricted_routes);
   cycle_context_->SetRoutingInfo(restricted_routes);
 
   // Only reconfigure if we have types to download.
   if (!params.types_to_download.Empty()) {
-    pending_configure_params_.reset(new ConfigurationParams(params));
+    pending_configure_params_ = base::MakeUnique<ConfigurationParams>(params);
     TrySyncCycleJob();
   } else {
     SDVLOG(2) << "No change in routing info, calling ready task directly.";
     params.ready_task.Run();
   }
 }
 
 void SyncSchedulerImpl::ScheduleClearServerData(const ClearParams& params) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(CLEAR_SERVER_DATA_MODE, mode_);
   DCHECK(!pending_configure_params_);
   DCHECK(!params.report_success_task.is_null());
   CHECK(started_) << "Scheduler must be running to clear.";
-  pending_clear_params_.reset(new ClearParams(params));
+  pending_clear_params_ = base::MakeUnique<ClearParams>(params);
   TrySyncCycleJob();
 }
 
 bool SyncSchedulerImpl::CanRunJobNow(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   if (IsCurrentlyThrottled()) {
     SDVLOG(1) << "Unable to run a job because we're throttled.";
     return false;
   }
 
@@ skipping 224 matching lines @@
 }
 
 void SyncSchedulerImpl::HandleFailure(
     const ModelNeutralState& model_neutral_state) {
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Was throttled during previous sync cycle.";
   } else if (!IsBackingOff()) {
     // Setup our backoff if this is our first such failure.
     TimeDelta length = delay_provider_->GetDelay(
         delay_provider_->GetInitialDelay(model_neutral_state));
-    wait_interval_.reset(
-        new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
+    wait_interval_ = base::MakeUnique<WaitInterval>(
+        WaitInterval::EXPONENTIAL_BACKOFF, length);
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
   } else {
     // Increase our backoff interval and schedule another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
-    wait_interval_.reset(
-        new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
+    wait_interval_ = base::MakeUnique<WaitInterval>(
+        WaitInterval::EXPONENTIAL_BACKOFF, length);
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
   }
   RestartWaiting();
 }
 
 void SyncSchedulerImpl::DoPollSyncCycleJob() {
   SDVLOG(2) << "Polling with types "
             << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
   std::unique_ptr<SyncCycle> cycle(SyncCycle::Build(cycle_context_, this));
@@ skipping 157 matching lines @@
     // error states should trigger a canary job.
     DCHECK(IsCurrentlyThrottled() || IsBackingOff() ||
            cycle_context_->connection_manager()->HasInvalidAuthToken());
   }
 
   if (IsBackingOff() && !pending_wakeup_timer_.IsRunning()) {
     // If we succeeded, our wait interval would have been cleared.  If it hasn't
     // been cleared, then we should increase our backoff interval and schedule
     // another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
-    wait_interval_.reset(
-        new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
+    wait_interval_ = base::MakeUnique<WaitInterval>(
+        WaitInterval::EXPONENTIAL_BACKOFF, length);
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
               << wait_interval_->length.InMilliseconds() << "ms.";
     RestartWaiting();
   }
 }
 
 void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK(CalledOnValidThread());
   CHECK(!syncer_->IsSyncing());
 
@@ skipping 69 matching lines @@
 }
 
 bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK(CalledOnValidThread());
   return wait_interval_.get() &&
          wait_interval_->mode == WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
 void SyncSchedulerImpl::OnThrottled(const base::TimeDelta& throttle_duration) {
   DCHECK(CalledOnValidThread());
-  wait_interval_.reset(
-      new WaitInterval(WaitInterval::THROTTLED, throttle_duration));
+  wait_interval_ = base::MakeUnique<WaitInterval>(WaitInterval::THROTTLED,
+                                                  throttle_duration);
   NotifyRetryTime(base::Time::Now() + wait_interval_->length);
   NotifyThrottledTypesChanged(ModelTypeSet::All());
 }
 
 void SyncSchedulerImpl::OnTypesThrottled(
     ModelTypeSet types,
     const base::TimeDelta& throttle_duration) {
   base::TimeTicks now = base::TimeTicks::Now();
 
   SDVLOG(1) << "Throttling " << ModelTypeSetToString(types) << " for "
@@ skipping 86 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer