Refactor QuicCryptoServerStream.

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 "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/quic_simple_server_session.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_time_wait_list_manager.h"
 #include "net/tools/quic/stateless_rejector.h"
 
 using base::StringPiece;
 using std::list;
 using std::string;
 
@@ skipping 121 matching lines @@
   // Set as the visitor of |creator_| to collect any generated packets.
   PacketCollector collector_;
   QuicPacketCreator creator_;
   QuicTimeWaitListManager* time_wait_list_manager_;
 };
 
 // Class which sits between the ChloExtractor and the StatelessRejector
 // to give the QuicDispatcher a chance to apply policy checks to the CHLO.
 class ChloValidator : public ChloExtractor::Delegate {
  public:
-  ChloValidator(QuicServerSessionBase::Helper* helper,
+  ChloValidator(QuicCryptoServerStream::Helper* helper,
                 IPEndPoint self_address,
                 StatelessRejector* rejector)
       : helper_(helper),
         self_address_(self_address),
         rejector_(rejector),
         can_accept_(false) {}
 
   // ChloExtractor::Delegate implementation.
   void OnChlo(QuicVersion version,
               QuicConnectionId connection_id,
               const CryptoHandshakeMessage& chlo) override {
     if (helper_->CanAcceptClientHello(chlo, self_address_, &error_details_)) {
       can_accept_ = true;
       rejector_->OnChlo(version, connection_id,
                         helper_->GenerateConnectionIdForReject(connection_id),
                         chlo);
     }
   }
 
   bool can_accept() const { return can_accept_; }
 
   const string& error_details() const { return error_details_; }
 
  private:
-  QuicServerSessionBase::Helper* helper_;  // Unowned.
+  QuicCryptoServerStream::Helper* helper_;  // Unowned.
   IPEndPoint self_address_;
   StatelessRejector* rejector_;  // Unowned.
   bool can_accept_;
   string error_details_;
 };
 
 }  // namespace
 
 QuicDispatcher::QuicDispatcher(
     const QuicConfig& config,
     const QuicCryptoServerConfig* crypto_config,
     QuicVersionManager* version_manager,
     std::unique_ptr<QuicConnectionHelperInterface> helper,
-    std::unique_ptr<QuicServerSessionBase::Helper> session_helper,
+    std::unique_ptr<QuicCryptoServerStream::Helper> session_helper,
     std::unique_ptr<QuicAlarmFactory> alarm_factory)
     : config_(config),
       crypto_config_(crypto_config),
       compressed_certs_cache_(
           QuicCompressedCertsCache::kQuicCompressedCertsCacheSize),
       helper_(std::move(helper)),
       session_helper_(std::move(session_helper)),
       alarm_factory_(std::move(alarm_factory)),
       delete_sessions_alarm_(
           alarm_factory_->CreateAlarm(new DeleteSessionsAlarm(this))),
@@ skipping 696 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