Remove stl_util's deletion function use from device/.

device/bluetooth/dbus/fake_bluetooth_media_transport_client.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 "device/bluetooth/dbus/fake_bluetooth_media_transport_client.h"
 
 #include <stddef.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <memory>
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "device/bluetooth/dbus/bluetooth_media_client.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "device/bluetooth/dbus/fake_bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_media_client.h"
 #include "device/bluetooth/dbus/fake_bluetooth_media_endpoint_service_provider.h"
 
 using dbus::ObjectPath;
 
 namespace {
 
@@ skipping 58 matching lines @@
 
 void FakeBluetoothMediaTransportClient::Properties::Set(
     dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
   callback.Run(false);
 }
 
 FakeBluetoothMediaTransportClient::Transport::Transport(
     const ObjectPath& transport_path,
-    Properties* transport_properties)
-    : path(transport_path) {
-  properties.reset(transport_properties);
-}
+    std::unique_ptr<Properties> transport_properties)
+    : path(transport_path), properties(std::move(transport_properties)) {}
 
 FakeBluetoothMediaTransportClient::Transport::~Transport() {}
 
 FakeBluetoothMediaTransportClient::FakeBluetoothMediaTransportClient() {}
 
-FakeBluetoothMediaTransportClient::~FakeBluetoothMediaTransportClient() {
-  base::STLDeleteValues(&endpoint_to_transport_map_);
-}
+FakeBluetoothMediaTransportClient::~FakeBluetoothMediaTransportClient() {}
 
 // DBusClient override.
 void FakeBluetoothMediaTransportClient::Init(dbus::Bus* bus) {}
 
 void FakeBluetoothMediaTransportClient::AddObserver(
     BluetoothMediaTransportClient::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void FakeBluetoothMediaTransportClient::RemoveObserver(
@@ skipping 58 matching lines @@
     properties->uuid.ReplaceValue(
         BluetoothMediaClient::kBluetoothAudioSinkUUID);
     properties->codec.ReplaceValue(kTransportCodec);
     properties->configuration.ReplaceValue(
         UINT8_VECTOR_FROM_ARRAY(kTransportConfiguration));
     properties->state.ReplaceValue(BluetoothMediaTransportClient::kStateIdle);
     properties->delay.ReplaceValue(kTransportDelay);
     properties->volume.ReplaceValue(kTransportVolume);
 
     endpoint_to_transport_map_[endpoint_path] =
-        new Transport(transport_path, properties.release());
+        base::MakeUnique<Transport>(transport_path, std::move(properties));
     transport_to_endpoint_map_[transport_path] = endpoint_path;
     return;
   }
 
   Transport* transport = GetTransport(endpoint_path);
   if (!transport)
     return;
   ObjectPath transport_path = transport->path;
 
   // Notifies observers about the state change of the transport.
   for (auto& observer : observers_)
     observer.MediaTransportRemoved(transport_path);
 
   endpoint->ClearConfiguration(transport_path);
-  delete transport;
   endpoint_to_transport_map_.erase(endpoint_path);
   transport_to_endpoint_map_.erase(transport_path);
 }
 
 void FakeBluetoothMediaTransportClient::SetState(
     const ObjectPath& endpoint_path,
     const std::string& state) {
   VLOG(1) << "SetState - state: " << state;
 
   Transport* transport = GetTransport(endpoint_path);
@@ skipping 64 matching lines @@
 ObjectPath FakeBluetoothMediaTransportClient::GetEndpointPath(
     const ObjectPath& transport_path) {
   const auto& it = transport_to_endpoint_map_.find(transport_path);
   return it != transport_to_endpoint_map_.end() ? it->second : ObjectPath("");
 }
 
 FakeBluetoothMediaTransportClient::Transport*
 FakeBluetoothMediaTransportClient::GetTransport(
     const ObjectPath& endpoint_path) {
   const auto& it = endpoint_to_transport_map_.find(endpoint_path);
-  return (it != endpoint_to_transport_map_.end()) ? it->second : nullptr;
+  return (it != endpoint_to_transport_map_.end()) ? it->second.get() : nullptr;
 }
 
 FakeBluetoothMediaTransportClient::Transport*
 FakeBluetoothMediaTransportClient::GetTransportByPath(
     const dbus::ObjectPath& transport_path) {
   return GetTransport(GetEndpointPath(transport_path));
 }
 
 void FakeBluetoothMediaTransportClient::AcquireInternal(
     bool try_flag,
@@ skipping 25 matching lines @@
   }
   DCHECK((fds[0] > kInvalidFd) && (fds[1] > kInvalidFd));
   transport->input_fd.reset(new base::File(fds[0]));
 
   base::ScopedFD out_fd(fds[1]);
   callback.Run(std::move(out_fd), kDefaultReadMtu, kDefaultWriteMtu);
   SetState(endpoint_path, "active");
 }
 
 }  // namespace bluez