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

extensions/browser/api/alarms/alarm_manager.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.
 
 #include "extensions/browser/api/alarms/alarm_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 27 matching lines @@
   return base::TimeDelta::FromDays(1);
 }
 
 class DefaultAlarmDelegate : public AlarmManager::Delegate {
  public:
   explicit DefaultAlarmDelegate(content::BrowserContext* context)
       : browser_context_(context) {}
   ~DefaultAlarmDelegate() override {}
 
   void OnAlarm(const std::string& extension_id, const Alarm& alarm) override {
-    scoped_ptr<base::ListValue> args(new base::ListValue());
+    std::unique_ptr<base::ListValue> args(new base::ListValue());
     args->Append(alarm.js_alarm->ToValue().release());
-    scoped_ptr<Event> event(new Event(
+    std::unique_ptr<Event> event(new Event(
         events::ALARMS_ON_ALARM, alarms::OnAlarm::kEventName, std::move(args)));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(extension_id, std::move(event));
   }
 
  private:
   content::BrowserContext* browser_context_;
 };
 
 // Creates a TimeDelta from a delay as specified in the API.
@@ skipping 11 matching lines @@
         alarms::Alarm::Populate(*alarm_dict, alarm.js_alarm.get())) {
       const base::Value* time_value = NULL;
       if (alarm_dict->Get(kAlarmGranularity, &time_value))
         base::GetValueAsTimeDelta(*time_value, &alarm.granularity);
       alarms.push_back(alarm);
     }
   }
   return alarms;
 }
 
-scoped_ptr<base::ListValue> AlarmsToValue(const std::vector<Alarm>& alarms) {
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+std::unique_ptr<base::ListValue> AlarmsToValue(
+    const std::vector<Alarm>& alarms) {
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (size_t i = 0; i < alarms.size(); ++i) {
-    scoped_ptr<base::DictionaryValue> alarm = alarms[i].js_alarm->ToValue();
+    std::unique_ptr<base::DictionaryValue> alarm =
+        alarms[i].js_alarm->ToValue();
     alarm->Set(kAlarmGranularity,
                base::CreateTimeDeltaValue(alarms[i].granularity));
     list->Append(alarm.release());
   }
   return list;
 }
 
 }  // namespace
 
 // AlarmManager
@@ skipping 187 matching lines @@
       base::Time::FromJsTime(alarm.js_alarm->scheduled_time);
   if (next_poll_time_.is_null() || alarm_time < next_poll_time_)
     SetNextPollTime(alarm_time);
 }
 
 void AlarmManager::WriteToStorage(const std::string& extension_id) {
   StateStore* storage = ExtensionSystem::Get(browser_context_)->state_store();
   if (!storage)
     return;
 
-  scoped_ptr<base::Value> alarms;
+  std::unique_ptr<base::Value> alarms;
   AlarmMap::iterator list = alarms_.find(extension_id);
   if (list != alarms_.end())
     alarms.reset(AlarmsToValue(list->second).release());
   else
     alarms.reset(AlarmsToValue(std::vector<Alarm>()).release());
   storage->SetExtensionValue(extension_id, kRegisteredAlarms,
                              std::move(alarms));
 }
 
 void AlarmManager::ReadFromStorage(const std::string& extension_id,
-                                   scoped_ptr<base::Value> value) {
+                                   std::unique_ptr<base::Value> value) {
   base::ListValue* list = NULL;
   if (value.get() && value->GetAsList(&list)) {
     std::vector<Alarm> alarm_states = AlarmsFromValue(list);
     for (size_t i = 0; i < alarm_states.size(); ++i)
       AddAlarmImpl(extension_id, alarm_states[i]);
   }
 
   ReadyQueue& extension_ready_queue = ready_actions_[extension_id];
   while (!extension_ready_queue.empty()) {
     extension_ready_queue.front().Run(extension_id);
@@ skipping 149 matching lines @@
         new double(*create_info.period_in_minutes));
   }
 }
 
 Alarm::Alarm(const Alarm& other) = default;
 
 Alarm::~Alarm() {
 }
 
 }  // namespace extensions