Remove stl_util's STLDeleteContainerPairSecondPointers from net/.

net/test/embedded_test_server/embedded_test_server.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 "net/test/embedded_test_server/embedded_test_server.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/process_metrics.h"
 #include "base/run_loop.h"
-#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "crypto/rsa_private_key.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/cert/pem_tokenizer.h"
 #include "net/cert/test_root_certs.h"
 #include "net/socket/ssl_server_socket.h"
@@ skipping 134 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return PostTaskToIOThreadAndWait(base::Bind(
       &EmbeddedTestServer::ShutdownOnIOThread, base::Unretained(this)));
 }
 
 void EmbeddedTestServer::ShutdownOnIOThread() {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   weak_factory_.InvalidateWeakPtrs();
   listen_socket_.reset();
-  base::STLDeleteContainerPairSecondPointers(connections_.begin(),
-                                             connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
                                        std::unique_ptr<HttpRequest> request) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
   for (const auto& monitor : request_monitors_)
     monitor.Run(*request);
 
@@ skipping 151 matching lines @@
   }
 }
 
 bool EmbeddedTestServer::FlushAllSocketsAndConnectionsOnUIThread() {
   return PostTaskToIOThreadAndWait(
       base::Bind(&EmbeddedTestServer::FlushAllSocketsAndConnections,
                  base::Unretained(this)));
 }
 
 void EmbeddedTestServer::FlushAllSocketsAndConnections() {
-  base::STLDeleteContainerPairSecondPointers(connections_.begin(),
-                                             connections_.end());
   connections_.clear();
 }
 
 void EmbeddedTestServer::OnAcceptCompleted(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   HandleAcceptResult(std::move(accepted_socket_));
   DoAcceptLoop();
 }
 
 void EmbeddedTestServer::OnHandshakeDone(HttpConnection* connection, int rv) {
   if (connection->socket_->IsConnected())
     ReadData(connection);
   else
     DidClose(connection);
 }
 
 void EmbeddedTestServer::HandleAcceptResult(
     std::unique_ptr<StreamSocket> socket) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   if (connection_listener_)
     connection_listener_->AcceptedSocket(*socket);
 
   if (is_using_ssl_)
     socket = DoSSLUpgrade(std::move(socket));
 
-  HttpConnection* http_connection = new HttpConnection(
-      std::move(socket),
-      base::Bind(&EmbeddedTestServer::HandleRequest, base::Unretained(this)));
-  connections_[http_connection->socket_.get()] = http_connection;
+  std::unique_ptr<HttpConnection> http_connection_ptr =
+      base::MakeUnique<HttpConnection>(
+          std::move(socket), base::Bind(&EmbeddedTestServer::HandleRequest,
+                                        base::Unretained(this)));
+  HttpConnection* http_connection = http_connection_ptr.get();
+  connections_[http_connection->socket_.get()] = std::move(http_connection_ptr);
 
   if (is_using_ssl_) {
     SSLServerSocket* ssl_socket =
         static_cast<SSLServerSocket*>(http_connection->socket_.get());
     int rv = ssl_socket->Handshake(
         base::Bind(&EmbeddedTestServer::OnHandshakeDone, base::Unretained(this),
                    http_connection));
     if (rv != ERR_IO_PENDING)
       OnHandshakeDone(http_connection, rv);
   } else {
@@ skipping 35 matching lines @@
 
   return true;
 }
 
 void EmbeddedTestServer::DidClose(HttpConnection* connection) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
   DCHECK(connection);
   DCHECK_EQ(1u, connections_.count(connection->socket_.get()));
 
   connections_.erase(connection->socket_.get());
-  delete connection;
 }
 
 HttpConnection* EmbeddedTestServer::FindConnection(StreamSocket* socket) {
   DCHECK(io_thread_->task_runner()->BelongsToCurrentThread());
 
-  std::map<StreamSocket*, HttpConnection*>::iterator it =
-      connections_.find(socket);
+  auto it = connections_.find(socket);
   if (it == connections_.end()) {
-    return NULL;
+    return nullptr;
   }
-  return it->second;
+  return it->second.get();
 }
 
 bool EmbeddedTestServer::PostTaskToIOThreadAndWait(
     const base::Closure& closure) {
   // Note that PostTaskAndReply below requires
   // base::ThreadTaskRunnerHandle::Get() to return a task runner for posting
   // the reply task. However, in order to make EmbeddedTestServer universally
   // usable, it needs to cope with the situation where it's running on a thread
   // on which a message loop is not (yet) available or as has been destroyed
   // already.
   //
   // To handle this situation, create temporary message loop to support the
   // PostTaskAndReply operation if the current thread as no message loop.
   std::unique_ptr<base::MessageLoop> temporary_loop;
   if (!base::MessageLoop::current())
     temporary_loop.reset(new base::MessageLoop());
 
   base::RunLoop run_loop;
   if (!io_thread_->task_runner()->PostTaskAndReply(FROM_HERE, closure,
                                                    run_loop.QuitClosure())) {
     return false;
   }
   run_loop.Run();
 
   return true;
 }
 
 }  // namespace test_server
 }  // namespace net