Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

components/proximity_auth/cryptauth/sync_scheduler_impl.cc

 // Copyright 2015 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/proximity_auth/cryptauth/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
 #include "components/proximity_auth/logging/logging.h"
 
 namespace proximity_auth {
 
 namespace {
 
 // Returns a human readable string given a |time_delta|.
@@ skipping 83 matching lines @@
     sync_state_ = SyncState::SYNC_IN_PROGRESS;
   } else if (strategy_ == Strategy::AGGRESSIVE_RECOVERY) {
     PA_LOG(INFO) << "Timer fired for aggressive recovery, making request...";
     sync_state_ = SyncState::SYNC_IN_PROGRESS;
   } else {
     NOTREACHED();
     return;
   }
 
   delegate_->OnSyncRequested(
-      make_scoped_ptr(new SyncRequest(weak_ptr_factory_.GetWeakPtr())));
+      base::WrapUnique(new SyncRequest(weak_ptr_factory_.GetWeakPtr())));
 }
 
-scoped_ptr<base::Timer> SyncSchedulerImpl::CreateTimer() {
+std::unique_ptr<base::Timer> SyncSchedulerImpl::CreateTimer() {
   bool retain_user_task = false;
   bool is_repeating = false;
-  return make_scoped_ptr(new base::Timer(retain_user_task, is_repeating));
+  return base::WrapUnique(new base::Timer(retain_user_task, is_repeating));
 }
 
 void SyncSchedulerImpl::ScheduleNextSync(const base::TimeDelta& sync_delta) {
   if (sync_state_ != SyncState::WAITING_FOR_REFRESH) {
     PA_LOG(ERROR) << "Unexpected state when scheduling next sync: sync_state="
                   << static_cast<int>(sync_state_);
     return;
   }
 
   bool is_aggressive_recovery = (strategy_ == Strategy::AGGRESSIVE_RECOVERY);
@@ skipping 55 matching lines @@
     base::TimeDelta backoff_period = base_recovery_period_ * backoff_factor;
     return backoff_period < refresh_period_ ? backoff_period : refresh_period_;
   } else {
     PA_LOG(ERROR) << "Error getting period for strategy: "
                   << static_cast<int>(strategy_);
     return base::TimeDelta();
   }
 }
 
 }  // namespace proximity_auth