Break reliance of QuicDispatcher on QuicServerSessionBase

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"
@@ skipping 457 matching lines @@
     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.get();
+    QuicSession* 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.get() != session);
   }
   DeleteSessions();
 }
 
@@ skipping 158 matching lines @@
   // Reset the counter before starting creating connections.
   new_sessions_allowed_per_event_loop_ = max_connections_to_create;
   for (; new_sessions_allowed_per_event_loop_ > 0;
        --new_sessions_allowed_per_event_loop_) {
     QuicConnectionId connection_id;
     list<BufferedPacket> packets =
         buffered_packets_.DeliverPacketsForNextConnection(&connection_id);
     if (packets.empty()) {
       return;
     }
-    QuicServerSessionBase* session =
+    QuicSession* session =
         CreateQuicSession(connection_id, packets.front().client_address);
     DVLOG(1) << "Created new session for " << connection_id;
     session_map_.insert(
         std::make_pair(connection_id, base::WrapUnique(session)));
     DeliverPacketsToSession(packets, session);
   }
 }
 
 bool QuicDispatcher::HasChlosBuffered() const {
   return buffered_packets_.HasChlosBuffered();
@@ skipping 76 matching lines @@
       if (rs != EnqueuePacketResult::SUCCESS) {
         OnBufferPacketFailure(rs, current_connection_id_);
       } else if (!FLAGS_quic_create_session_after_insertion &&
                  is_new_connection) {
         ShouldCreateOrBufferPacketForConnection(current_connection_id_);
       }
     }
     return;
   }
   // Creates a new session and process all buffered packets for this connection.
-  QuicServerSessionBase* session =
+  QuicSession* 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_, 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_);
@@ skipping 233 matching lines @@
   }
   ProcessUnauthenticatedHeaderFate(fate, rejector->connection_id(),
                                    packet_number);
 }
 
 const QuicVersionVector& QuicDispatcher::GetSupportedVersions() {
   return version_manager_->GetSupportedVersions();
 }
 
 void QuicDispatcher::DeliverPacketsToSession(
-    const std::list<BufferedPacket>& packets,
-    QuicServerSessionBase* session) {
+    const list<BufferedPacket>& packets,
+    QuicSession* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net