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

components/proximity_auth/cryptauth/sync_scheduler_impl_unittest.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 <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/timer/mock_timer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace proximity_auth {
 
 using Strategy = SyncScheduler::Strategy;
 using SyncState = SyncScheduler::SyncState;
 
 namespace {
 
@@ skipping 30 matching lines @@
                           refresh_period,
                           recovery_period,
                           max_jitter_ratio,
                           kTestSchedulerName) {}
 
   ~TestSyncSchedulerImpl() override {}
 
   base::MockTimer* timer() { return mock_timer_; }
 
  private:
-  scoped_ptr<base::Timer> CreateTimer() override {
+  std::unique_ptr<base::Timer> CreateTimer() override {
     bool retain_user_task = false;
     bool is_repeating = false;
     mock_timer_ = new base::MockTimer(retain_user_task, is_repeating);
-    return make_scoped_ptr(mock_timer_);
+    return base::WrapUnique(mock_timer_);
   }
 
   // A timer instance for testing. Owned by the parent scheduler.
   base::MockTimer* mock_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestSyncSchedulerImpl);
 };
 
 }  // namespace
 
 class ProximityAuthSyncSchedulerImplTest : public testing::Test,
                                            public SyncSchedulerImpl::Delegate {
  protected:
   ProximityAuthSyncSchedulerImplTest()
       : refresh_period_(base::TimeDelta::FromDays(kRefreshPeriodDays)),
         base_recovery_period_(
             base::TimeDelta::FromSeconds(kRecoveryPeriodSeconds)),
         zero_elapsed_time_(base::TimeDelta::FromSeconds(0)),
         scheduler_(new TestSyncSchedulerImpl(this,
                                              refresh_period_,
                                              base_recovery_period_,
                                              0)) {}
 
   ~ProximityAuthSyncSchedulerImplTest() override {}
 
   void OnSyncRequested(
-      scoped_ptr<SyncScheduler::SyncRequest> sync_request) override {
+      std::unique_ptr<SyncScheduler::SyncRequest> sync_request) override {
     sync_request_ = std::move(sync_request);
   }
 
   base::MockTimer* timer() { return scheduler_->timer(); }
 
   // The time deltas used to configure |scheduler_|.
   base::TimeDelta refresh_period_;
   base::TimeDelta base_recovery_period_;
   base::TimeDelta zero_elapsed_time_;
 
   // The scheduler instance under test.
-  scoped_ptr<TestSyncSchedulerImpl> scheduler_;
+  std::unique_ptr<TestSyncSchedulerImpl> scheduler_;
 
-  scoped_ptr<SyncScheduler::SyncRequest> sync_request_;
+  std::unique_ptr<SyncScheduler::SyncRequest> sync_request_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityAuthSyncSchedulerImplTest);
 };
 
 TEST_F(ProximityAuthSyncSchedulerImplTest, ForceSyncSuccess) {
   scheduler_->Start(zero_elapsed_time_, Strategy::PERIODIC_REFRESH);
   EXPECT_EQ(Strategy::PERIODIC_REFRESH, scheduler_->GetStrategy());
   EXPECT_EQ(SyncState::WAITING_FOR_REFRESH, scheduler_->GetSyncState());
 
   scheduler_->ForceSync();
@@ skipping 166 matching lines @@
   // This could happen in rare cases where the system clock changes.
   scheduler_->Start(base::TimeDelta::FromDays(-1000),
                     Strategy::PERIODIC_REFRESH);
 
   base::TimeDelta zero_delta = base::TimeDelta::FromSeconds(0);
   EXPECT_EQ(zero_delta, scheduler_->GetTimeToNextSync());
   EXPECT_EQ(zero_delta, timer()->GetCurrentDelay());
 }
 
 }  // namespace proximity_auth