Refactor QuicCryptoServerStream.

net/quic/core/quic_crypto_server_stream.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/quic/core/quic_crypto_server_stream.h"
 
 #include <memory>
 
 #include "base/base64.h"
 #include "crypto/secure_hash.h"
 #include "net/quic/core/crypto/crypto_protocol.h"
 #include "net/quic/core/crypto/crypto_utils.h"
 #include "net/quic/core/crypto/quic_crypto_server_config.h"
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/proto/cached_network_parameters.pb.h"
 #include "net/quic/core/quic_config.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/quic/core/quic_protocol.h"
 #include "net/quic/core/quic_server_session_base.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
-QuicCryptoServerStreamBase::QuicCryptoServerStreamBase(
-    QuicServerSessionBase* session)
+QuicCryptoServerStreamBase::QuicCryptoServerStreamBase(QuicSession* session)
     : QuicCryptoStream(session) {}
 
 // TODO(jokulik): Once stateless rejects support is inherent in the version
 // number, this function will likely go away entirely.
 // static
 bool QuicCryptoServerStreamBase::DoesPeerSupportStatelessRejects(
     const CryptoHandshakeMessage& message) {
   const QuicTag* received_tags;
   size_t received_tags_length;
   QuicErrorCode error =
       message.GetTaglist(kCOPT, &received_tags, &received_tags_length);
   if (error != QUIC_NO_ERROR) {
     return false;
   }
   for (size_t i = 0; i < received_tags_length; ++i) {
     if (received_tags[i] == kSREJ) {
       return true;
     }
   }
   return false;
 }
 
 QuicCryptoServerStream::QuicCryptoServerStream(
     const QuicCryptoServerConfig* crypto_config,
     QuicCompressedCertsCache* compressed_certs_cache,
     bool use_stateless_rejects_if_peer_supported,
-    QuicServerSessionBase* session)
+    QuicSession* session,
+    Helper* helper)
     : QuicCryptoServerStreamBase(session),
       crypto_config_(crypto_config),
       compressed_certs_cache_(compressed_certs_cache),
       validate_client_hello_cb_(nullptr),
+      helper_(helper),
       num_handshake_messages_(0),
       num_handshake_messages_with_server_nonces_(0),
       send_server_config_update_cb_(nullptr),
       num_server_config_update_messages_sent_(0),
       use_stateless_rejects_if_peer_supported_(
           use_stateless_rejects_if_peer_supported),
       peer_supports_stateless_rejects_(false),
       chlo_packet_size_(0) {
   DCHECK_EQ(Perspective::IS_SERVER, session->connection()->perspective());
 }
@@ skipping 308 matching lines @@
   return true;
 }
 
 QuicErrorCode QuicCryptoServerStream::ProcessClientHello(
     const CryptoHandshakeMessage& message,
     const ValidateClientHelloResultCallback::Result& result,
     std::unique_ptr<ProofSource::Details> proof_source_details,
     CryptoHandshakeMessage* reply,
     DiversificationNonce* out_diversification_nonce,
     string* error_details) {
-  QuicServerSessionBase* session_base =
-      static_cast<QuicServerSessionBase*>(session());
-  if (!session_base->CanAcceptClientHello(message, error_details)) {
+  if (!helper_->CanAcceptClientHello(
+          message, session()->connection()->self_address(), error_details)) {
     return QUIC_HANDSHAKE_FAILED;
   }
 
   if (!result.info.server_nonce.empty()) {
     ++num_handshake_messages_with_server_nonces_;
   }
   // Store the bandwidth estimate from the client.
   if (result.cached_network_params.bandwidth_estimate_bytes_per_second() > 0) {
     previous_cached_network_params_.reset(
         new CachedNetworkParameters(result.cached_network_params));
@@ skipping 35 matching lines @@
     parent_->FinishProcessingHandshakeMessage(client_hello, result,
                                               std::move(details));
   }
 }
 
 QuicConnectionId QuicCryptoServerStream::GenerateConnectionIdForReject(
     bool use_stateless_rejects) {
   if (!use_stateless_rejects) {
     return 0;
   }
-  QuicServerSessionBase* session_base =
-      static_cast<QuicServerSessionBase*>(session());
-  return session_base->GenerateConnectionIdForReject(
+  return helper_->GenerateConnectionIdForReject(
       session()->connection()->connection_id());
 }
 
 }  // namespace net