Some linked_ptr -> unique_ptr conversion in extensions/browser.

extensions/browser/api/alarms/alarms_api_unittest.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.
 
 // This file tests the chrome.alarms extension API.
 
 #include <stddef.h>
 
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
@@ skipping 57 matching lines @@
 
     test_clock_->SetNow(base::Time::FromDoubleT(10));
   }
 
   void CreateAlarm(const std::string& args) {
     RunFunction(new AlarmsCreateFunction(test_clock_), args);
   }
 
   // Takes a JSON result from a function and converts it to a vector of
   // JsAlarms.
-  std::vector<linked_ptr<JsAlarm>> ToAlarmList(base::ListValue* value) {
-    std::vector<linked_ptr<JsAlarm>> list;
+  std::vector<std::unique_ptr<JsAlarm>> ToAlarmList(base::ListValue* value) {
+    std::vector<std::unique_ptr<JsAlarm>> list;
     for (size_t i = 0; i < value->GetSize(); ++i) {
-      linked_ptr<JsAlarm> alarm(new JsAlarm);
+      std::unique_ptr<JsAlarm> alarm(new JsAlarm());
       base::DictionaryValue* alarm_value;
       if (!value->GetDictionary(i, &alarm_value)) {
         ADD_FAILURE() << "Expected a list of Alarm objects.";
         return list;
       }
       EXPECT_TRUE(JsAlarm::Populate(*alarm_value, alarm.get()));
-      list.push_back(alarm);
+      list.push_back(std::move(alarm));
     }
     return list;
   }
 
   // Creates up to 3 alarms using the extension API.
   void CreateAlarms(size_t num_alarms) {
     CHECK_LE(num_alarms, 3U);
 
     const char* const kCreateArgs[] = {
         "[null, {\"periodInMinutes\": 0.001}]",
@@ skipping 260 matching lines @@
                                        "[\"nobody\"]"));
     ASSERT_FALSE(result.get());
   }
 }
 
 TEST_F(ExtensionAlarmsTest, GetAll) {
   // Test getAll with 0 alarms.
   {
     std::unique_ptr<base::ListValue> result(
         RunFunctionAndReturnList(new AlarmsGetAllFunction(), "[]"));
-    std::vector<linked_ptr<JsAlarm>> alarms = ToAlarmList(result.get());
+    std::vector<std::unique_ptr<JsAlarm>> alarms = ToAlarmList(result.get());
     EXPECT_EQ(0u, alarms.size());
   }
 
   // Create 2 alarms, and make sure we can query them.
   CreateAlarms(2);
 
   {
     std::unique_ptr<base::ListValue> result(
         RunFunctionAndReturnList(new AlarmsGetAllFunction(), "[null]"));
-    std::vector<linked_ptr<JsAlarm>> alarms = ToAlarmList(result.get());
+    std::vector<std::unique_ptr<JsAlarm>> alarms = ToAlarmList(result.get());
     EXPECT_EQ(2u, alarms.size());
 
     // Test the "7" alarm.
     JsAlarm* alarm = alarms[0].get();
     if (alarm->name != "7")
       alarm = alarms[1].get();
     EXPECT_EQ("7", alarm->name);
     EXPECT_THAT(alarm->period_in_minutes, testing::Pointee(7));
   }
 }
@@ skipping 364 matching lines @@
 
   // The next poll should be the first poll that hasn't happened and is in-line
   // with the original scheduling.
   // Last poll was at 380 seconds; next poll should be at 480 seconds.
   EXPECT_DOUBLE_EQ((alarm_manager_->last_poll_time_ +
                     base::TimeDelta::FromSeconds(100)).ToJsTime(),
                    alarm_manager_->next_poll_time_.ToJsTime());
 }
 
 }  // namespace extensions