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

chrome/browser/extensions/api/notification_provider/notification_provider_api.cc

 // Copyright 2014 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 "chrome/browser/extensions/api/notification_provider/notification_provider_api.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/guid.h"
@@ skipping 43 matching lines @@
     const std::string& sender_id,
     const std::string& notification_id) {
   Clear(notification_provider_id, sender_id, notification_id);
 }
 
 void NotificationProviderEventRouter::Create(
     const std::string& notification_provider_id,
     const std::string& sender_id,
     const std::string& notification_id,
     const api::notifications::NotificationOptions& options) {
-  scoped_ptr<base::ListValue> args =
-      api::notification_provider::OnCreated::Create(
-          sender_id, notification_id, options);
+  std::unique_ptr<base::ListValue> args =
+      api::notification_provider::OnCreated::Create(sender_id, notification_id,
+                                                    options);
 
-  scoped_ptr<Event> event(new Event(
+  std::unique_ptr<Event> event(new Event(
       events::NOTIFICATION_PROVIDER_ON_CREATED,
       api::notification_provider::OnCreated::kEventName, std::move(args)));
 
   EventRouter::Get(profile_)
       ->DispatchEventToExtension(notification_provider_id, std::move(event));
 }
 
 void NotificationProviderEventRouter::Update(
     const std::string& notification_provider_id,
     const std::string& sender_id,
     const std::string& notification_id,
     const api::notifications::NotificationOptions& options) {
-  scoped_ptr<base::ListValue> args =
-      api::notification_provider::OnUpdated::Create(
-          sender_id, notification_id, options);
+  std::unique_ptr<base::ListValue> args =
+      api::notification_provider::OnUpdated::Create(sender_id, notification_id,
+                                                    options);
 
-  scoped_ptr<Event> event(new Event(
+  std::unique_ptr<Event> event(new Event(
       events::NOTIFICATION_PROVIDER_ON_UPDATED,
       api::notification_provider::OnUpdated::kEventName, std::move(args)));
 
   EventRouter::Get(profile_)
       ->DispatchEventToExtension(notification_provider_id, std::move(event));
 }
 
 void NotificationProviderEventRouter::Clear(
     const std::string& notification_provider_id,
     const std::string& sender_id,
     const std::string& notification_id) {
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       api::notification_provider::OnCleared::Create(sender_id, notification_id);
 
-  scoped_ptr<Event> event(new Event(
+  std::unique_ptr<Event> event(new Event(
       events::NOTIFICATION_PROVIDER_ON_CLEARED,
       api::notification_provider::OnCleared::kEventName, std::move(args)));
 
   EventRouter::Get(profile_)
       ->DispatchEventToExtension(notification_provider_id, std::move(event));
 }
 
 NotificationProviderNotifyOnClearedFunction::
     NotificationProviderNotifyOnClearedFunction() {
 }
 
 NotificationProviderNotifyOnClearedFunction::
     ~NotificationProviderNotifyOnClearedFunction() {
 }
 
 ExtensionFunction::ResponseAction
 NotificationProviderNotifyOnClearedFunction::Run() {
-  scoped_ptr<api::notification_provider::NotifyOnCleared::Params> params =
+  std::unique_ptr<api::notification_provider::NotifyOnCleared::Params> params =
       api::notification_provider::NotifyOnCleared::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Notification* notification =
       g_browser_process->notification_ui_manager()->FindById(
           params->notification_id,
           NotificationUIManager::GetProfileID(GetProfile()));
 
   bool found_notification = notification != NULL;
   if (found_notification)
     notification->delegate()->Close(true);
 
   return RespondNow(
       ArgumentList(api::notification_provider::NotifyOnCleared::Results::Create(
           found_notification)));
 }
 
 NotificationProviderNotifyOnClickedFunction::
     NotificationProviderNotifyOnClickedFunction() {
 }
 
 NotificationProviderNotifyOnClickedFunction::
     ~NotificationProviderNotifyOnClickedFunction() {
 }
 
 ExtensionFunction::ResponseAction
 NotificationProviderNotifyOnClickedFunction::Run() {
-  scoped_ptr<api::notification_provider::NotifyOnClicked::Params> params =
+  std::unique_ptr<api::notification_provider::NotifyOnClicked::Params> params =
       api::notification_provider::NotifyOnClicked::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Notification* notification =
       g_browser_process->notification_ui_manager()->FindById(
           params->notification_id,
           NotificationUIManager::GetProfileID(GetProfile()));
 
   bool found_notification = notification != NULL;
   if (found_notification)
     notification->delegate()->Click();
 
   return RespondNow(
       ArgumentList(api::notification_provider::NotifyOnClicked::Results::Create(
           found_notification)));
 }
 
 NotificationProviderNotifyOnButtonClickedFunction::
     NotificationProviderNotifyOnButtonClickedFunction() {
 }
 
 NotificationProviderNotifyOnButtonClickedFunction::
     ~NotificationProviderNotifyOnButtonClickedFunction() {
 }
 
 ExtensionFunction::ResponseAction
 NotificationProviderNotifyOnButtonClickedFunction::Run() {
-  scoped_ptr<api::notification_provider::NotifyOnButtonClicked::Params> params =
-      api::notification_provider::NotifyOnButtonClicked::Params::Create(*args_);
+  std::unique_ptr<api::notification_provider::NotifyOnButtonClicked::Params>
+      params =
+          api::notification_provider::NotifyOnButtonClicked::Params::Create(
+              *args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Notification* notification =
       g_browser_process->notification_ui_manager()->FindById(
           params->notification_id,
           NotificationUIManager::GetProfileID(GetProfile()));
 
   bool found_notification = notification != NULL;
   if (found_notification)
     notification->delegate()->ButtonClick(params->button_index);
 
   return RespondNow(ArgumentList(
       api::notification_provider::NotifyOnButtonClicked::Results::Create(
           found_notification)));
 }
 
 NotificationProviderNotifyOnPermissionLevelChangedFunction::
     NotificationProviderNotifyOnPermissionLevelChangedFunction() {
 }
 
 NotificationProviderNotifyOnPermissionLevelChangedFunction::
     ~NotificationProviderNotifyOnPermissionLevelChangedFunction() {
 }
 
 ExtensionFunction::ResponseAction
 NotificationProviderNotifyOnPermissionLevelChangedFunction::Run() {
-  scoped_ptr<api::notification_provider::NotifyOnPermissionLevelChanged::Params>
+  std::unique_ptr<
+      api::notification_provider::NotifyOnPermissionLevelChanged::Params>
       params = api::notification_provider::NotifyOnPermissionLevelChanged::
           Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   // Third party apps/extensions with notification provider API will not be able
   // to change permission levels of web notifiers, because the list of allowed
   // websites should only be set in Chrome Settings manually by users. But they
   // are able to change permission levels of application type notifiers.
   bool is_application_type =
       (params->notifier_type ==
@@ skipping 21 matching lines @@
 NotificationProviderNotifyOnShowSettingsFunction::
     NotificationProviderNotifyOnShowSettingsFunction() {
 }
 
 NotificationProviderNotifyOnShowSettingsFunction::
     ~NotificationProviderNotifyOnShowSettingsFunction() {
 }
 
 ExtensionFunction::ResponseAction
 NotificationProviderNotifyOnShowSettingsFunction::Run() {
-  scoped_ptr<api::notification_provider::NotifyOnShowSettings::Params> params =
-      api::notification_provider::NotifyOnShowSettings::Params::Create(*args_);
+  std::unique_ptr<api::notification_provider::NotifyOnShowSettings::Params>
+      params = api::notification_provider::NotifyOnShowSettings::Params::Create(
+          *args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool has_advanced_settings;
   // Only application type notifiers have advanced settings.
   if (params->notifier_type ==
       api::notification_provider::NotifierType::NOTIFIER_TYPE_APPLICATION) {
     // TODO(dewittj): Refactor NotificationUIManage API to have a getter of
     // NotifierSettingsProvider, since it holds the settings provider.
     message_center::NotifierSettingsProvider* settings_provider =
         message_center::MessageCenter::Get()->GetNotifierSettingsProvider();
@@ skipping 41 matching lines @@
 
 ExtensionFunction::ResponseAction
 NotificationProviderGetAllNotifiersFunction::Run() {
   std::vector<api::notification_provider::Notifier> notifiers;
 
   return RespondNow(ArgumentList(
       api::notification_provider::GetAllNotifiers::Results::Create(notifiers)));
 }
 
 }  // namespace extensions