Replace scoped_ptr with std::unique_ptr in //media.

media/midi/midi_manager_android.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 "media/midi/midi_manager_android.h"
 
 #include "base/android/build_info.h"
 #include "base/android/context_utils.h"
 #include "base/command_line.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MidiManagerAndroid_jni.h"
 #include "media/midi/midi_device_android.h"
 #include "media/midi/midi_manager_usb.h"
 #include "media/midi/midi_output_port_android.h"
 #include "media/midi/midi_switches.h"
 #include "media/midi/usb_midi_device_factory_android.h"
 
 namespace media {
 namespace midi {
 
 MidiManager* MidiManager::Create() {
   auto sdk_version = base::android::BuildInfo::GetInstance()->sdk_int();
   if (sdk_version <= base::android::SDK_VERSION_LOLLIPOP_MR1 ||
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseAndroidMidiApi)) {
-    return new MidiManagerUsb(
-        scoped_ptr<UsbMidiDevice::Factory>(new UsbMidiDeviceFactoryAndroid));
+    return new MidiManagerUsb(std::unique_ptr<UsbMidiDevice::Factory>(
+        new UsbMidiDeviceFactoryAndroid));
   }
 
   return new MidiManagerAndroid();
 }
 
 MidiManagerAndroid::MidiManagerAndroid() {}
 
 MidiManagerAndroid::~MidiManagerAndroid() {}
 
 void MidiManagerAndroid::StartInitialization() {
@@ skipping 46 matching lines @@
 }
 
 void MidiManagerAndroid::OnInitialized(
     JNIEnv* env,
     const JavaParamRef<jobject>& caller,
     const JavaParamRef<jobjectArray>& devices) {
   jsize length = env->GetArrayLength(devices);
 
   for (jsize i = 0; i < length; ++i) {
     jobject raw_device = env->GetObjectArrayElement(devices, i);
-    AddDevice(make_scoped_ptr(new MidiDeviceAndroid(env, raw_device, this)));
+    AddDevice(base::WrapUnique(new MidiDeviceAndroid(env, raw_device, this)));
   }
   CompleteInitialization(Result::OK);
 }
 
 void MidiManagerAndroid::OnAttached(JNIEnv* env,
                                     const JavaParamRef<jobject>& caller,
                                     const JavaParamRef<jobject>& raw_device) {
-  AddDevice(make_scoped_ptr(new MidiDeviceAndroid(env, raw_device, this)));
+  AddDevice(base::WrapUnique(new MidiDeviceAndroid(env, raw_device, this)));
 }
 
 void MidiManagerAndroid::OnDetached(JNIEnv* env,
                                     const JavaParamRef<jobject>& caller,
                                     const JavaParamRef<jobject>& raw_device) {
   for (const auto& device : devices_) {
     if (device->HasRawDevice(env, raw_device)) {
       for (const auto& port : device->input_ports()) {
         DCHECK(input_port_to_index_.end() != input_port_to_index_.find(port));
         size_t index = input_port_to_index_[port];
         SetInputPortState(index, MIDI_PORT_DISCONNECTED);
       }
       for (const auto& port : device->output_ports()) {
         DCHECK(output_port_to_index_.end() != output_port_to_index_.find(port));
         size_t index = output_port_to_index_[port];
         SetOutputPortState(index, MIDI_PORT_DISCONNECTED);
       }
     }
   }
 }
 
-void MidiManagerAndroid::AddDevice(scoped_ptr<MidiDeviceAndroid> device) {
+void MidiManagerAndroid::AddDevice(std::unique_ptr<MidiDeviceAndroid> device) {
   for (auto& port : device->input_ports()) {
     // We implicitly open input ports here, because there are no signal
     // from the renderer when to open.
     // TODO(yhirano): Implement open operation in Blink.
     MidiPortState state = port->Open() ? MIDI_PORT_OPENED : MIDI_PORT_CONNECTED;
 
     const size_t index = all_input_ports_.size();
     all_input_ports_.push_back(port);
     // Port ID must be unique in a MIDI manager. This ID setting is
     // sufficiently unique although there is no user-friendly meaning.
@@ skipping 23 matching lines @@
   }
   devices_.push_back(device.release());
 }
 
 bool MidiManagerAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace midi
 }  // namespace media