Remove use of stl_util's STLDeleteContainerPairSecondPointers from content/.

content/browser/renderer_host/p2p/socket_host_tcp.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 "content/browser/renderer_host/p2p/socket_host_tcp.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 49 matching lines @@
       url_context_(url_context) {
 }
 
 P2PSocketHostTcpBase::~P2PSocketHostTcpBase() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
-bool P2PSocketHostTcpBase::InitAccepted(const net::IPEndPoint& remote_address,
-                                        net::StreamSocket* socket) {
+bool P2PSocketHostTcpBase::InitAccepted(
+    const net::IPEndPoint& remote_address,
+    std::unique_ptr<net::StreamSocket> socket) {
   DCHECK(socket);
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
 
   remote_address_.ip_address = remote_address;
   // TODO(ronghuawu): Add FakeSSLServerSocket.
-  socket_.reset(socket);
+  socket_ = std::move(socket);
   state_ = STATE_OPEN;
   DoRead();
   return state_ != STATE_ERROR;
 }
 
 bool P2PSocketHostTcpBase::Init(const net::IPEndPoint& local_address,
                                 uint16_t min_port,
                                 uint16_t max_port,
                                 const P2PHostAndIPEndPoint& remote_address) {
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
@@ skipping 15 matching lines @@
         remote_address.ip_address);
   }
 
   // TODO(mallinath) - We are ignoring local_address altogether. We should
   // find a way to inject this into ProxyResolvingClientSocket. This could be
   // a problem on multi-homed host.
 
   // The default SSLConfig is good enough for us for now.
   const net::SSLConfig ssl_config;
   socket_.reset(new jingle_glue::ProxyResolvingClientSocket(
-                    NULL,     // Default socket pool provided by the net::Proxy.
-                    url_context_,
-                    ssl_config,
-                    dest_host_port_pair));
+      nullptr,  // Default socket pool provided by the net::Proxy.
+      url_context_, ssl_config, dest_host_port_pair));
 
   int status = socket_->Connect(
       base::Bind(&P2PSocketHostTcpBase::OnConnected,
                  base::Unretained(this)));
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessConnectDone instead of calling it
     // directly here as the caller may not expect an error/close to
     // happen here.  This is okay, as from the caller's point of view,
     // the connect always happens asynchronously.
     base::MessageLoop* message_loop = base::MessageLoop::current();
@@ skipping 292 matching lines @@
 }
 
 void P2PSocketHostTcpBase::HandleWriteResult(int result) {
   DCHECK(write_buffer_.get());
   if (result >= 0) {
     write_buffer_->DidConsume(result);
     if (write_buffer_->BytesRemaining() == 0) {
       message_sender_->Send(
           new P2PMsg_OnSendComplete(id_, P2PSendPacketMetrics()));
       if (write_queue_.empty()) {
-        write_buffer_ = NULL;
+        write_buffer_ = nullptr;
       } else {
         write_buffer_ = write_queue_.front();
         write_queue_.pop();
         // Update how many bytes are still waiting to be sent.
         DecrementDelayedBytes(write_buffer_->size());
       }
     }
   } else if (result == net::ERR_IO_PENDING) {
     write_pending_ = true;
   } else {
     ReportSocketError(result, "WebRTC.ICE.TcpSocketWriteErrorCode");
 
     LOG(ERROR) << "Error when sending data in TCP socket: " << result;
     OnError();
   }
 }
 
-P2PSocketHost* P2PSocketHostTcpBase::AcceptIncomingTcpConnection(
-    const net::IPEndPoint& remote_address, int id) {
+std::unique_ptr<P2PSocketHost>
+P2PSocketHostTcpBase::AcceptIncomingTcpConnection(
+    const net::IPEndPoint& remote_address,
+    int id) {
   NOTREACHED();
   OnError();
-  return NULL;
+  return nullptr;
 }
 
 void P2PSocketHostTcpBase::DidCompleteRead(int result) {
   DCHECK_EQ(state_, STATE_OPEN);
 
   if (result == net::ERR_IO_PENDING) {
     return;
   } else if (result < 0) {
     LOG(ERROR) << "Error when reading from TCP socket: " << result;
     OnError();
@@ skipping 180 matching lines @@
   } else {
     packet_size += kTurnChannelDataHeaderSize;
     // Calculate any padding if present.
     if (packet_size % 4)
       *pad_bytes = 4 - packet_size % 4;
   }
   return packet_size;
 }
 
 }  // namespace content