Refactor QuicCryptoClientStream to use QuicSession directly.

net/quic/quic_crypto_client_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/quic_crypto_client_stream.h"
 
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/stringprintf.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
-#include "net/quic/quic_client_session_base.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 
 namespace {
 
 void AppendFixed(CryptoHandshakeMessage* message) {
   vector<QuicTag> tags;
   tags.push_back(kFIXD);
 
   const QuicTag* received_tags;
   size_t received_tags_length;
   QuicErrorCode error =
       message->GetTaglist(kCOPT, &received_tags, &received_tags_length);
   if (error == QUIC_NO_ERROR) {
     for (size_t i = 0; i < received_tags_length; ++i) {
       tags.push_back(received_tags[i]);
     }
   }
   message->SetVector(kCOPT, tags);
 }
 
 }  // namespace
 
-QuicCryptoClientStreamBase::QuicCryptoClientStreamBase(
-    QuicClientSessionBase* session)
+QuicCryptoClientStreamBase::QuicCryptoClientStreamBase(QuicSession* session)
     : QuicCryptoStream(session) {}
 
 QuicCryptoClientStream::ChannelIDSourceCallbackImpl::
     ChannelIDSourceCallbackImpl(QuicCryptoClientStream* stream)
     : stream_(stream) {}
 
 QuicCryptoClientStream::ChannelIDSourceCallbackImpl::
     ~ChannelIDSourceCallbackImpl() {}
 
 void QuicCryptoClientStream::ChannelIDSourceCallbackImpl::Run(
@@ skipping 39 matching lines @@
   // The ProofVerifier owns this object and will delete it when this method
   // returns.
 }
 
 void QuicCryptoClientStream::ProofVerifierCallbackImpl::Cancel() {
   stream_ = nullptr;
 }
 
 QuicCryptoClientStream::QuicCryptoClientStream(
     const QuicServerId& server_id,
-    QuicClientSessionBase* session,
+    QuicSession* session,
     ProofVerifyContext* verify_context,
-    QuicCryptoClientConfig* crypto_config)
+    QuicCryptoClientConfig* crypto_config,
+    ProofHandler* proof_handler)
     : QuicCryptoClientStreamBase(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
       server_id_(server_id),
       generation_counter_(0),
       channel_id_sent_(false),
       channel_id_source_callback_run_(false),
       channel_id_source_callback_(nullptr),
       verify_context_(verify_context),
       proof_verify_callback_(nullptr),
+      proof_handler_(proof_handler),
       stateless_reject_received_(false) {
   DCHECK_EQ(Perspective::IS_CLIENT, session->connection()->perspective());
 }
 
 QuicCryptoClientStream::~QuicCryptoClientStream() {
   if (channel_id_source_callback_) {
     channel_id_source_callback_->Cancel();
   }
   if (proof_verify_callback_) {
     proof_verify_callback_->Cancel();
@@ skipping 219 matching lines @@
 
   if (error != QUIC_NO_ERROR) {
     // Flush the cached config so that, if it's bad, the server has a
     // chance to send us another in the future.
     cached->InvalidateServerConfig();
     CloseConnectionWithDetails(error, error_details);
     return;
   }
   channel_id_sent_ = (channel_id_key_.get() != nullptr);
   if (cached->proof_verify_details()) {
-    client_session()->OnProofVerifyDetailsAvailable(
+    proof_handler_->OnProofVerifyDetailsAvailable(
         *cached->proof_verify_details());
   }
   next_state_ = STATE_RECV_SHLO;
   SendHandshakeMessage(out);
   // Be prepared to decrypt with the new server write key.
   session()->connection()->SetAlternativeDecrypter(
       ENCRYPTION_INITIAL,
       crypto_negotiated_params_.initial_crypters.decrypter.release(),
       true /* latch once used */);
   // Send subsequent packets under encryption on the assumption that the
@@ skipping 109 matching lines @@
 }
 
 void QuicCryptoClientStream::DoVerifyProofComplete(
     QuicCryptoClientConfig::CachedState* cached) {
   if (!proof_verify_start_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("Net.QuicSession.VerifyProofTime.CachedServerConfig",
                         base::TimeTicks::Now() - proof_verify_start_time_);
   }
   if (!verify_ok_) {
     if (verify_details_.get()) {
-      client_session()->OnProofVerifyDetailsAvailable(*verify_details_);
+      proof_handler_->OnProofVerifyDetailsAvailable(*verify_details_);
     }
     if (num_client_hellos_ == 0) {
       cached->Clear();
       next_state_ = STATE_INITIALIZE;
       return;
     }
     next_state_ = STATE_NONE;
     UMA_HISTOGRAM_BOOLEAN("Net.QuicVerifyProofFailed.HandshakeConfirmed",
                           handshake_confirmed());
     CloseConnectionWithDetails(QUIC_PROOF_INVALID,
@@ skipping 142 matching lines @@
     update_ignored = true;
     next_state_ = STATE_NONE;
   }
   UMA_HISTOGRAM_COUNTS("Net.QuicNumServerConfig.UpdateMessagesIgnored",
                        update_ignored);
 }
 
 void QuicCryptoClientStream::SetCachedProofValid(
     QuicCryptoClientConfig::CachedState* cached) {
   cached->SetProofValid();
-  client_session()->OnProofValid(*cached);
+  proof_handler_->OnProofValid(*cached);
 }
 
 bool QuicCryptoClientStream::RequiresChannelID(
     QuicCryptoClientConfig::CachedState* cached) {
   if (server_id_.privacy_mode() == PRIVACY_MODE_ENABLED ||
       !crypto_config_->channel_id_source()) {
     return false;
   }
   const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
   if (!scfg) {  // scfg may be null then we send an inchoate CHLO.
     return false;
   }
   const QuicTag* their_proof_demands;
   size_t num_their_proof_demands;
   if (scfg->GetTaglist(kPDMD, &their_proof_demands, &num_their_proof_demands) !=
       QUIC_NO_ERROR) {
     return false;
   }
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     if (their_proof_demands[i] == kCHID) {
       return true;
     }
   }
   return false;
 }
 
-QuicClientSessionBase* QuicCryptoClientStream::client_session() {
-  return reinterpret_cast<QuicClientSessionBase*>(session());
-}
-
 }  // namespace net