Convert //extensions/browser/api from scoped_ptr to std::unique_ptr

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/test/simple_test_clock.h"
 #include "base/values.h"
@@ skipping 79 matching lines @@
   // 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}]",
         "[\"7\", {\"periodInMinutes\": 7}]",
         "[\"0\", {\"delayInMinutes\": 0}]",
     };
     for (size_t i = 0; i < num_alarms; ++i) {
-      scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDictionary(
-          new AlarmsCreateFunction(test_clock_), kCreateArgs[i]));
+      std::unique_ptr<base::DictionaryValue> result(
+          RunFunctionAndReturnDictionary(new AlarmsCreateFunction(test_clock_),
+                                         kCreateArgs[i]));
       EXPECT_FALSE(result.get());
     }
   }
 
   base::SimpleTestClock* test_clock_;
   AlarmManager* alarm_manager_;
   AlarmDelegate* alarm_delegate_;
 };
 
 void ExtensionAlarmsTestGetAllAlarmsCallback(
@@ skipping 207 matching lines @@
 
 TEST_F(ExtensionAlarmsTest, Get) {
   test_clock_->SetNow(base::Time::FromDoubleT(4));
 
   // Create 2 alarms, and make sure we can query them.
   CreateAlarms(2);
 
   // Get the default one.
   {
     JsAlarm alarm;
-    scoped_ptr<base::DictionaryValue> result(
+    std::unique_ptr<base::DictionaryValue> result(
         RunFunctionAndReturnDictionary(new AlarmsGetFunction(), "[null]"));
     ASSERT_TRUE(result.get());
     EXPECT_TRUE(JsAlarm::Populate(*result, &alarm));
     EXPECT_EQ("", alarm.name);
     EXPECT_DOUBLE_EQ(4060, alarm.scheduled_time);
     EXPECT_THAT(alarm.period_in_minutes,
                 testing::Pointee(testing::DoubleEq(0.001)));
   }
 
   // Get "7".
   {
     JsAlarm alarm;
-    scoped_ptr<base::DictionaryValue> result(
+    std::unique_ptr<base::DictionaryValue> result(
         RunFunctionAndReturnDictionary(new AlarmsGetFunction(), "[\"7\"]"));
     ASSERT_TRUE(result.get());
     EXPECT_TRUE(JsAlarm::Populate(*result, &alarm));
     EXPECT_EQ("7", alarm.name);
     EXPECT_EQ(424000, alarm.scheduled_time);
     EXPECT_THAT(alarm.period_in_minutes, testing::Pointee(7));
   }
 
   // Get a non-existent one.
   {
-    scoped_ptr<base::DictionaryValue> result(RunFunctionAndReturnDictionary(
-        new AlarmsGetFunction(), "[\"nobody\"]"));
+    std::unique_ptr<base::DictionaryValue> result(
+        RunFunctionAndReturnDictionary(new AlarmsGetFunction(),
+                                       "[\"nobody\"]"));
     ASSERT_FALSE(result.get());
   }
 }
 
 TEST_F(ExtensionAlarmsTest, GetAll) {
   // Test getAll with 0 alarms.
   {
-    scoped_ptr<base::ListValue> result(
+    std::unique_ptr<base::ListValue> result(
         RunFunctionAndReturnList(new AlarmsGetAllFunction(), "[]"));
     std::vector<linked_ptr<JsAlarm>> alarms = ToAlarmList(result.get());
     EXPECT_EQ(0u, alarms.size());
   }
 
   // Create 2 alarms, and make sure we can query them.
   CreateAlarms(2);
 
   {
-    scoped_ptr<base::ListValue> result(
+    std::unique_ptr<base::ListValue> result(
         RunFunctionAndReturnList(new AlarmsGetAllFunction(), "[null]"));
     std::vector<linked_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 28 matching lines @@
 
   // Ensure the 0.001-minute alarm is still there, since it's repeating.
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
       base::Bind(ExtensionAlarmsTestClearGetAllAlarms2Callback));
 }
 
 TEST_F(ExtensionAlarmsTest, Clear) {
   // Clear a non-existent one.
   {
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new AlarmsClearFunction(), "[\"nobody\"]"));
     bool copy_bool_result = false;
     ASSERT_TRUE(result->GetAsBoolean(&copy_bool_result));
     EXPECT_FALSE(copy_bool_result);
   }
 
   // Create 3 alarms.
   CreateAlarms(3);
 
   // Clear all but the 0.001-minute alarm.
   {
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new AlarmsClearFunction(), "[\"7\"]"));
     bool copy_bool_result = false;
     ASSERT_TRUE(result->GetAsBoolean(&copy_bool_result));
     EXPECT_TRUE(copy_bool_result);
   }
   {
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new AlarmsClearFunction(), "[\"0\"]"));
     bool copy_bool_result = false;
     ASSERT_TRUE(result->GetAsBoolean(&copy_bool_result));
     EXPECT_TRUE(copy_bool_result);
   }
 
   alarm_manager_->GetAllAlarms(
       extension()->id(),
       base::Bind(ExtensionAlarmsTestClearGetAllAlarms1Callback, this));
 }
@@ skipping 12 matching lines @@
   // Clear them.
   test->RunFunction(new AlarmsClearAllFunction(), "[]");
   test->alarm_manager_->GetAllAlarms(
       test->extension()->id(),
       base::Bind(ExtensionAlarmsTestClearAllGetAllAlarms2Callback));
 }
 
 TEST_F(ExtensionAlarmsTest, ClearAll) {
   // ClearAll with no alarms set.
   {
-    scoped_ptr<base::Value> result(
+    std::unique_ptr<base::Value> result(
         RunFunctionAndReturnValue(new AlarmsClearAllFunction(), "[]"));
     bool copy_bool_result = false;
     ASSERT_TRUE(result->GetAsBoolean(&copy_bool_result));
     EXPECT_TRUE(copy_bool_result);
   }
 
   // Create 3 alarms.
   CreateAlarms(3);
   alarm_manager_->GetAllAlarms(
       extension()->id(),
@@ skipping 207 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