Make AlarmManager::Alarm non copyable.

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/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 97 matching lines @@
     WriteToConsole(content::CONSOLE_MESSAGE_LEVEL_WARNING, *it);
 
   const int kSecondsPerMinute = 60;
   base::TimeDelta granularity =
       base::TimeDelta::FromSecondsD(
           (Manifest::IsUnpackedLocation(extension()->location())
                ? alarms_api_constants::kDevDelayMinimum
                : alarms_api_constants::kReleaseDelayMinimum)) *
       kSecondsPerMinute;
 
-  Alarm alarm(alarm_name, params->alarm_info, granularity, clock_->Now());
+  std::unique_ptr<Alarm> alarm(
+      new Alarm(alarm_name, params->alarm_info, granularity, clock_->Now()));
   AlarmManager::Get(browser_context())
-      ->AddAlarm(extension_id(), alarm,
+      ->AddAlarm(extension_id(), std::move(alarm),
                  base::Bind(&AlarmsCreateFunction::Callback, this));
 
   return true;
 }
 
 void AlarmsCreateFunction::Callback() {
   SendResponse(true);
 }
 
 bool AlarmsGetFunction::RunAsync() {
@@ skipping 20 matching lines @@
 bool AlarmsGetAllFunction::RunAsync() {
   AlarmManager::Get(browser_context())
       ->GetAllAlarms(extension_id(),
                      base::Bind(&AlarmsGetAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsGetAllFunction::Callback(const AlarmList* alarms) {
   std::unique_ptr<base::ListValue> alarms_value(new base::ListValue());
   if (alarms) {
-    for (const Alarm& alarm : *alarms)
-      alarms_value->Append(alarm.js_alarm->ToValue());
+    for (const std::unique_ptr<Alarm>& alarm : *alarms)
+      alarms_value->Append(alarm->js_alarm->ToValue());
   }
   SetResult(std::move(alarms_value));
   SendResponse(true);
 }
 
 bool AlarmsClearFunction::RunAsync() {
   std::unique_ptr<alarms::Clear::Params> params(
       alarms::Clear::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
@@ skipping 16 matching lines @@
                         base::Bind(&AlarmsClearAllFunction::Callback, this));
   return true;
 }
 
 void AlarmsClearAllFunction::Callback() {
   SetResult(base::MakeUnique<base::FundamentalValue>(true));
   SendResponse(true);
 }
 
 }  // namespace extensions