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

extensions/browser/event_router.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/event_router.h"
 
 #include <stddef.h>
 
 #include <tuple>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/api_activity_monitor.h"
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
@@ skipping 29 matching lines @@
 // A dictionary of event names to lists of filters that this extension has
 // registered from its lazy background page.
 const char kFilteredEvents[] = "filtered_events";
 
 // Sends a notification about an event to the API activity monitor and the
 // ExtensionHost for |extension_id| on the UI thread. Can be called from any
 // thread.
 void NotifyEventDispatched(void* browser_context_id,
                            const std::string& extension_id,
                            const std::string& event_name,
-                           scoped_ptr<ListValue> args) {
+                           std::unique_ptr<ListValue> args) {
   // The ApiActivityMonitor can only be accessed from the UI thread.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&NotifyEventDispatched, browser_context_id, extension_id,
                    event_name, base::Passed(&args)));
     return;
   }
 
   // Notify the ApiActivityMonitor about the event dispatch.
@@ skipping 30 matching lines @@
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* browser_context_id,
                                            const std::string& extension_id,
                                            int event_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
   NotifyEventDispatched(browser_context_id, extension_id, event_name,
-                        make_scoped_ptr(event_args->DeepCopy()));
+                        base::WrapUnique(event_args->DeepCopy()));
 
   // TODO(chirantan): Make event dispatch a separate IPC so that it doesn't
   // piggyback off MessageInvoke, which is used for other things.
   ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
   args.Set(3, new base::FundamentalValue(event_id));
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
       MSG_ROUTING_CONTROL,
       extension_id,
       kEventBindings,
       "dispatchEvent",
       args,
       user_gesture == USER_GESTURE_ENABLED));
 
   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
   // must ensure that the destruction of args does not attempt to free it.
-  scoped_ptr<base::Value> removed_event_args;
+  std::unique_ptr<base::Value> removed_event_args;
   args.Remove(1, &removed_event_args);
   ignore_result(removed_event_args.release());
 }
 
 // static
 EventRouter* EventRouter::Get(content::BrowserContext* browser_context) {
   return EventRouterFactory::GetForBrowserContext(browser_context);
 }
 
 // static
 std::string EventRouter::GetBaseEventName(const std::string& full_event_name) {
   size_t slash_sep = full_event_name.find('/');
   return full_event_name.substr(0, slash_sep);
 }
 
 // static
 void EventRouter::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<ListValue> event_args,
+                                        std::unique_ptr<ListValue> event_args,
                                         UserGestureState user_gesture,
                                         const EventFilteringInfo& info) {
   int event_id = g_extension_event_id.GetNext();
 
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     DoDispatchEventToSenderBookkeepingOnUI(browser_context_id, extension_id,
                                            event_id, histogram_value,
                                            event_name);
   } else {
     // This is called from WebRequest API.
@@ skipping 24 matching lines @@
 
 EventRouter::~EventRouter() {
   for (auto process : observed_process_set_)
     process->RemoveObserver(this);
 }
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(EventListener::ForExtension(
-      event_name, extension_id, process, scoped_ptr<DictionaryValue>()));
+      event_name, extension_id, process, std::unique_ptr<DictionaryValue>()));
 }
 
 void EventRouter::RemoveEventListener(const std::string& event_name,
                                       content::RenderProcessHost* process,
                                       const std::string& extension_id) {
-  scoped_ptr<EventListener> listener = EventListener::ForExtension(
-      event_name, extension_id, process, scoped_ptr<DictionaryValue>());
+  std::unique_ptr<EventListener> listener = EventListener::ForExtension(
+      event_name, extension_id, process, std::unique_ptr<DictionaryValue>());
   listeners_.RemoveListener(listener.get());
 }
 
 void EventRouter::AddEventListenerForURL(const std::string& event_name,
                                          content::RenderProcessHost* process,
                                          const GURL& listener_url) {
   listeners_.AddListener(EventListener::ForURL(
-      event_name, listener_url, process, scoped_ptr<DictionaryValue>()));
+      event_name, listener_url, process, std::unique_ptr<DictionaryValue>()));
 }
 
 void EventRouter::RemoveEventListenerForURL(const std::string& event_name,
                                             content::RenderProcessHost* process,
                                             const GURL& listener_url) {
-  scoped_ptr<EventListener> listener = EventListener::ForURL(
-      event_name, listener_url, process, scoped_ptr<DictionaryValue>());
+  std::unique_ptr<EventListener> listener = EventListener::ForURL(
+      event_name, listener_url, process, std::unique_ptr<DictionaryValue>());
   listeners_.RemoveListener(listener.get());
 }
 
 void EventRouter::RegisterObserver(Observer* observer,
                                    const std::string& event_name) {
   // Observing sub-event names like "foo.onBar/123" is not allowed.
   DCHECK(event_name.find('/') == std::string::npos);
   observers_[event_name] = observer;
 }
 
@@ skipping 47 matching lines @@
 
 void EventRouter::RenderProcessHostDestroyed(content::RenderProcessHost* host) {
   listeners_.RemoveListenersForProcess(host);
   observed_process_set_.erase(host);
   host->RemoveObserver(this);
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const std::string& extension_id) {
   bool is_new = listeners_.AddListener(EventListener::ForExtension(
-      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
+      event_name, extension_id, NULL, std::unique_ptr<DictionaryValue>()));
 
   if (is_new) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
                                           const std::string& extension_id) {
-  scoped_ptr<EventListener> listener = EventListener::ForExtension(
-      event_name, extension_id, NULL, scoped_ptr<DictionaryValue>());
+  std::unique_ptr<EventListener> listener = EventListener::ForExtension(
+      event_name, extension_id, NULL, std::unique_ptr<DictionaryValue>());
   bool did_exist = listeners_.RemoveListener(listener.get());
 
   if (did_exist) {
     std::set<std::string> events = GetRegisteredEvents(extension_id);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     SetRegisteredEvents(extension_id, events);
   }
 }
 
 void EventRouter::AddFilteredEventListener(const std::string& event_name,
                                            content::RenderProcessHost* process,
                                            const std::string& extension_id,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(EventListener::ForExtension(
-      event_name,
-      extension_id,
-      process,
-      scoped_ptr<DictionaryValue>(filter.DeepCopy())));
+      event_name, extension_id, process,
+      std::unique_ptr<DictionaryValue>(filter.DeepCopy())));
 
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(EventListener::ForExtension(
-        event_name,
-        extension_id,
-        NULL,
-        scoped_ptr<DictionaryValue>(filter.DeepCopy())));
+        event_name, extension_id, NULL,
+        std::unique_ptr<DictionaryValue>(filter.DeepCopy())));
 
     if (added)
       AddFilterToEvent(event_name, extension_id, &filter);
   }
 }
 
 void EventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool remove_lazy_listener) {
-  scoped_ptr<EventListener> listener = EventListener::ForExtension(
-      event_name,
-      extension_id,
-      process,
-      scoped_ptr<DictionaryValue>(filter.DeepCopy()));
+  std::unique_ptr<EventListener> listener = EventListener::ForExtension(
+      event_name, extension_id, process,
+      std::unique_ptr<DictionaryValue>(filter.DeepCopy()));
 
   listeners_.RemoveListener(listener.get());
 
   if (remove_lazy_listener) {
     listener->MakeLazy();
     bool removed = listeners_.RemoveListener(listener.get());
 
     if (removed)
       RemoveFilterFromEvent(event_name, extension_id, &filter);
   }
@@ skipping 98 matching lines @@
 }
 
 const DictionaryValue* EventRouter::GetFilteredEvents(
     const std::string& extension_id) {
   const DictionaryValue* events = NULL;
   extension_prefs_->ReadPrefAsDictionary(
       extension_id, kFilteredEvents, &events);
   return events;
 }
 
-void EventRouter::BroadcastEvent(scoped_ptr<Event> event) {
+void EventRouter::BroadcastEvent(std::unique_ptr<Event> event) {
   DispatchEventImpl(std::string(), linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
-                                           scoped_ptr<Event> event) {
+                                           std::unique_ptr<Event> event) {
   DCHECK(!extension_id.empty());
   DispatchEventImpl(extension_id, linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventWithLazyListener(const std::string& extension_id,
-                                                scoped_ptr<Event> event) {
+                                                std::unique_ptr<Event> event) {
   DCHECK(!extension_id.empty());
   std::string event_name = event->event_name;
   bool has_listener = ExtensionHasEventListener(extension_id, event_name);
   if (!has_listener)
     AddLazyEventListener(event_name, extension_id);
   DispatchEventToExtension(extension_id, std::move(event));
   if (!has_listener)
     RemoveLazyEventListener(event_name, extension_id);
 }
 
@@ skipping 361 matching lines @@
 
 void EventRouter::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   // Remove all registered listeners from our cache.
   listeners_.RemoveListenersForExtension(extension->id());
 }
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
-             scoped_ptr<base::ListValue> event_args)
+             std::unique_ptr<base::ListValue> event_args)
     : Event(histogram_value, event_name, std::move(event_args), nullptr) {}
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
-             scoped_ptr<base::ListValue> event_args,
+             std::unique_ptr<base::ListValue> event_args,
              BrowserContext* restrict_to_browser_context)
     : Event(histogram_value,
             event_name,
             std::move(event_args),
             restrict_to_browser_context,
             GURL(),
             EventRouter::USER_GESTURE_UNKNOWN,
             EventFilteringInfo()) {}
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
-             scoped_ptr<ListValue> event_args_tmp,
+             std::unique_ptr<ListValue> event_args_tmp,
              BrowserContext* restrict_to_browser_context,
              const GURL& event_url,
              EventRouter::UserGestureState user_gesture,
              const EventFilteringInfo& filter_info)
     : histogram_value(histogram_value),
       event_name(event_name),
       event_args(std::move(event_args_tmp)),
       restrict_to_browser_context(restrict_to_browser_context),
       event_url(event_url),
       user_gesture(user_gesture),
       filter_info(filter_info) {
   DCHECK(event_args);
   DCHECK_NE(events::UNKNOWN, histogram_value)
       << "events::UNKNOWN cannot be used as a histogram value.\n"
       << "If this is a test, use events::FOR_TEST.\n"
       << "If this is production code, it is important that you use a realistic "
       << "value so that we can accurately track event usage. "
       << "See extension_event_histogram_value.h for inspiration.";
 }
 
 Event::~Event() {}
 
 Event* Event::DeepCopy() {
-  Event* copy = new Event(histogram_value, event_name,
-                          scoped_ptr<base::ListValue>(event_args->DeepCopy()),
-                          restrict_to_browser_context, event_url, user_gesture,
-                          filter_info);
+  Event* copy = new Event(
+      histogram_value, event_name,
+      std::unique_ptr<base::ListValue>(event_args->DeepCopy()),
+      restrict_to_browser_context, event_url, user_gesture, filter_info);
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions