Make AlarmManager::Alarm non copyable.

extensions/browser/api/alarms/alarm_manager.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_API_ALARMS_ALARM_MANAGER_H_
 #define EXTENSIONS_BROWSER_API_ALARMS_ALARM_MANAGER_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 20 matching lines @@
 namespace extensions {
 class ExtensionAlarmsSchedulingTest;
 class ExtensionRegistry;
 
 struct Alarm {
   Alarm();
   Alarm(const std::string& name,
         const api::alarms::AlarmCreateInfo& create_info,
         base::TimeDelta min_granularity,
         base::Time now);
-  Alarm(const Alarm& other);
   ~Alarm();
 
-  linked_ptr<api::alarms::Alarm> js_alarm;
+  std::unique_ptr<api::alarms::Alarm> js_alarm;
   // The granularity isn't exposed to the extension's javascript, but we poll at
   // least as often as the shortest alarm's granularity.  It's initialized as
   // the relative delay requested in creation, even if creation uses an absolute
   // time.  This will always be at least as large as the min_granularity
   // constructor argument.
   base::TimeDelta granularity;
   // The minimum granularity is the minimum allowed polling rate. This stops
   // alarms from polling too often.
   base::TimeDelta minimum_granularity;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Alarm);
 };
 
 // Manages the currently pending alarms for every extension in a profile.
 // There is one manager per virtual Profile.
 class AlarmManager : public BrowserContextKeyedAPI,
                      public ExtensionRegistryObserver,
                      public base::SupportsWeakPtr<AlarmManager> {
  public:
-  typedef std::vector<Alarm> AlarmList;
+  using AlarmList = std::vector<std::unique_ptr<Alarm>>;
 
   class Delegate {
    public:
     virtual ~Delegate() {}
     // Called when an alarm fires.
     virtual void OnAlarm(const std::string& extension_id,
                          const Alarm& alarm) = 0;
   };
 
   explicit AlarmManager(content::BrowserContext* context);
   ~AlarmManager() override;
 
   // Override the default delegate. Callee assumes onwership. Used for testing.
   void set_delegate(Delegate* delegate) { delegate_.reset(delegate); }
 
   typedef base::Callback<void()> AddAlarmCallback;
   // Adds |alarm| for the given extension, and starts the timer. Invokes
   // |callback| when done.
   void AddAlarm(const std::string& extension_id,
-                const Alarm& alarm,
+                std::unique_ptr<Alarm> alarm,
                 const AddAlarmCallback& callback);
 
   typedef base::Callback<void(Alarm*)> GetAlarmCallback;
   // Passes the alarm with the given name, or NULL if none exists, to
   // |callback|.
   void GetAlarm(const std::string& extension_id,
                 const std::string& name,
                 const GetAlarmCallback& callback);
 
   typedef base::Callback<void(const AlarmList*)> GetAllAlarmsCallback;
@@ skipping 45 matching lines @@
 
   typedef base::Callback<void(const std::string&)> ReadyAction;
   typedef std::queue<ReadyAction> ReadyQueue;
   typedef std::map<ExtensionId, ReadyQueue> ReadyMap;
 
   // Iterator used to identify a particular alarm within the Map/List pair.
   // "Not found" is represented by <alarms_.end(), invalid_iterator>.
   typedef std::pair<AlarmMap::iterator, AlarmList::iterator> AlarmIterator;
 
   // Part of AddAlarm that is executed after alarms are loaded.
-  void AddAlarmWhenReady(const Alarm& alarm,
+  void AddAlarmWhenReady(std::unique_ptr<Alarm> alarm,
                          const AddAlarmCallback& callback,
                          const std::string& extension_id);
 
   // Part of GetAlarm that is executed after alarms are loaded.
   void GetAlarmWhenReady(const std::string& name,
                          const GetAlarmCallback& callback,
                          const std::string& extension_id);
 
   // Part of GetAllAlarms that is executed after alarms are loaded.
   void GetAllAlarmsWhenReady(const GetAllAlarmsCallback& callback,
@@ skipping 15 matching lines @@
                                  const std::string& name);
 
   // Helper to cancel and remove the alarm at the given iterator. The iterator
   // must be valid.
   void RemoveAlarmIterator(const AlarmIterator& iter);
 
   // Callback for when an alarm fires.
   void OnAlarm(AlarmIterator iter);
 
   // Internal helper to add an alarm and start the timer with the given delay.
-  void AddAlarmImpl(const std::string& extension_id, const Alarm& alarm);
+  void AddAlarmImpl(const std::string& extension_id,
+                    std::unique_ptr<Alarm> alarm);
 
   // Syncs our alarm data for the given extension to/from the state storage.
   void WriteToStorage(const std::string& extension_id);
   void ReadFromStorage(const std::string& extension_id,
                        bool is_unpacked,
                        std::unique_ptr<base::Value> value);
 
   // Set the timer to go off at the specified |time|, and set |next_poll_time|
   // appropriately.
   void SetNextPollTime(const base::Time& time);
@@ skipping 45 matching lines @@
 
   // Next poll's time.
   base::Time next_poll_time_;
 
   DISALLOW_COPY_AND_ASSIGN(AlarmManager);
 };
 
 }  //  namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_ALARMS_ALARM_MANAGER_H_