Remove stl_util's deletion functions from:

net/tools/quic/quic_dispatcher.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/tools/quic/quic_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/stl_util.h"
+#include "base/memory/ptr_util.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_utils.h"
 
 #include "net/tools/quic/chlo_extractor.h"
 #include "net/tools/quic/quic_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 #include "net/tools/quic/quic_simple_server_session.h"
 #include "net/tools/quic/quic_time_wait_list_manager.h"
@@ skipping 189 matching lines @@
       version_manager_(version_manager),
       framer_(GetSupportedVersions(),
               /*unused*/ QuicTime::Zero(),
               Perspective::IS_SERVER),
       last_error_(QUIC_NO_ERROR),
       new_sessions_allowed_per_event_loop_(0u) {
   framer_.set_visitor(this);
 }
 
 QuicDispatcher::~QuicDispatcher() {
-  base::STLDeleteValues(&session_map_);
-  base::STLDeleteElements(&closed_session_list_);
+  session_map_.clear();
+  closed_session_list_.clear();
 }
 
 void QuicDispatcher::InitializeWithWriter(QuicPacketWriter* writer) {
   DCHECK(writer_ == nullptr);
   writer_.reset(writer);
   time_wait_list_manager_.reset(CreateQuicTimeWaitListManager());
 }
 
 void QuicDispatcher::ProcessPacket(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
@@ skipping 186 matching lines @@
   // All packets within a connection sent by a client before receiving a
   // response from the server are required to have the version negotiation flag
   // set.  Since this may be a client continuing a connection we lost track of
   // via server restart, send a rejection to fast-fail the connection.
   if (!header.public_header.version_flag) {
     DVLOG(1) << "Packet without version arrived for unknown connection ID "
              << header.public_header.connection_id;
     return kFateTimeWait;
   }
 
-  // Check that the sequence numer is within the range that the client is
+  // Check that the sequence number is within the range that the client is
   // expected to send before receiving a response from the server.
   if (header.packet_number == kInvalidPacketNumber ||
       header.packet_number > kMaxReasonableInitialPacketNumber) {
     return kFateTimeWait;
   }
 
   return kFateProcess;
 }
 
 void QuicDispatcher::CleanUpSession(SessionMap::iterator it,
+                                    QuicConnection* connection,
                                     bool should_close_statelessly) {
-  QuicConnection* connection = it->second->connection();
-
   write_blocked_list_.erase(connection);
   if (should_close_statelessly) {
     DCHECK(connection->termination_packets() != nullptr &&
            !connection->termination_packets()->empty());
   }
   time_wait_list_manager_->AddConnectionIdToTimeWait(
       it->first, connection->version(), should_close_statelessly,
       connection->termination_packets());
   session_map_.erase(it);
 }
 
 void QuicDispatcher::DeleteSessions() {
-  base::STLDeleteElements(&closed_session_list_);
+  closed_session_list_.clear();
 }
 
 void QuicDispatcher::OnCanWrite() {
   // The socket is now writable.
   writer_->SetWritable();
 
   // Give all the blocked writers one chance to write, until we're blocked again
   // or there's no work left.
   while (!write_blocked_list_.empty() && !writer_->IsWriteBlocked()) {
     QuicBlockedWriterInterface* blocked_writer =
         write_blocked_list_.begin()->first;
     write_blocked_list_.erase(write_blocked_list_.begin());
     blocked_writer->OnCanWrite();
   }
 }
 
 bool QuicDispatcher::HasPendingWrites() const {
   return !write_blocked_list_.empty();
 }
 
 void QuicDispatcher::Shutdown() {
   while (!session_map_.empty()) {
-    QuicServerSessionBase* session = session_map_.begin()->second;
+    QuicServerSessionBase* session = session_map_.begin()->second.get();
     session->connection()->CloseConnection(
         QUIC_PEER_GOING_AWAY, "Server shutdown imminent",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
     // Validate that the session removes itself from the session map on close.
-    DCHECK(session_map_.empty() || session_map_.begin()->second != session);
+    DCHECK(session_map_.empty() ||
+           session_map_.begin()->second.get() != session);
   }
   DeleteSessions();
 }
 
 void QuicDispatcher::OnConnectionClosed(QuicConnectionId connection_id,
                                         QuicErrorCode error,
                                         const string& error_details) {
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it == session_map_.end()) {
     QUIC_BUG << "ConnectionId " << connection_id
              << " does not exist in the session map.  Error: "
              << QuicUtils::ErrorToString(error);
     QUIC_BUG << base::debug::StackTrace().ToString();
     return;
   }
 
   DVLOG_IF(1, error != QUIC_NO_ERROR)
       << "Closing connection (" << connection_id
       << ") due to error: " << QuicUtils::ErrorToString(error)
       << ", with details: " << error_details;
 
   if (closed_session_list_.empty()) {
     delete_sessions_alarm_->Update(helper()->GetClock()->ApproximateNow(),
                                    QuicTime::Delta::Zero());
   }
-  closed_session_list_.push_back(it->second);
+  QuicConnection* connection = it->second->connection();
+  closed_session_list_.push_back(std::move(it->second));
   const bool should_close_statelessly =
       (error == QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT);
-  CleanUpSession(it, should_close_statelessly);
+  CleanUpSession(it, connection, should_close_statelessly);
 }
 
 void QuicDispatcher::OnWriteBlocked(
     QuicBlockedWriterInterface* blocked_writer) {
   if (!writer_->IsWriteBlocked()) {
     QUIC_BUG << "QuicDispatcher::OnWriteBlocked called when the writer is "
                 "not blocked.";
     // Return without adding the connection to the blocked list, to avoid
     // infinite loops in OnCanWrite.
     return;
@@ skipping 125 matching lines @@
        --new_sessions_allowed_per_event_loop_) {
     QuicConnectionId connection_id;
     list<BufferedPacket> packets =
         buffered_packets_.DeliverPacketsForNextConnection(&connection_id);
     if (packets.empty()) {
       return;
     }
     QuicServerSessionBase* session =
         CreateQuicSession(connection_id, packets.front().client_address);
     DVLOG(1) << "Created new session for " << connection_id;
-    session_map_.insert(std::make_pair(connection_id, session));
+    session_map_.insert(
+        std::make_pair(connection_id, base::WrapUnique(session)));
     DeliverPacketsToSession(packets, session);
   }
 }
 
 bool QuicDispatcher::HasChlosBuffered() const {
   return buffered_packets_.HasChlosBuffered();
 }
 
 bool QuicDispatcher::ShouldCreateOrBufferPacketForConnection(
     QuicConnectionId connection_id) {
@@ skipping 75 matching lines @@
                  is_new_connection) {
         ShouldCreateOrBufferPacketForConnection(current_connection_id_);
       }
     }
     return;
   }
   // Creates a new session and process all buffered packets for this connection.
   QuicServerSessionBase* session =
       CreateQuicSession(current_connection_id_, current_client_address_);
   DVLOG(1) << "Created new session for " << current_connection_id_;
-  session_map_.insert(std::make_pair(current_connection_id_, session));
+  session_map_.insert(
+      std::make_pair(current_connection_id_, base::WrapUnique(session)));
   std::list<BufferedPacket> packets =
       buffered_packets_.DeliverPackets(current_connection_id_);
   // Check if CHLO is the first packet arrived on this connection.
   if (!FLAGS_quic_create_session_after_insertion &&
       FLAGS_quic_buffer_packet_till_chlo && packets.empty()) {
     ShouldCreateOrBufferPacketForConnection(current_connection_id_);
   }
   // Process CHLO at first.
   session->ProcessUdpPacket(current_server_address_, current_client_address_,
                             *current_packet_);
@@ skipping 238 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicServerSessionBase* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net