Remove stl_util's deletion function use from content/.

content/browser/devtools/protocol/tethering_handler.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 "content/browser/devtools/protocol/tethering_handler.h"
 
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/server_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_server_socket.h"
 
 namespace content {
@@ skipping 222 matching lines @@
   void Unbind(DevToolsCommandId command_id, uint16_t port);
   void Accepted(uint16_t port, const std::string& name);
 
  private:
   void SendInternalError(DevToolsCommandId command_id,
                          const std::string& message);
 
   base::WeakPtr<TetheringHandler> handler_;
   CreateServerSocketCallback socket_callback_;
 
-  typedef std::map<uint16_t, BoundSocket*> BoundSockets;
-  BoundSockets bound_sockets_;
+  std::map<uint16_t, std::unique_ptr<BoundSocket>> bound_sockets_;
 };
 
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
     const CreateServerSocketCallback& socket_callback)
     : handler_(handler),
       socket_callback_(socket_callback) {
 }
 
-TetheringHandler::TetheringImpl::~TetheringImpl() {
-  base::STLDeleteValues(&bound_sockets_);
-}
+TetheringHandler::TetheringImpl::~TetheringImpl() = default;
 
 void TetheringHandler::TetheringImpl::Bind(DevToolsCommandId command_id,
                                            uint16_t port) {
   if (bound_sockets_.find(port) != bound_sockets_.end()) {
     SendInternalError(command_id, "Port already bound");
     return;
   }
 
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
-  std::unique_ptr<BoundSocket> bound_socket(
-      new BoundSocket(callback, socket_callback_));
+  std::unique_ptr<BoundSocket> bound_socket =
+      base::MakeUnique<BoundSocket>(callback, socket_callback_);
   if (!bound_socket->Listen(port)) {
     SendInternalError(command_id, "Could not bind port");
     return;
   }
 
-  bound_sockets_[port] = bound_socket.release();
+  bound_sockets_[port] = std::move(bound_socket);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::SendBindSuccess, handler_, command_id));
 }
 
 void TetheringHandler::TetheringImpl::Unbind(DevToolsCommandId command_id,
                                              uint16_t port) {
-  BoundSockets::iterator it = bound_sockets_.find(port);
+  auto it = bound_sockets_.find(port);
   if (it == bound_sockets_.end()) {
     SendInternalError(command_id, "Port is not bound");
     return;
   }
 
-  delete it->second;
   bound_sockets_.erase(it);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command_id));
 }
 
 void TetheringHandler::TetheringImpl::Accepted(uint16_t port,
                                                const std::string& name) {
   BrowserThread::PostTask(
@@ skipping 87 matching lines @@
 }
 
 void TetheringHandler::SendInternalError(DevToolsCommandId command_id,
                                          const std::string& message) {
   client_->SendError(command_id, Response::InternalError(message));
 }
 
 }  // namespace tethering
 }  // namespace devtools
 }  // namespace content