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

extensions/browser/api/bluetooth/bluetooth_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/api/bluetooth/bluetooth_event_router.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 119 matching lines @@
     return;
   }
 
   // Check whether user pre set discovery filter by calling SetDiscoveryFilter
   // before. If the user has set a discovery filter then start a filtered
   // discovery session, otherwise start a regular session
   PreSetFilterMap::iterator pre_set_iter =
       pre_set_filter_map_.find(extension_id);
   if (pre_set_iter != pre_set_filter_map_.end()) {
     adapter->StartDiscoverySessionWithFilter(
-        scoped_ptr<device::BluetoothDiscoveryFilter>(pre_set_iter->second),
+        std::unique_ptr<device::BluetoothDiscoveryFilter>(pre_set_iter->second),
         base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
                    weak_ptr_factory_.GetWeakPtr(), extension_id, callback),
         error_callback);
     pre_set_filter_map_.erase(pre_set_iter);
     return;
   }
   adapter->StartDiscoverySession(
       base::Bind(&BluetoothEventRouter::OnStartDiscoverySession,
                  weak_ptr_factory_.GetWeakPtr(), extension_id, callback),
       error_callback);
@@ skipping 13 matching lines @@
   if (iter == discovery_session_map_.end() || !iter->second->IsActive()) {
     DVLOG(1) << "No active discovery session exists for extension.";
     error_callback.Run();
     return;
   }
   device::BluetoothDiscoverySession* session = iter->second;
   session->Stop(callback, error_callback);
 }
 
 void BluetoothEventRouter::SetDiscoveryFilter(
-    scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter,
+    std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter,
     device::BluetoothAdapter* adapter,
     const std::string& extension_id,
     const base::Closure& callback,
     const base::Closure& error_callback) {
   DVLOG(1) << "SetDiscoveryFilter";
   if (adapter != adapter_.get()) {
     error_callback.Run();
     return;
   }
 
@@ skipping 185 matching lines @@
     num_event_listeners_--;
   MaybeReleaseAdapter();
 }
 
 void BluetoothEventRouter::DispatchAdapterStateEvent() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   api::bluetooth::AdapterState state;
   CHECK(adapter_.get());
   PopulateAdapterState(*adapter_.get(), &state);
 
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       bluetooth::OnAdapterStateChanged::Create(state);
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::BLUETOOTH_ON_ADAPTER_STATE_CHANGED,
                 bluetooth::OnAdapterStateChanged::kEventName, std::move(args)));
   EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
 }
 
 void BluetoothEventRouter::DispatchDeviceEvent(
     events::HistogramValue histogram_value,
     const std::string& event_name,
     device::BluetoothDevice* device) {
   bluetooth::Device extension_device;
   CHECK(device);
   bluetooth::BluetoothDeviceToApiDevice(*device, &extension_device);
 
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       bluetooth::OnDeviceAdded::Create(extension_device);
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(histogram_value, event_name, std::move(args)));
   EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
 }
 
 void BluetoothEventRouter::CleanUpForExtension(
     const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   RemovePairingDelegate(extension_id);
 
   PreSetFilterMap::iterator pre_set_iter =
@@ skipping 24 matching lines @@
   discovery_session_map_.clear();
 
   PairingDelegateMap::iterator pairing_iter = pairing_delegate_map_.begin();
   while (pairing_iter != pairing_delegate_map_.end())
     RemovePairingDelegate(pairing_iter++->first);
 }
 
 void BluetoothEventRouter::OnStartDiscoverySession(
     const std::string& extension_id,
     const base::Closure& callback,
-    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
+    std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   // Clean up any existing session instance for the extension.
   DiscoverySessionMap::iterator iter =
       discovery_session_map_.find(extension_id);
   if (iter != discovery_session_map_.end())
     delete iter->second;
   discovery_session_map_[extension_id] = discovery_session.release();
   callback.Run();
 }
 
 void BluetoothEventRouter::OnSetDiscoveryFilter(const std::string& extension_id,
@@ skipping 13 matching lines @@
 }
 
 void BluetoothEventRouter::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   CleanUpForExtension(extension->id());
 }
 
 }  // namespace extensions