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

chrome/browser/extensions/api/notifications/notifications_api.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 "chrome/browser/extensions/api/notifications/notifications_api.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 138 matching lines @@
     shutdown_notifier_subscription_ =
         ShutdownNotifierFactory::GetInstance()->Get(profile)->Subscribe(
             base::Bind(&NotificationsApiDelegate::Shutdown,
                        base::Unretained(this)));
   }
 
   void Close(bool by_user) override {
     EventRouter::UserGestureState gesture =
         by_user ? EventRouter::USER_GESTURE_ENABLED
                 : EventRouter::USER_GESTURE_NOT_ENABLED;
-    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
+    std::unique_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(new base::FundamentalValue(by_user));
     SendEvent(events::NOTIFICATIONS_ON_CLOSED,
               notifications::OnClosed::kEventName, gesture, std::move(args));
   }
 
   void Click() override {
-    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
+    std::unique_ptr<base::ListValue> args(CreateBaseEventArgs());
     SendEvent(events::NOTIFICATIONS_ON_CLICKED,
               notifications::OnClicked::kEventName,
               EventRouter::USER_GESTURE_ENABLED, std::move(args));
   }
 
   bool HasClickedListener() override {
     if (!event_router_)
       return false;
 
     return event_router_->HasEventListener(
         notifications::OnClicked::kEventName);
   }
 
   void ButtonClick(int index) override {
-    scoped_ptr<base::ListValue> args(CreateBaseEventArgs());
+    std::unique_ptr<base::ListValue> args(CreateBaseEventArgs());
     args->Append(new base::FundamentalValue(index));
     SendEvent(events::NOTIFICATIONS_ON_BUTTON_CLICKED,
               notifications::OnButtonClicked::kEventName,
               EventRouter::USER_GESTURE_ENABLED, std::move(args));
   }
 
   std::string id() const override { return scoped_id_; }
 
  private:
   ~NotificationsApiDelegate() override {}
 
   void SendEvent(events::HistogramValue histogram_value,
                  const std::string& name,
                  EventRouter::UserGestureState user_gesture,
-                 scoped_ptr<base::ListValue> args) {
+                 std::unique_ptr<base::ListValue> args) {
     if (!event_router_)
       return;
 
-    scoped_ptr<Event> event(new Event(histogram_value, name, std::move(args)));
+    std::unique_ptr<Event> event(
+        new Event(histogram_value, name, std::move(args)));
     event->user_gesture = user_gesture;
     event_router_->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
   void Shutdown() {
     event_router_ = nullptr;
     shutdown_notifier_subscription_.reset();
   }
 
-  scoped_ptr<base::ListValue> CreateBaseEventArgs() {
-    scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> CreateBaseEventArgs() {
+    std::unique_ptr<base::ListValue> args(new base::ListValue());
     args->Append(new base::StringValue(id_));
     return args;
   }
 
   scoped_refptr<ChromeAsyncExtensionFunction> api_function_;
 
   // Since this class is refcounted it may outlive the profile.  We listen for
   // profile-keyed service shutdown events and reset to nullptr at that time,
   // so make sure to check for a valid pointer before use.
   EventRouter* event_router_;
 
   const std::string extension_id_;
   const std::string id_;
   const std::string scoped_id_;
 
-  scoped_ptr<KeyedServiceShutdownNotifier::Subscription>
+  std::unique_ptr<KeyedServiceShutdownNotifier::Subscription>
       shutdown_notifier_subscription_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationsApiDelegate);
 };
 
 }  // namespace
 
 bool NotificationsApiFunction::IsNotificationsApiAvailable() {
   // We need to check this explicitly rather than letting
   // _permission_features.json enforce it, because we're sharing the
@@ skipping 443 matching lines @@
 
 NotificationsGetAllFunction::~NotificationsGetAllFunction() {}
 
 bool NotificationsGetAllFunction::RunNotificationsApi() {
   NotificationUIManager* notification_ui_manager =
       g_browser_process->notification_ui_manager();
   std::set<std::string> notification_ids =
       notification_ui_manager->GetAllIdsByProfileAndSourceOrigin(
           NotificationUIManager::GetProfileID(GetProfile()), extension_->url());
 
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 
   for (std::set<std::string>::iterator iter = notification_ids.begin();
        iter != notification_ids.end(); iter++) {
     result->SetBooleanWithoutPathExpansion(
         StripScopeFromIdentifier(extension_->id(), *iter), true);
   }
 
   SetResult(result.release());
   SendResponse(true);
 
@@ skipping 16 matching lines @@
           ? api::notifications::PERMISSION_LEVEL_GRANTED
           : api::notifications::PERMISSION_LEVEL_DENIED;
 
   SetResult(new base::StringValue(api::notifications::ToString(result)));
   SendResponse(true);
 
   return true;
 }
 
 }  // namespace extensions