Remove stl_util's STLDeleteContainerPairSecondPointers from net/.

net/server/http_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/server/http_server.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/server/http_connection.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
@@ skipping 12 matching lines @@
       weak_ptr_factory_(this) {
   DCHECK(server_socket_);
   // Start accepting connections in next run loop in case when delegate is not
   // ready to get callbacks.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&HttpServer::DoAcceptLoop, weak_ptr_factory_.GetWeakPtr()));
 }
 
 HttpServer::~HttpServer() {
-  base::STLDeleteContainerPairSecondPointers(id_to_connection_.begin(),
-                                             id_to_connection_.end());
 }
 
 void HttpServer::AcceptWebSocket(
     int connection_id,
     const HttpServerRequestInfo& request) {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection == NULL)
     return;
   DCHECK(connection->web_socket());
   connection->web_socket()->Accept(request);
@@ skipping 41 matching lines @@
 
 void HttpServer::Send404(int connection_id) {
   SendResponse(connection_id, HttpServerResponseInfo::CreateFor404());
 }
 
 void HttpServer::Send500(int connection_id, const std::string& message) {
   SendResponse(connection_id, HttpServerResponseInfo::CreateFor500(message));
 }
 
 void HttpServer::Close(int connection_id) {
-  HttpConnection* connection = FindConnection(connection_id);
-  if (connection == NULL)
+  auto it = id_to_connection_.find(connection_id);
+  if (it == id_to_connection_.end())
     return;
 
+  std::unique_ptr<HttpConnection> connection = std::move(it->second);
   id_to_connection_.erase(connection_id);

[davidben, 2016/09/16 22:11:13]

Nit: id_to_connection_.erase(it) to save a lookup?

[Avi (use Gerrit), 2016/09/16 22:14:40]

Done.

   delegate_->OnClose(connection_id);
 
   // The call stack might have callbacks which still have the pointer of
   // connection. Instead of referencing connection with ID all the time,
   // destroys the connection in next run loop to make sure any pending
   // callbacks in the call stack return.
-  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, connection);
+  base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE,
+                                                  connection.release());
 }
 
 int HttpServer::GetLocalAddress(IPEndPoint* address) {
   return server_socket_->GetLocalAddress(address);
 }
 
 void HttpServer::SetReceiveBufferSize(int connection_id, int32_t size) {
   HttpConnection* connection = FindConnection(connection_id);
   if (connection)
     connection->read_buf()->set_max_buffer_size(size);
@@ skipping 21 matching lines @@
   if (HandleAcceptResult(rv) == OK)
     DoAcceptLoop();
 }
 
 int HttpServer::HandleAcceptResult(int rv) {
   if (rv < 0) {
     LOG(ERROR) << "Accept error: rv=" << rv;
     return rv;
   }
 
-  HttpConnection* connection =
-      new HttpConnection(++last_id_, std::move(accepted_socket_));
-  id_to_connection_[connection->id()] = connection;
+  std::unique_ptr<HttpConnection> connection_ptr =
+      base::MakeUnique<HttpConnection>(++last_id_, std::move(accepted_socket_));
+  HttpConnection* connection = connection_ptr.get();
+  id_to_connection_[connection->id()] = std::move(connection_ptr);
   delegate_->OnConnect(connection->id());
   if (!HasClosedConnection(connection))
     DoReadLoop(connection);
   return OK;
 }
 
 void HttpServer::DoReadLoop(HttpConnection* connection) {
   int rv;
   do {
     HttpConnection::ReadIOBuffer* read_buf = connection->read_buf();
@@ skipping 269 matching lines @@
         case ST_ERR:
           return false;
       }
     }
   }
   // No more characters, but we haven't finished parsing yet.
   return false;
 }
 
 HttpConnection* HttpServer::FindConnection(int connection_id) {
-  IdToConnectionMap::iterator it = id_to_connection_.find(connection_id);
+  auto it = id_to_connection_.find(connection_id);
   if (it == id_to_connection_.end())
-    return NULL;
-  return it->second;
+    return nullptr;
+  return it->second.get();
 }
 
 // This is called after any delegate callbacks are called to check if Close()
 // has been called during callback processing. Using the pointer of connection,
 // |connection| is safe here because Close() deletes the connection in next run
 // loop.
 bool HttpServer::HasClosedConnection(HttpConnection* connection) {
   return FindConnection(connection->id()) != connection;
 }
 
 }  // namespace net