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

extensions/browser/api/alarms/alarms_api.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/alarms_api.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
@@ skipping 85 matching lines @@
 AlarmsCreateFunction::AlarmsCreateFunction(base::Clock* clock)
     : clock_(clock), owns_clock_(false) {
 }
 
 AlarmsCreateFunction::~AlarmsCreateFunction() {
   if (owns_clock_)
     delete clock_;
 }
 
 bool AlarmsCreateFunction::RunAsync() {
-  scoped_ptr<alarms::Create::Params> params(
+  std::unique_ptr<alarms::Create::Params> params(
       alarms::Create::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const std::string& alarm_name =
       params->name.get() ? *params->name : kDefaultAlarmName;
   std::vector<std::string> warnings;
   if (!ValidateAlarmCreateInfo(alarm_name, params->alarm_info, extension(),
                                &error_, &warnings)) {
     return false;
   }
   for (std::vector<std::string>::const_iterator it = warnings.begin();
@@ skipping 11 matching lines @@
                  base::Bind(&AlarmsCreateFunction::Callback, this));
 
   return true;
 }
 
 void AlarmsCreateFunction::Callback() {
   SendResponse(true);
 }
 
 bool AlarmsGetFunction::RunAsync() {
-  scoped_ptr<alarms::Get::Params> params(alarms::Get::Params::Create(*args_));
+  std::unique_ptr<alarms::Get::Params> params(
+      alarms::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
   AlarmManager::Get(browser_context())
       ->GetAlarm(extension_id(), name,
                  base::Bind(&AlarmsGetFunction::Callback, this, name));
 
   return true;
 }
 
 void AlarmsGetFunction::Callback(const std::string& name,
                                  extensions::Alarm* alarm) {
   if (alarm) {
     results_ = alarms::Get::Results::Create(*alarm->js_alarm);
   }
   SendResponse(true);
 }
 
 bool AlarmsGetAllFunction::RunAsync() {
   AlarmManager::Get(browser_context())
       ->GetAllAlarms(extension_id(),
                      base::Bind(&AlarmsGetAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsGetAllFunction::Callback(const AlarmList* alarms) {
-  scoped_ptr<base::ListValue> alarms_value(new base::ListValue());
+  std::unique_ptr<base::ListValue> alarms_value(new base::ListValue());
   if (alarms) {
     for (const Alarm& alarm : *alarms)
       alarms_value->Append(alarm.js_alarm->ToValue());
   }
   SetResult(std::move(alarms_value));
   SendResponse(true);
 }
 
 bool AlarmsClearFunction::RunAsync() {
-  scoped_ptr<alarms::Clear::Params> params(
+  std::unique_ptr<alarms::Clear::Params> params(
       alarms::Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   std::string name = params->name.get() ? *params->name : kDefaultAlarmName;
   AlarmManager::Get(browser_context())
       ->RemoveAlarm(extension_id(), name,
                     base::Bind(&AlarmsClearFunction::Callback, this, name));
 
   return true;
 }
 
 void AlarmsClearFunction::Callback(const std::string& name, bool success) {
   SetResult(new base::FundamentalValue(success));
   SendResponse(true);
 }
 
 bool AlarmsClearAllFunction::RunAsync() {
   AlarmManager::Get(browser_context())
       ->RemoveAllAlarms(extension_id(),
                         base::Bind(&AlarmsClearAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsClearAllFunction::Callback() {
   SetResult(new base::FundamentalValue(true));
   SendResponse(true);
 }
 
 }  // namespace extensions