Remove stl_util's deletion functions from:

net/tools/quic/end_to_end_test.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 <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 395 matching lines @@
     CHECK(server_thread_.get() == nullptr);
     DVLOG(1) << "Setting server initial session flow control window: "
              << window;
     server_config_.SetInitialSessionFlowControlWindowToSend(window);
   }
 
   const QuicSentPacketManagerInterface*
   GetSentPacketManagerFromFirstServerSession() const {
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
-    QuicSession* session = dispatcher->session_map().begin()->second;
+    QuicSession* session = dispatcher->session_map().begin()->second.get();
     return &session->connection()->sent_packet_manager();
   }
 
   bool Initialize() {
     QuicTagVector copt;
     server_config_.SetConnectionOptionsToSend(copt);
 
     // TODO(nimia): Consider setting the congestion control algorithm for the
     // client as well according to the test parameter.
     copt.push_back(GetParam().congestion_control_tag);
@@ skipping 140 matching lines @@
          client_->client()->session()->GetNumSentClientHellos() > 0)
             ? 1
             : 0;
     EXPECT_EQ(num_expected_stateless_rejects,
               client_->client()->num_stateless_rejects_received());
 
     server_thread_->Pause();
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
     ASSERT_EQ(1u, dispatcher->session_map().size());
-    QuicSession* session = dispatcher->session_map().begin()->second;
+    QuicSession* session = dispatcher->session_map().begin()->second.get();
     QuicConnectionStats server_stats = session->connection()->GetStats();
     if (!had_packet_loss) {
       EXPECT_EQ(0u, server_stats.packets_lost);
     }
     EXPECT_EQ(0u, server_stats.packets_discarded);
     // TODO(ianswett): Restore the check for packets_dropped equals 0.
     // The expect for packets received is equal to packets processed fails
     // due to version negotiation packets.
     server_thread_->Resume();
   }
@@ skipping 48 matching lines @@
   QuicCryptoStream* crypto_stream =
       QuicSessionPeer::GetCryptoStream(client_->client()->session());
   QuicStreamSequencer* sequencer =
       ReliableQuicStreamPeer::sequencer(crypto_stream);
   EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer &&
                 FLAGS_quic_reduce_sequencer_buffer_memory_life_time,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSession* server_session = dispatcher->session_map().begin()->second;
+  QuicSession* server_session = dispatcher->session_map().begin()->second.get();
   crypto_stream = QuicSessionPeer::GetCryptoStream(server_session);
   sequencer = ReliableQuicStreamPeer::sequencer(crypto_stream);
   EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer &&
                 FLAGS_quic_reduce_sequencer_buffer_memory_life_time,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
 }
 
 TEST_P(EndToEndTest, SimpleRequestResponse) {
   ASSERT_TRUE(Initialize());
 
@@ skipping 693 matching lines @@
     // Earlier versions negotiated max open streams.
     return;
   }
 
   // The client has received the server's limit and vice versa.
   EXPECT_EQ(kServerMaxIncomingDynamicStreams,
             client_->client()->session()->max_open_outgoing_streams());
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSession* server_session = dispatcher->session_map().begin()->second;
+  QuicSession* server_session = dispatcher->session_map().begin()->second.get();
   EXPECT_EQ(kClientMaxIncomingDynamicStreams,
             server_session->max_open_outgoing_streams());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, NegotiateCongestionControl) {
   FLAGS_quic_allow_new_bbr = true;
   // Disable this flag because if connection uses multipath sent packet manager,
   // static_cast here does not work.
   FLAGS_quic_enable_multipath = false;
@@ skipping 74 matching lines @@
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   const QuicSentPacketManagerInterface& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
 
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(
       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
   const RttStats& server_rtt_stats =
       *session->connection()->sent_packet_manager().GetRttStats();
   EXPECT_EQ(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.initial_rtt_us());
   EXPECT_GE(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.smoothed_rtt().ToMicroseconds());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, MinInitialRTT) {
   // Client tries to suggest 0 and the server uses the default.
   client_config_.SetInitialRoundTripTimeUsToSend(0);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   const QuicSentPacketManagerInterface& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManagerInterface& server_sent_packet_manager =
       session->connection()->sent_packet_manager();
 
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(
       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
   // Expect the default rtt of 100ms.
@@ skipping 239 matching lines @@
   EXPECT_EQ(kServerStreamIFCW, QuicFlowControllerPeer::SendWindowOffset(
                                    stream->flow_controller()));
   EXPECT_EQ(kServerSessionIFCW,
             QuicFlowControllerPeer::SendWindowOffset(
                 client_->client()->session()->flow_controller()));
 
   // Server should have the right values for client's receive window.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   EXPECT_EQ(kClientStreamIFCW,
             session->config()->ReceivedInitialStreamFlowControlWindowBytes());
   EXPECT_EQ(kClientSessionIFCW,
             session->config()->ReceivedInitialSessionFlowControlWindowBytes());
   EXPECT_EQ(kClientSessionIFCW, QuicFlowControllerPeer::SendWindowOffset(
                                     session->flow_controller()));
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, HeadersAndCryptoStreamsNoConnectionFlowControl) {
@@ skipping 34 matching lines @@
               kStreamIFCW);
   }
   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
                               client_->client()->session()->flow_controller()));
 
   // Server should be in a similar state: connection flow control window should
   // not have any bytes marked as received.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   QuicFlowController* server_connection_flow_controller =
       session->flow_controller();
   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::ReceiveWindowSize(
                               server_connection_flow_controller));
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, FlowControlsSynced) {
   set_smaller_flow_control_receive_window();
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   server_thread_->Pause();
   QuicSpdySession* const client_session = client_->client()->session();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSpdySession* server_session = dispatcher->session_map().begin()->second;
+  QuicSpdySession* server_session =
+      dispatcher->session_map().begin()->second.get();
 
   ExpectFlowControlsSynced(client_session->flow_controller(),
                            server_session->flow_controller());
   ExpectFlowControlsSynced(
       QuicSessionPeer::GetCryptoStream(client_session)->flow_controller(),
       QuicSessionPeer::GetCryptoStream(server_session)->flow_controller());
   ExpectFlowControlsSynced(
       QuicSpdySessionPeer::GetHeadersStream(client_session)->flow_controller(),
       QuicSpdySessionPeer::GetHeadersStream(server_session)->flow_controller());
 
@@ skipping 16 matching lines @@
   ASSERT_TRUE(Initialize());
 
   // Send a simple headers only request, and receive response.
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 
   // Now verify that the server is not waiting for a final FIN or RST.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   EXPECT_EQ(
       0u,
       QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(session).size());
   server_thread_->Resume();
 }
 
 // A TestAckListener verifies that its OnAckNotification method has been
 // called exactly once on destruction.
 class TestAckListener : public QuicAckListenerInterface {
  public:
@@ skipping 583 matching lines @@
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
 
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   QuicDispatcher::SessionMap const& map =
       QuicDispatcherPeer::session_map(dispatcher);
   QuicDispatcher::SessionMap::const_iterator it = map.begin();
   EXPECT_TRUE(it != map.end());
-  QuicServerSessionBase* server_session = it->second;
+  QuicServerSessionBase* server_session = it->second.get();
 
   // The stream is not waiting for the arrival of the peer's final offset.
   EXPECT_EQ(
       0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(server_session)
               .size());
 
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, LargePostEarlyResponse) {
@@ skipping 288 matching lines @@
     // request.
     client_->WaitForResponse();
   }
 
   // Check server session to see if it has max number of outgoing streams opened
   // though more resources need to be pushed.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
-  QuicSession* session = dispatcher->session_map().begin()->second;
+  QuicSession* session = dispatcher->session_map().begin()->second.get();
   EXPECT_EQ(kNumMaxStreams, session->GetNumOpenOutgoingStreams());
   server_thread_->Resume();
 
   EXPECT_EQ(1u, client_->num_requests());
   EXPECT_EQ(1u, client_->num_responses());
   EXPECT_EQ(kBody, client_->response_body());
 
   // "Send" request for a promised resources will not really send out it because
   // its response is being pushed(but blocked). And the following ack and
   // flow control behavior of SendSynchronousRequests()
@@ skipping 176 matching lines @@
   client_->WaitForResponse();
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 }  // namespace
 }  // namespace test
 }  // namespace net