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

extensions/browser/event_router.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_EVENT_ROUTER_H_
 #define EXTENSIONS_BROWSER_EVENT_ROUTER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 77 matching lines @@
   // Sends an event via ipc_sender to the given extension. Can be called on any
   // thread.
   //
   // It is very rare to call this function directly. Instead use the instance
   // methods BroadcastEvent or DispatchEventToExtension.
   static void DispatchEventToSender(IPC::Sender* ipc_sender,
                                     void* browser_context_id,
                                     const std::string& extension_id,
                                     events::HistogramValue histogram_value,
                                     const std::string& event_name,
-                                    scoped_ptr<base::ListValue> event_args,
+                                    std::unique_ptr<base::ListValue> event_args,
                                     UserGestureState user_gesture,
                                     const EventFilteringInfo& info);
 
   // An EventRouter is shared between |browser_context| and its associated
   // incognito context. |extension_prefs| may be NULL in tests.
   EventRouter(content::BrowserContext* browser_context,
               ExtensionPrefs* extension_prefs);
   ~EventRouter() override;
 
   // Add or remove an extension as an event listener for |event_name|.
@@ skipping 58 matching lines @@
   virtual bool ExtensionHasEventListener(const std::string& extension_id,
                                          const std::string& event_name);
 
   // Return or set the list of events for which the given extension has
   // registered.
   std::set<std::string> GetRegisteredEvents(const std::string& extension_id);
   void SetRegisteredEvents(const std::string& extension_id,
                            const std::set<std::string>& events);
 
   // Broadcasts an event to every listener registered for that event.
-  virtual void BroadcastEvent(scoped_ptr<Event> event);
+  virtual void BroadcastEvent(std::unique_ptr<Event> event);
 
   // Dispatches an event to the given extension.
   virtual void DispatchEventToExtension(const std::string& extension_id,
-                                        scoped_ptr<Event> event);
+                                        std::unique_ptr<Event> event);
 
   // Dispatches |event| to the given extension as if the extension has a lazy
   // listener for it. NOTE: This should be used rarely, for dispatching events
   // to extensions that haven't had a chance to add their own listeners yet, eg:
   // newly installed extensions.
   void DispatchEventWithLazyListener(const std::string& extension_id,
-                                     scoped_ptr<Event> event);
+                                     std::unique_ptr<Event> event);
 
   // Record the Event Ack from the renderer. (One less event in-flight.)
   void OnEventAck(content::BrowserContext* context,
                   const std::string& extension_id);
 
   // Reports UMA for an event dispatched to |extension| with histogram value
   // |histogram_value|. Must be called on the UI thread.
   //
   // |did_enqueue| should be true if the event was queued waiting for a process
   // to start, like an event page.
@@ skipping 162 matching lines @@
 
   // The identifier for the event, for histograms. In most cases this
   // correlates 1:1 with |event_name|, in some cases events will generate
   // their own names, but they cannot generate their own identifier.
   events::HistogramValue histogram_value;
 
   // The event to dispatch.
   std::string event_name;
 
   // Arguments to send to the event listener.
-  scoped_ptr<base::ListValue> event_args;
+  std::unique_ptr<base::ListValue> event_args;
 
   // If non-NULL, then the event will not be sent to other BrowserContexts
   // unless the extension has permission (e.g. incognito tab update -> normal
   // tab only works if extension is allowed incognito access).
   content::BrowserContext* restrict_to_browser_context;
 
   // If not empty, the event is only sent to extensions with host permissions
   // for this url.
   GURL event_url;
 
   // Whether a user gesture triggered the event.
   EventRouter::UserGestureState user_gesture;
 
   // Extra information used to filter which events are sent to the listener.
   EventFilteringInfo filter_info;
 
   // If specified, this is called before dispatching an event to each
   // extension. The third argument is a mutable reference to event_args,
   // allowing the caller to provide different arguments depending on the
   // extension and profile. This is guaranteed to be called synchronously with
   // DispatchEvent, so callers don't need to worry about lifetime.
   //
   // NOTE: the Extension argument to this may be NULL because it's possible for
   // this event to be dispatched to non-extension processes, like WebUI.
   WillDispatchCallback will_dispatch_callback;
 
   Event(events::HistogramValue histogram_value,
         const std::string& event_name,
-        scoped_ptr<base::ListValue> event_args);
+        std::unique_ptr<base::ListValue> event_args);
 
   Event(events::HistogramValue histogram_value,
         const std::string& event_name,
-        scoped_ptr<base::ListValue> event_args,
+        std::unique_ptr<base::ListValue> event_args,
         content::BrowserContext* restrict_to_browser_context);
 
   Event(events::HistogramValue histogram_value,
         const std::string& event_name,
-        scoped_ptr<base::ListValue> event_args,
+        std::unique_ptr<base::ListValue> event_args,
         content::BrowserContext* restrict_to_browser_context,
         const GURL& event_url,
         EventRouter::UserGestureState user_gesture,
         const EventFilteringInfo& info);
 
   ~Event();
 
   // Makes a deep copy of this instance. Ownership is transferred to the
   // caller.
   Event* DeepCopy();
 };
 
 struct EventListenerInfo {
   EventListenerInfo(const std::string& event_name,
                     const std::string& extension_id,
                     const GURL& listener_url,
                     content::BrowserContext* browser_context);
   // The event name including any sub-event, e.g. "runtime.onStartup" or
   // "webRequest.onCompleted/123".
   const std::string event_name;
 
   const std::string extension_id;
   const GURL listener_url;
   content::BrowserContext* browser_context;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EVENT_ROUTER_H_