Low-impact. Dispatcher now uses QuicServerSession, not QuicSession.

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 <errno.h>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 199 matching lines @@
     const QuicPacketPublicHeader& header) {
   // Port zero is only allowed for unidirectional UDP, so is disallowed by QUIC.
   // Given that we can't even send a reply rejecting the packet, just black hole
   // it.
   if (current_client_address_.port() == 0) {
     return false;
   }
 
   // The session that we have identified as the one to which this packet
   // belongs.
-  QuicSession* session = nullptr;
+  QuicServerSession* session = nullptr;
   QuicConnectionId connection_id = header.connection_id;
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it == session_map_.end()) {
     if (time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
       return HandlePacketForTimeWait(header);
     }
 
     // The packet has an unknown connection ID.
     // If the packet is a public reset, there is nothing we must do or can do.
     if (header.reset_flag) {
@@ skipping 26 matching lines @@
   }
 
   session->connection()->ProcessUdpPacket(
       current_server_address_, current_client_address_, *current_packet_);
 
   // Do not parse the packet further.  The session methods called above have
   // processed it completely.
   return false;
 }
 
-QuicSession* QuicDispatcher::AdditionalValidityChecksThenCreateSession(
+QuicServerSession* QuicDispatcher::AdditionalValidityChecksThenCreateSession(
     const QuicPacketPublicHeader& header,
     QuicConnectionId connection_id) {
-  QuicSession* session = CreateQuicSession(
+  QuicServerSession* session = CreateQuicSession(
       connection_id, current_server_address_, current_client_address_);
 
   if (session == nullptr) {
     DVLOG(1) << "Failed to create session for " << connection_id;
 
     if (!framer_.IsSupportedVersion(header.versions.front())) {
       // TODO(ianswett): Produce packet saying "no supported version".
       return nullptr;
     }
 
@@ skipping 52 matching lines @@
     blocked_writer->OnCanWrite();
   }
 }
 
 bool QuicDispatcher::HasPendingWrites() const {
   return !write_blocked_list_.empty();
 }
 
 void QuicDispatcher::Shutdown() {
   while (!session_map_.empty()) {
-    QuicSession* session = session_map_.begin()->second;
+    QuicServerSession* session = session_map_.begin()->second;
     session->connection()->SendConnectionClose(QUIC_PEER_GOING_AWAY);
     // Validate that the session removes itself from the session map on close.
     DCHECK(session_map_.empty() || session_map_.begin()->second != session);
   }
   DeleteSessions();
 }
 
 void QuicDispatcher::OnConnectionClosed(QuicConnectionId connection_id,
                                         QuicErrorCode error) {
   SessionMap::iterator it = session_map_.find(connection_id);
@@ skipping 37 matching lines @@
 
 void QuicDispatcher::OnConnectionRemovedFromTimeWaitList(
     QuicConnectionId connection_id) {
   DVLOG(1) << "Connection " << connection_id << " removed from time wait list.";
 }
 
 QuicPacketWriter* QuicDispatcher::CreateWriter(int fd) {
   return new QuicDefaultPacketWriter(fd);
 }
 
-QuicSession* QuicDispatcher::CreateQuicSession(
+QuicServerSession* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& server_address,
     const IPEndPoint& client_address) {
-  // The QuicSession takes ownership of |connection| below.
+  // The QuicServerSession takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), connection_writer_factory_,
       /* owns_writer= */ true, Perspective::IS_SERVER,
       crypto_config_.HasProofSource(), supported_versions_);
 
   QuicServerSession* session = new QuicServerSession(config_, connection, this);
   session->InitializeSession(&crypto_config_);
   return session;
 }
 
@@ skipping 14 matching lines @@
   framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
       header.connection_id));
 
   // Continue parsing the packet to extract the sequence number.  Then
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 }  // namespace tools
 }  // namespace net