Convert //components/[f-n]* from scoped_ptr to std::unique_ptr

components/network_time/network_time_tracker_unittest.cc

 // 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.
 
 #include "components/network_time/network_time_tracker.h"
 
+#include <memory>
+
 #include "base/compiler_specific.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "components/network_time/network_time_pref_names.h"
 #include "components/prefs/testing_pref_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace network_time {
 
 class NetworkTimeTrackerTest : public testing::Test {
  public:
   ~NetworkTimeTrackerTest() override {}
 
   void SetUp() override {
     NetworkTimeTracker::RegisterPrefs(pref_service_.registry());
 
     clock_ = new base::SimpleTestClock();
     tick_clock_ = new base::SimpleTestTickClock();
     // Do this to be sure that |is_null| returns false.
     clock_->Advance(base::TimeDelta::FromDays(111));
     tick_clock_->Advance(base::TimeDelta::FromDays(222));
 
     tracker_.reset(new NetworkTimeTracker(
-        scoped_ptr<base::Clock>(clock_),
-        scoped_ptr<base::TickClock>(tick_clock_),
-        &pref_service_));
+        std::unique_ptr<base::Clock>(clock_),
+        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_));
 
     // Can not be smaller than 15, it's the NowFromSystemTime() resolution.
     resolution_ = base::TimeDelta::FromMilliseconds(17);
     latency_ = base::TimeDelta::FromMilliseconds(50);
     adjustment_ = 7 * base::TimeDelta::FromMilliseconds(kTicksResolutionMs);
   }
 
   // Replaces |tracker_| with a new object, while preserving the
   // testing clocks.
   void Reset() {
     base::SimpleTestClock* new_clock = new base::SimpleTestClock();
     new_clock->SetNow(clock_->Now());
     base::SimpleTestTickClock* new_tick_clock = new base::SimpleTestTickClock();
     new_tick_clock->SetNowTicks(tick_clock_->NowTicks());
     clock_ = new_clock;
     tick_clock_= new_tick_clock;
     tracker_.reset(new NetworkTimeTracker(
-        scoped_ptr<base::Clock>(clock_),
-        scoped_ptr<base::TickClock>(tick_clock_),
-        &pref_service_));
+        std::unique_ptr<base::Clock>(clock_),
+        std::unique_ptr<base::TickClock>(tick_clock_), &pref_service_));
   }
 
   // Updates the notifier's time with the specified parameters.
   void UpdateNetworkTime(const base::Time& network_time,
                          const base::TimeDelta& resolution,
                          const base::TimeDelta& latency,
                          const base::TimeTicks& post_time) {
     tracker_->UpdateNetworkTime(
         network_time, resolution, latency, post_time);
   }
 
   // Advances both the system clock and the tick clock.  This should be used for
   // the normal passage of time, i.e. when neither clock is doing anything odd.
   void AdvanceBoth(const base::TimeDelta& delta) {
     tick_clock_->Advance(delta);
     clock_->Advance(delta);
   }
 
  protected:
   base::TimeDelta resolution_;
   base::TimeDelta latency_;
   base::TimeDelta adjustment_;
   base::SimpleTestClock* clock_;
   base::SimpleTestTickClock* tick_clock_;
   TestingPrefServiceSimple pref_service_;
-  scoped_ptr<NetworkTimeTracker> tracker_;
+  std::unique_ptr<NetworkTimeTracker> tracker_;
 };
 
 TEST_F(NetworkTimeTrackerTest, Uninitialized) {
   base::Time network_time;
   base::TimeDelta uncertainty;
   EXPECT_FALSE(tracker_->GetNetworkTime(&network_time, &uncertainty));
 }
 
 TEST_F(NetworkTimeTrackerTest, LongPostingDelay) {
   // The request arrives at the server, which records the time.  Advance the
@@ skipping 196 matching lines @@
                     tick_clock_->NowTicks());
 
   base::Time out_network_time;
   EXPECT_TRUE(tracker_->GetNetworkTime(&out_network_time, NULL));
   clock_->Advance(base::TimeDelta::FromDays(1));
   Reset();
   EXPECT_FALSE(tracker_->GetNetworkTime(&out_network_time, NULL));
 }
 
 }  // namespace network_time