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

extensions/browser/api/bluetooth/bluetooth_private_apitest.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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "extensions/browser/api/bluetooth/bluetooth_api.h"
 #include "extensions/browser/api/bluetooth/bluetooth_event_router.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/bluetooth_private.h"
 #include "extensions/common/switches.h"
@@ skipping 79 matching lines @@
   }
 
   void DispatchPairingEvent(bt_private::PairingEventType pairing_event_type) {
     bt_private::PairingEvent pairing_event;
     pairing_event.pairing = pairing_event_type;
     pairing_event.device.name.reset(new std::string(kDeviceName));
     pairing_event.device.address = mock_device_->GetAddress();
     pairing_event.device.vendor_id_source = bt::VENDOR_ID_SOURCE_USB;
     pairing_event.device.type = bt::DEVICE_TYPE_PHONE;
 
-    scoped_ptr<base::ListValue> args =
+    std::unique_ptr<base::ListValue> args =
         bt_private::OnPairing::Create(pairing_event);
-    scoped_ptr<Event> event(new Event(events::BLUETOOTH_PRIVATE_ON_PAIRING,
-                                      bt_private::OnPairing::kEventName,
-                                      std::move(args)));
+    std::unique_ptr<Event> event(new Event(events::BLUETOOTH_PRIVATE_ON_PAIRING,
+                                           bt_private::OnPairing::kEventName,
+                                           std::move(args)));
     EventRouter::Get(browser()->profile())
         ->DispatchEventToExtension(kTestExtensionId, std::move(event));
   }
 
   void DispatchAuthorizePairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTAUTHORIZATION);
   }
 
   void DispatchPincodePairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPINCODE);
   }
 
   void DispatchPasskeyPairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_REQUESTPASSKEY);
   }
 
   void DispatchConfirmPasskeyPairingEvent() {
     DispatchPairingEvent(bt_private::PAIRING_EVENT_TYPE_CONFIRMPASSKEY);
   }
 
   void CallSetDiscoveryFilterCallback(
       device::BluetoothAdapter::DiscoverySessionCallback callback) {
-    auto session_ptr = scoped_ptr<NiceMock<MockBluetoothDiscoverySession>>(
+    auto session_ptr = std::unique_ptr<NiceMock<MockBluetoothDiscoverySession>>(
         mock_discovery_session_);
 
     callback.Run(std::move(session_ptr));
   }
 
  protected:
   std::string adapter_name_;
   bool adapter_powered_;
   bool adapter_discoverable_;
 
   scoped_refptr<NiceMock<MockBluetoothAdapter> > mock_adapter_;
-  scoped_ptr<NiceMock<MockBluetoothDevice> > mock_device_;
+  std::unique_ptr<NiceMock<MockBluetoothDevice>> mock_device_;
 
   // This discovery session will be owned by EventRouter, we'll only keep
   // pointer to it.
   NiceMock<MockBluetoothDiscoverySession>* mock_discovery_session_;
 };
 
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   ::std::tr1::get<k>(args).Run();
@@ skipping 135 matching lines @@
   EXPECT_CALL(*mock_device_.get(), Pair(_, _, _))
       .WillOnce(DoAll(
           WithoutArgs(Invoke(
               this,
               &BluetoothPrivateApiTest::DispatchConfirmPasskeyPairingEvent)),
           InvokeCallbackArgument<1>()));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/pair")) << message_;
 }
 
 }  // namespace extensions