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

chrome/browser/extensions/api/braille_display_private/braille_display_private_api.cc

 // Copyright 2013 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/braille_display_private/braille_display_private_api.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "build/build_config.h"
@@ skipping 15 matching lines @@
 using extensions::api::braille_display_private::BrailleController;
 
 namespace extensions {
 
 class BrailleDisplayPrivateAPI::DefaultEventDelegate
     : public BrailleDisplayPrivateAPI::EventDelegate {
  public:
   DefaultEventDelegate(EventRouter::Observer* observer, Profile* profile);
   ~DefaultEventDelegate() override;
 
-  void BroadcastEvent(scoped_ptr<Event> event) override;
+  void BroadcastEvent(std::unique_ptr<Event> event) override;
   bool HasListener() override;
 
  private:
   EventRouter::Observer* observer_;
   Profile* profile_;
 };
 
 BrailleDisplayPrivateAPI::BrailleDisplayPrivateAPI(
     content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)),
@@ skipping 11 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<BrailleDisplayPrivateAPI>*
 BrailleDisplayPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void BrailleDisplayPrivateAPI::OnBrailleDisplayStateChanged(
     const DisplayState& display_state) {
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::BRAILLE_DISPLAY_PRIVATE_ON_DISPLAY_STATE_CHANGED,
                 OnDisplayStateChanged::kEventName,
                 OnDisplayStateChanged::Create(display_state)));
   event_delegate_->BroadcastEvent(std::move(event));
 }
 
 void BrailleDisplayPrivateAPI::OnBrailleKeyEvent(const KeyEvent& key_event) {
   // Key events only go to extensions of the active profile.
   if (!IsProfileActive())
     return;
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::BRAILLE_DISPLAY_PRIVATE_ON_KEY_EVENT,
                 OnKeyEvent::kEventName, OnKeyEvent::Create(key_event)));
   event_delegate_->BroadcastEvent(std::move(event));
 }
 
 bool BrailleDisplayPrivateAPI::IsProfileActive() {
 #if defined(OS_CHROMEOS)
   Profile* active_profile;
   chromeos::ScreenLocker* screen_locker =
       chromeos::ScreenLocker::default_screen_locker();
   if (screen_locker && screen_locker->locked()) {
     active_profile = chromeos::ProfileHelper::GetSigninProfile();
   } else {
     // Since we are creating one instance per profile / user, we should be fine
     // comparing against the active user. That said - if we ever change that,
     // this code will need to be changed.
     active_profile = ProfileManager::GetActiveUserProfile();
   }
   return profile_->IsSameProfile(active_profile);
 #else  // !defined(OS_CHROMEOS)
   return true;
 #endif
 }
 
 void BrailleDisplayPrivateAPI::SetEventDelegateForTest(
-    scoped_ptr<EventDelegate> delegate) {
+    std::unique_ptr<EventDelegate> delegate) {
   event_delegate_ = std::move(delegate);
 }
 
 void BrailleDisplayPrivateAPI::OnListenerAdded(
     const EventListenerInfo& details) {
   BrailleController* braille_controller = BrailleController::GetInstance();
   if (!scoped_observer_.IsObserving(braille_controller))
     scoped_observer_.Add(braille_controller);
 }
 
@@ skipping 12 matching lines @@
   EventRouter* event_router = EventRouter::Get(profile_);
   event_router->RegisterObserver(observer_, OnDisplayStateChanged::kEventName);
   event_router->RegisterObserver(observer_, OnKeyEvent::kEventName);
 }
 
 BrailleDisplayPrivateAPI::DefaultEventDelegate::~DefaultEventDelegate() {
   EventRouter::Get(profile_)->UnregisterObserver(observer_);
 }
 
 void BrailleDisplayPrivateAPI::DefaultEventDelegate::BroadcastEvent(
-    scoped_ptr<Event> event) {
+    std::unique_ptr<Event> event) {
   EventRouter::Get(profile_)->BroadcastEvent(std::move(event));
 }
 
 bool BrailleDisplayPrivateAPI::DefaultEventDelegate::HasListener() {
   EventRouter* event_router = EventRouter::Get(profile_);
   return (event_router->HasEventListener(OnDisplayStateChanged::kEventName) ||
           event_router->HasEventListener(OnKeyEvent::kEventName));
 }
 
 namespace api {
@@ skipping 26 matching lines @@
 
 void BrailleDisplayPrivateWriteDotsFunction::Work() {
   BrailleController::GetInstance()->WriteDots(params_->cells);
 }
 
 bool BrailleDisplayPrivateWriteDotsFunction::Respond() {
   return true;
 }
 }  // namespace api
 }  // namespace extensions