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

extensions/browser/api/idle/idle_manager.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/api/idle/idle_manager.h"
 
 #include <utility>
 
 #include "base/stl_util.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 29 matching lines @@
 
 DefaultEventDelegate::DefaultEventDelegate(content::BrowserContext* context)
     : context_(context) {
 }
 
 DefaultEventDelegate::~DefaultEventDelegate() {
 }
 
 void DefaultEventDelegate::OnStateChanged(const std::string& extension_id,
                                           ui::IdleState new_state) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(IdleManager::CreateIdleValue(new_state));
-  scoped_ptr<Event> event(new Event(events::IDLE_ON_STATE_CHANGED,
-                                    idle::OnStateChanged::kEventName,
-                                    std::move(args)));
+  std::unique_ptr<Event> event(new Event(events::IDLE_ON_STATE_CHANGED,
+                                         idle::OnStateChanged::kEventName,
+                                         std::move(args)));
   event->restrict_to_browser_context = context_;
   EventRouter::Get(context_)
       ->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void DefaultEventDelegate::RegisterObserver(EventRouter::Observer* observer) {
   EventRouter::Get(context_)
       ->RegisterObserver(observer, idle::OnStateChanged::kEventName);
 }
 
@@ skipping 123 matching lines @@
   } else if (idle_state == ui::IDLE_STATE_IDLE) {
     description = keys::kStateIdle;
   } else {
     description = keys::kStateLocked;
   }
 
   return new base::StringValue(description);
 }
 
 void IdleManager::SetEventDelegateForTest(
-    scoped_ptr<EventDelegate> event_delegate) {
+    std::unique_ptr<EventDelegate> event_delegate) {
   DCHECK(thread_checker_.CalledOnValidThread());
   event_delegate_ = std::move(event_delegate);
 }
 
 void IdleManager::SetIdleTimeProviderForTest(
-    scoped_ptr<IdleTimeProvider> idle_time_provider) {
+    std::unique_ptr<IdleTimeProvider> idle_time_provider) {
   DCHECK(thread_checker_.CalledOnValidThread());
   idle_time_provider_ = std::move(idle_time_provider);
 }
 
 IdleMonitor* IdleManager::GetMonitor(const std::string& extension_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   MonitorMap::iterator it = monitors_.find(extension_id);
 
   if (it == monitors_.end()) {
     it = monitors_.insert(std::make_pair(extension_id,
@@ skipping 39 matching lines @@
       event_delegate_->OnStateChanged(it->first, new_state);
     monitor.last_state = new_state;
     listener_count += monitor.listeners;
   }
 
   if (listener_count == 0)
     StopPolling();
 }
 
 }  // namespace extensions