Make AlarmManager::Alarm non copyable.

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/test/simple_test_clock.h"
@@ skipping 258 matching lines @@
       extension()->id(), std::string(),
       base::Bind(
           ExtensionAlarmsTestCreateRepeatingWithQuickFirstCallGetAlarm1Callback,
           this));
 }
 
 void ExtensionAlarmsTestCreateDupeGetAllAlarmsCallback(
     const AlarmManager::AlarmList* alarms) {
   ASSERT_TRUE(alarms);
   EXPECT_EQ(1u, alarms->size());
-  EXPECT_DOUBLE_EQ(430000, (*alarms)[0].js_alarm->scheduled_time);
+  EXPECT_DOUBLE_EQ(430000, (*alarms)[0]->js_alarm->scheduled_time);
 }
 
 TEST_F(ExtensionAlarmsTest, CreateDupe) {
   test_clock_->SetNow(base::Time::FromDoubleT(10));
 
   // Create 2 duplicate alarms. The first should be overridden.
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 1}]");
   CreateAlarm("[\"dup\", {\"delayInMinutes\": 7}]");
 
   alarm_manager_->GetAllAlarms(
@@ skipping 95 matching lines @@
     EXPECT_EQ("7", alarm->name);
     EXPECT_THAT(alarm->period_in_minutes, testing::Pointee(7));
   }
 }
 
 void ExtensionAlarmsTestClearGetAllAlarms2Callback(
     const AlarmManager::AlarmList* alarms) {
   // Ensure the 0.001-minute alarm is still there, since it's repeating.
   ASSERT_TRUE(alarms);
   EXPECT_EQ(1u, alarms->size());
-  EXPECT_THAT((*alarms)[0].js_alarm->period_in_minutes,
+  EXPECT_THAT((*alarms)[0]->js_alarm->period_in_minutes,
               testing::Pointee(0.001));
 }
 
 void ExtensionAlarmsTestClearGetAllAlarms1Callback(
     ExtensionAlarmsTest* test,
     const AlarmManager::AlarmList* alarms) {
   ASSERT_TRUE(alarms);
   EXPECT_EQ(1u, alarms->size());
-  EXPECT_THAT((*alarms)[0].js_alarm->period_in_minutes,
+  EXPECT_THAT((*alarms)[0]->js_alarm->period_in_minutes,
               testing::Pointee(0.001));
 
   // Now wait for the alarms to fire, and ensure the cancelled alarms don't
   // fire.
   test->test_clock_->Advance(base::TimeDelta::FromMilliseconds(60));
   RunScheduleNextPoll(test->alarm_manager_);
   base::MessageLoop::current()->Run();
 
   ASSERT_EQ(1u, test->alarm_delegate_->alarms_seen.size());
   EXPECT_EQ("", test->alarm_delegate_->alarms_seen[0]);
@@ skipping 115 matching lines @@
   }
   {
     CreateAlarm("[\"a\", {\"delayInMinutes\": 10}]");
     CreateAlarm("[\"bb\", {\"delayInMinutes\": 21}]");
     VerifyScheduledTime("a");
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(10));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 10}]");
-    Alarm alarm;
-    alarm.js_alarm->name = "bb";
-    alarm.js_alarm->scheduled_time = 30 * 60000;
-    alarm.js_alarm->period_in_minutes.reset(new double(30));
-    alarm_manager_->AddAlarmImpl(extension()->id(), alarm);
+    std::unique_ptr<Alarm> alarm(new Alarm);
+    alarm->js_alarm->name = "bb";
+    alarm->js_alarm->scheduled_time = 30 * 60000;
+    alarm->js_alarm->period_in_minutes.reset(new double(30));
+    alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm));
     VerifyScheduledTime("a");
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(3 * 60 + 1));
-    Alarm alarm;
-    alarm.js_alarm->name = "bb";
-    alarm.js_alarm->scheduled_time = 3 * 60000;
-    alarm.js_alarm->period_in_minutes.reset(new double(3));
-    alarm_manager_->AddAlarmImpl(extension()->id(), alarm);
+    std::unique_ptr<Alarm> alarm(new Alarm);
+    alarm->js_alarm->name = "bb";
+    alarm->js_alarm->scheduled_time = 3 * 60000;
+    alarm->js_alarm->period_in_minutes.reset(new double(3));
+    alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm));
     base::MessageLoop::current()->Run();
     EXPECT_EQ(
         base::Time::FromJsTime(3 * 60000) + base::TimeDelta::FromMinutes(3),
         alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
   {
     test_clock_->SetNow(base::Time::FromDoubleT(4 * 60 + 1));
     CreateAlarm("[\"a\", {\"periodInMinutes\": 2}]");
     RemoveAlarm("a");
-    Alarm alarm2;
-    alarm2.js_alarm->name = "bb";
-    alarm2.js_alarm->scheduled_time = 4 * 60000;
-    alarm2.js_alarm->period_in_minutes.reset(new double(4));
-    alarm_manager_->AddAlarmImpl(extension()->id(), alarm2);
-    Alarm alarm3;
-    alarm3.js_alarm->name = "ccc";
-    alarm3.js_alarm->scheduled_time = 25 * 60000;
-    alarm3.js_alarm->period_in_minutes.reset(new double(25));
-    alarm_manager_->AddAlarmImpl(extension()->id(), alarm3);
+    std::unique_ptr<Alarm> alarm2(new Alarm);
+    alarm2->js_alarm->name = "bb";
+    alarm2->js_alarm->scheduled_time = 4 * 60000;
+    alarm2->js_alarm->period_in_minutes.reset(new double(4));
+    alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm2));
+    std::unique_ptr<Alarm> alarm3(new Alarm);
+    alarm3->js_alarm->name = "ccc";
+    alarm3->js_alarm->scheduled_time = 25 * 60000;
+    alarm3->js_alarm->period_in_minutes.reset(new double(25));
+    alarm_manager_->AddAlarmImpl(extension()->id(), std::move(alarm3));
     base::MessageLoop::current()->Run();
     EXPECT_EQ(
         base::Time::FromJsTime(4 * 60000) + base::TimeDelta::FromMinutes(4),
         alarm_manager_->next_poll_time_);
     RemoveAllAlarms();
   }
 }
 
 TEST_F(ExtensionAlarmsSchedulingTest, ReleasedExtensionPollsInfrequently) {
   set_extension(
@@ skipping 168 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