diff --git a/quic/core/http/quic_server_session_base_test.cc b/quic/core/http/quic_server_session_base_test.cc
index 3e9437f..b4072c5 100644
--- a/quic/core/http/quic_server_session_base_test.cc
+++ b/quic/core/http/quic_server_session_base_test.cc
@@ -13,6 +13,7 @@
 #include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
 #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
+#include "net/third_party/quiche/src/quic/core/quic_crypto_server_handshaker.h"
 #include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/core/tls_server_handshaker.h"
@@ -456,21 +457,22 @@
                   "ShouldCreateIncomingStream called when disconnected");
 }
 
-class MockQuicCryptoServerStream : public QuicCryptoServerStream {
+class MockQuicCryptoServerHandshaker : public QuicCryptoServerHandshaker {
  public:
-  explicit MockQuicCryptoServerStream(
+  explicit MockQuicCryptoServerHandshaker(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicServerSessionBase* session,
       QuicCryptoServerStreamBase::Helper* helper)
-      : QuicCryptoServerStream(crypto_config,
-                               compressed_certs_cache,
-                               session,
-                               helper) {}
-  MockQuicCryptoServerStream(const MockQuicCryptoServerStream&) = delete;
-  MockQuicCryptoServerStream& operator=(const MockQuicCryptoServerStream&) =
+      : QuicCryptoServerHandshaker(crypto_config,
+                                   compressed_certs_cache,
+                                   session,
+                                   helper) {}
+  MockQuicCryptoServerHandshaker(const MockQuicCryptoServerHandshaker&) =
       delete;
-  ~MockQuicCryptoServerStream() override {}
+  MockQuicCryptoServerHandshaker& operator=(
+      const MockQuicCryptoServerHandshaker&) = delete;
+  ~MockQuicCryptoServerHandshaker() override {}
 
   MOCK_METHOD1(SendServerConfigUpdate,
                void(const CachedNetworkParameters* cached_network_parameters));
@@ -516,11 +518,11 @@
         /*is_static=*/true);
   }
   QuicServerSessionBasePeer::SetCryptoStream(session_.get(), nullptr);
-  MockQuicCryptoServerStream* quic_crypto_stream = nullptr;
+  MockQuicCryptoServerHandshaker* quic_crypto_stream = nullptr;
   MockTlsServerHandshaker* tls_server_stream = nullptr;
   if (session_->connection()->version().handshake_protocol ==
       PROTOCOL_QUIC_CRYPTO) {
-    quic_crypto_stream = new MockQuicCryptoServerStream(
+    quic_crypto_stream = new MockQuicCryptoServerHandshaker(
         &crypto_config_, &compressed_certs_cache_, session_.get(),
         &stream_helper_);
     QuicServerSessionBasePeer::SetCryptoStream(session_.get(),
@@ -651,8 +653,9 @@
   connection_->AdvanceTime(
       QuicTime::Delta::FromSeconds(kNumSecondsPerHour + 1));
 
-  QuicCryptoServerStream* crypto_stream = static_cast<QuicCryptoServerStream*>(
-      QuicSessionPeer::GetMutableCryptoStream(session_.get()));
+  QuicCryptoServerStreamBase* crypto_stream =
+      static_cast<QuicCryptoServerStreamBase*>(
+          QuicSessionPeer::GetMutableCryptoStream(session_.get()));
 
   // No effect if no CachedNetworkParameters provided.
   EXPECT_CALL(*connection_, ResumeConnectionState(_, _)).Times(0);
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index a4994a0..ba25c21 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -48,12 +48,11 @@
 
 QuicCryptoServerHandshaker::QuicCryptoServerHandshaker(
     const QuicCryptoServerConfig* crypto_config,
-    QuicCryptoServerStream* stream,
     QuicCompressedCertsCache* compressed_certs_cache,
     QuicSession* session,
     QuicCryptoServerStreamBase::Helper* helper)
-    : QuicCryptoHandshaker(stream, session),
-      stream_(stream),
+    : QuicCryptoServerStreamBase(session),
+      QuicCryptoHandshaker(this, session),
       session_(session),
       delegate_(session),
       crypto_config_(crypto_config),
@@ -101,14 +100,14 @@
 
   // Do not process handshake messages after the handshake is confirmed.
   if (one_rtt_keys_available_) {
-    stream_->OnUnrecoverableError(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE,
-                                  "Unexpected handshake message from client");
+    OnUnrecoverableError(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE,
+                         "Unexpected handshake message from client");
     return;
   }
 
   if (message.tag() != kCHLO) {
-    stream_->OnUnrecoverableError(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
-                                  "Handshake packet not CHLO");
+    OnUnrecoverableError(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
+                         "Handshake packet not CHLO");
     return;
   }
 
@@ -117,9 +116,8 @@
     // Already processing some other handshake message.  The protocol
     // does not allow for clients to send multiple handshake messages
     // before the server has a chance to respond.
-    stream_->OnUnrecoverableError(
-        QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO,
-        "Unexpected handshake message while processing CHLO");
+    OnUnrecoverableError(QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO,
+                         "Unexpected handshake message while processing CHLO");
     return;
   }
 
@@ -166,7 +164,7 @@
 
   const CryptoHandshakeMessage& message = result.client_hello;
   if (error != QUIC_NO_ERROR) {
-    stream_->OnUnrecoverableError(error, error_details);
+    OnUnrecoverableError(error, error_details);
     return;
   }
 
@@ -186,7 +184,7 @@
   const QuicErrorCode process_error =
       config->ProcessPeerHello(message, CLIENT, &process_error_details);
   if (process_error != QUIC_NO_ERROR) {
-    stream_->OnUnrecoverableError(process_error, process_error_details);
+    OnUnrecoverableError(process_error, process_error_details);
     return;
   }
 
@@ -286,8 +284,8 @@
                 << message.DebugString();
   if (!QuicVersionUsesCryptoFrames(transport_version())) {
     const QuicData& data = message.GetSerialized();
-    stream_->WriteOrBufferData(
-        quiche::QuicheStringPiece(data.data(), data.length()), false, nullptr);
+    WriteOrBufferData(quiche::QuicheStringPiece(data.data(), data.length()),
+                      false, nullptr);
   } else {
     SendHandshakeMessage(message);
   }
@@ -330,6 +328,10 @@
   }
 }
 
+void QuicCryptoServerHandshaker::OnHandshakeDoneReceived() {
+  DCHECK(false);
+}
+
 bool QuicCryptoServerHandshaker::ShouldSendExpectCTHeader() const {
   return signed_config_->proof.send_expect_ct_header;
 }
diff --git a/quic/core/quic_crypto_server_handshaker.h b/quic/core/quic_crypto_server_handshaker.h
index 257ee16..6c4b710 100644
--- a/quic/core/quic_crypto_server_handshaker.h
+++ b/quic/core/quic_crypto_server_handshaker.h
@@ -20,18 +20,11 @@
 class QuicCryptoServerStreamPeer;
 }  // namespace test
 
+// TODO(nharper): Rename this class to QuicCryptoServerStream.
 class QUIC_EXPORT_PRIVATE QuicCryptoServerHandshaker
-    : public QuicCryptoServerStream::HandshakerInterface,
+    : public QuicCryptoServerStreamBase,
       public QuicCryptoHandshaker {
  public:
-  // |crypto_config| must outlive the stream.
-  // |session| must outlive the stream.
-  // |helper| must outlive the stream.
-  QuicCryptoServerHandshaker(const QuicCryptoServerConfig* crypto_config,
-                             QuicCryptoServerStream* stream,
-                             QuicCompressedCertsCache* compressed_certs_cache,
-                             QuicSession* session,
-                             QuicCryptoServerStreamBase::Helper* helper);
   QuicCryptoServerHandshaker(const QuicCryptoServerHandshaker&) = delete;
   QuicCryptoServerHandshaker& operator=(const QuicCryptoServerHandshaker&) =
       delete;
@@ -51,6 +44,8 @@
   void SetPreviousCachedNetworkParams(
       CachedNetworkParameters cached_network_params) override;
   void OnPacketDecrypted(EncryptionLevel level) override;
+  void OnOneRttPacketAcknowledged() override {}
+  void OnHandshakeDoneReceived() override;
   bool ShouldSendExpectCTHeader() const override;
 
   // From QuicCryptoStream
@@ -66,6 +61,20 @@
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
 
  protected:
+  QUIC_EXPORT_PRIVATE friend std::unique_ptr<QuicCryptoServerStreamBase>
+  CreateCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
+                           QuicCompressedCertsCache* compressed_certs_cache,
+                           QuicSession* session,
+                           QuicCryptoServerStreamBase::Helper* helper);
+
+  // |crypto_config| must outlive the stream.
+  // |session| must outlive the stream.
+  // |helper| must outlive the stream.
+  QuicCryptoServerHandshaker(const QuicCryptoServerConfig* crypto_config,
+                             QuicCompressedCertsCache* compressed_certs_cache,
+                             QuicSession* session,
+                             QuicCryptoServerStreamBase::Helper* helper);
+
   virtual void ProcessClientHello(
       QuicReferenceCountedPointer<ValidateClientHelloResultCallback::Result>
           result,
@@ -161,8 +170,6 @@
     return session_->transport_version();
   }
 
-  QuicCryptoServerStream* stream_;
-
   QuicSession* session_;
   HandshakerDelegateInterface* delegate_;
 
diff --git a/quic/core/quic_crypto_server_stream.cc b/quic/core/quic_crypto_server_stream.cc
index dbbb541..a4ee9d1 100644
--- a/quic/core/quic_crypto_server_stream.cc
+++ b/quic/core/quic_crypto_server_stream.cc
@@ -34,8 +34,9 @@
     QuicCryptoServerStreamBase::Helper* helper) {
   switch (session->connection()->version().handshake_protocol) {
     case PROTOCOL_QUIC_CRYPTO:
-      return std::unique_ptr<QuicCryptoServerStream>(new QuicCryptoServerStream(
-          crypto_config, compressed_certs_cache, session, helper));
+      return std::unique_ptr<QuicCryptoServerHandshaker>(
+          new QuicCryptoServerHandshaker(crypto_config, compressed_certs_cache,
+                                         session, helper));
     case PROTOCOL_TLS1_3:
       return std::unique_ptr<TlsServerHandshaker>(new TlsServerHandshaker(
           session, crypto_config->ssl_ctx(), crypto_config->proof_source()));
@@ -48,156 +49,4 @@
   return nullptr;
 }
 
-QuicCryptoServerStream::QuicCryptoServerStream(
-    const QuicCryptoServerConfig* crypto_config,
-    QuicCompressedCertsCache* compressed_certs_cache,
-    QuicSession* session,
-    QuicCryptoServerStreamBase::Helper* helper)
-    : QuicCryptoServerStream(crypto_config,
-                             compressed_certs_cache,
-                             session,
-                             helper,
-                             /*handshaker*/ nullptr) {}
-
-QuicCryptoServerStream::QuicCryptoServerStream(
-    const QuicCryptoServerConfig* crypto_config,
-    QuicCompressedCertsCache* compressed_certs_cache,
-    QuicSession* session,
-    QuicCryptoServerStreamBase::Helper* helper,
-    std::unique_ptr<HandshakerInterface> handshaker)
-    : QuicCryptoServerStreamBase(session),
-      handshaker_(std::move(handshaker)),
-      crypto_config_(crypto_config),
-      compressed_certs_cache_(compressed_certs_cache),
-      helper_(helper) {
-  DCHECK_EQ(Perspective::IS_SERVER, session->connection()->perspective());
-  if (!handshaker_) {
-    switch (session->connection()->version().handshake_protocol) {
-      case PROTOCOL_QUIC_CRYPTO:
-        handshaker_ = std::make_unique<QuicCryptoServerHandshaker>(
-            crypto_config_, this, compressed_certs_cache_, session, helper_);
-        break;
-      case PROTOCOL_TLS1_3:
-        QUIC_BUG
-            << "Attempting to create QuicCryptoServerStream for TLS version";
-        break;
-      case PROTOCOL_UNSUPPORTED:
-        QUIC_BUG << "Attempting to create QuicCryptoServerStream for unknown "
-                    "handshake protocol";
-    }
-  }
-}
-
-QuicCryptoServerStream::~QuicCryptoServerStream() {}
-
-void QuicCryptoServerStream::CancelOutstandingCallbacks() {
-  if (handshaker_) {
-    handshaker_->CancelOutstandingCallbacks();
-  }
-}
-
-bool QuicCryptoServerStream::GetBase64SHA256ClientChannelID(
-    std::string* output) const {
-  return handshaker_->GetBase64SHA256ClientChannelID(output);
-}
-
-void QuicCryptoServerStream::SendServerConfigUpdate(
-    const CachedNetworkParameters* cached_network_params) {
-  handshaker_->SendServerConfigUpdate(cached_network_params);
-}
-
-uint8_t QuicCryptoServerStream::NumHandshakeMessages() const {
-  return handshaker_->NumHandshakeMessages();
-}
-
-uint8_t QuicCryptoServerStream::NumHandshakeMessagesWithServerNonces() const {
-  return handshaker_->NumHandshakeMessagesWithServerNonces();
-}
-
-int QuicCryptoServerStream::NumServerConfigUpdateMessagesSent() const {
-  return handshaker_->NumServerConfigUpdateMessagesSent();
-}
-
-const CachedNetworkParameters*
-QuicCryptoServerStream::PreviousCachedNetworkParams() const {
-  return handshaker_->PreviousCachedNetworkParams();
-}
-
-bool QuicCryptoServerStream::ZeroRttAttempted() const {
-  return handshaker_->ZeroRttAttempted();
-}
-
-void QuicCryptoServerStream::SetPreviousCachedNetworkParams(
-    CachedNetworkParameters cached_network_params) {
-  handshaker_->SetPreviousCachedNetworkParams(cached_network_params);
-}
-
-bool QuicCryptoServerStream::ShouldSendExpectCTHeader() const {
-  return handshaker_->ShouldSendExpectCTHeader();
-}
-
-bool QuicCryptoServerStream::encryption_established() const {
-  if (!handshaker_) {
-    return false;
-  }
-  return handshaker_->encryption_established();
-}
-
-bool QuicCryptoServerStream::one_rtt_keys_available() const {
-  if (!handshaker_) {
-    return false;
-  }
-  return handshaker_->one_rtt_keys_available();
-}
-
-const QuicCryptoNegotiatedParameters&
-QuicCryptoServerStream::crypto_negotiated_params() const {
-  return handshaker_->crypto_negotiated_params();
-}
-
-CryptoMessageParser* QuicCryptoServerStream::crypto_message_parser() {
-  return handshaker_->crypto_message_parser();
-}
-
-void QuicCryptoServerStream::OnPacketDecrypted(EncryptionLevel level) {
-  handshaker_->OnPacketDecrypted(level);
-}
-
-void QuicCryptoServerStream::OnHandshakeDoneReceived() {
-  DCHECK(false);
-}
-
-HandshakeState QuicCryptoServerStream::GetHandshakeState() const {
-  return handshaker_->GetHandshakeState();
-}
-
-size_t QuicCryptoServerStream::BufferSizeLimitForLevel(
-    EncryptionLevel level) const {
-  return handshaker_->BufferSizeLimitForLevel(level);
-}
-
-void QuicCryptoServerStream::set_handshaker(
-    std::unique_ptr<QuicCryptoServerStream::HandshakerInterface> handshaker) {
-  CHECK(!handshaker_);
-  handshaker_ = std::move(handshaker);
-}
-
-QuicCryptoServerStream::HandshakerInterface*
-QuicCryptoServerStream::handshaker() const {
-  return handshaker_.get();
-}
-
-const QuicCryptoServerConfig* QuicCryptoServerStream::crypto_config() const {
-  return crypto_config_;
-}
-
-QuicCompressedCertsCache* QuicCryptoServerStream::compressed_certs_cache()
-    const {
-  return compressed_certs_cache_;
-}
-
-QuicCryptoServerStreamBase::Helper* QuicCryptoServerStream::helper() const {
-  return helper_;
-}
-
 }  // namespace quic
diff --git a/quic/core/quic_crypto_server_stream.h b/quic/core/quic_crypto_server_stream.h
index f96c45a..ad2689e 100644
--- a/quic/core/quic_crypto_server_stream.h
+++ b/quic/core/quic_crypto_server_stream.h
@@ -79,145 +79,6 @@
   virtual bool ShouldSendExpectCTHeader() const = 0;
 };
 
-class QUIC_EXPORT_PRIVATE QuicCryptoServerStream
-    : public QuicCryptoServerStreamBase {
- public:
-  // QuicCryptoServerStream creates a HandshakerInterface at construction time
-  // based on the QuicTransportVersion of the connection. Different
-  // HandshakerInterfaces provide implementations of different crypto handshake
-  // protocols. Currently QUIC crypto is the only protocol implemented; a future
-  // HandshakerInterface will use TLS as the handshake protocol.
-  // QuicCryptoServerStream delegates all of its public methods to its
-  // HandshakerInterface.
-  //
-  // This setup of the crypto stream delegating its implementation to the
-  // handshaker results in the handshaker reading and writing bytes on the
-  // crypto stream, instead of the handshake rpassing the stream bytes to send.
-  class QUIC_EXPORT_PRIVATE HandshakerInterface {
-   public:
-    virtual ~HandshakerInterface() {}
-
-    // Cancel any outstanding callbacks, such as asynchronous validation of
-    // client hello.
-    virtual void CancelOutstandingCallbacks() = 0;
-
-    // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
-    // SHA-256 hash of the client's ChannelID key and returns true, if the
-    // client presented a ChannelID. Otherwise it returns false.
-    virtual bool GetBase64SHA256ClientChannelID(std::string* output) const = 0;
-
-    // Sends the latest server config and source-address token to the client.
-    virtual void SendServerConfigUpdate(
-        const CachedNetworkParameters* cached_network_params) = 0;
-
-    // These are all accessors and setters to their respective counters.
-    virtual uint8_t NumHandshakeMessages() const = 0;
-    virtual uint8_t NumHandshakeMessagesWithServerNonces() const = 0;
-    virtual int NumServerConfigUpdateMessagesSent() const = 0;
-    virtual const CachedNetworkParameters* PreviousCachedNetworkParams()
-        const = 0;
-    virtual bool ZeroRttAttempted() const = 0;
-    virtual void SetPreviousCachedNetworkParams(
-        CachedNetworkParameters cached_network_params) = 0;
-    virtual void OnPacketDecrypted(EncryptionLevel level) = 0;
-
-    // NOTE: Indicating that the Expect-CT header should be sent here presents a
-    // layering violation to some extent. The Expect-CT header only applies to
-    // HTTP connections, while this class can be used for non-HTTP applications.
-    // However, it is exposed here because that is the only place where the
-    // configuration for the certificate used in the connection is accessible.
-    virtual bool ShouldSendExpectCTHeader() const = 0;
-
-    // Returns true once any encrypter (initial/0RTT or final/1RTT) has been set
-    // for the connection.
-    virtual bool encryption_established() const = 0;
-
-    // Returns true once 1RTT keys are available.
-    virtual bool one_rtt_keys_available() const = 0;
-
-    // Returns the parameters negotiated in the crypto handshake.
-    virtual const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
-        const = 0;
-
-    // Used by QuicCryptoStream to parse data received on this stream.
-    virtual CryptoMessageParser* crypto_message_parser() = 0;
-
-    // Get current handshake state.
-    virtual HandshakeState GetHandshakeState() const = 0;
-
-    // Used by QuicCryptoStream to know how much unprocessed data can be
-    // buffered at each encryption level.
-    virtual size_t BufferSizeLimitForLevel(EncryptionLevel level) const = 0;
-  };
-
-  QuicCryptoServerStream(const QuicCryptoServerStream&) = delete;
-  QuicCryptoServerStream& operator=(const QuicCryptoServerStream&) = delete;
-
-  ~QuicCryptoServerStream() override;
-
-  // From QuicCryptoServerStreamBase
-  void CancelOutstandingCallbacks() override;
-  bool GetBase64SHA256ClientChannelID(std::string* output) const override;
-  void SendServerConfigUpdate(
-      const CachedNetworkParameters* cached_network_params) override;
-  uint8_t NumHandshakeMessages() const override;
-  uint8_t NumHandshakeMessagesWithServerNonces() const override;
-  int NumServerConfigUpdateMessagesSent() const override;
-  const CachedNetworkParameters* PreviousCachedNetworkParams() const override;
-  bool ZeroRttAttempted() const override;
-  void SetPreviousCachedNetworkParams(
-      CachedNetworkParameters cached_network_params) override;
-  bool ShouldSendExpectCTHeader() const override;
-
-  bool encryption_established() const override;
-  bool one_rtt_keys_available() const override;
-  const QuicCryptoNegotiatedParameters& crypto_negotiated_params()
-      const override;
-  CryptoMessageParser* crypto_message_parser() override;
-  void OnPacketDecrypted(EncryptionLevel level) override;
-  void OnOneRttPacketAcknowledged() override {}
-  void OnHandshakeDoneReceived() override;
-  HandshakeState GetHandshakeState() const override;
-  size_t BufferSizeLimitForLevel(EncryptionLevel level) const override;
-
- protected:
-  QUIC_EXPORT_PRIVATE friend std::unique_ptr<QuicCryptoServerStreamBase>
-  CreateCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
-                           QuicCompressedCertsCache* compressed_certs_cache,
-                           QuicSession* session,
-                           QuicCryptoServerStreamBase::Helper* helper);
-
-  QuicCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
-                         QuicCompressedCertsCache* compressed_certs_cache,
-                         QuicSession* session,
-                         QuicCryptoServerStreamBase::Helper* helper);
-  // Provided so that subclasses can provide their own handshaker.
-  // set_handshaker can only be called if this QuicCryptoServerStream's
-  // handshaker hasn't been set yet. If set_handshaker is called outside of
-  // OnSuccessfulVersionNegotiation, then that method must be overridden to not
-  // set a handshaker.
-  QuicCryptoServerStream(const QuicCryptoServerConfig* crypto_config,
-                         QuicCompressedCertsCache* compressed_certs_cache,
-                         QuicSession* session,
-                         QuicCryptoServerStreamBase::Helper* helper,
-                         std::unique_ptr<HandshakerInterface> handshaker);
-  void set_handshaker(std::unique_ptr<HandshakerInterface> handshaker);
-  HandshakerInterface* handshaker() const;
-
-  const QuicCryptoServerConfig* crypto_config() const;
-  QuicCompressedCertsCache* compressed_certs_cache() const;
-  QuicCryptoServerStreamBase::Helper* helper() const;
-
- private:
-  std::unique_ptr<HandshakerInterface> handshaker_;
-
-  // Arguments from QuicCryptoServerStream constructor that might need to be
-  // passed to the HandshakerInterface constructor in its late construction.
-  const QuicCryptoServerConfig* crypto_config_;
-  QuicCompressedCertsCache* compressed_certs_cache_;
-  QuicCryptoServerStreamBase::Helper* helper_;
-};
-
 // Creates an appropriate QuicCryptoServerStream for the provided parameters,
 // including the version used by |session|. |crypto_config|, |session|, and
 // |helper| must all outlive the stream. The caller takes ownership of the
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 8265dde..0315c86 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -13,7 +13,7 @@
 #include "net/third_party/quiche/src/quic/core/http/http_encoder.h"
 #include "net/third_party/quiche/src/quic/core/proto/cached_network_parameters_proto.h"
 #include "net/third_party/quiche/src/quic/core/quic_connection.h"
-#include "net/third_party/quiche/src/quic/core/quic_crypto_server_stream.h"
+#include "net/third_party/quiche/src/quic/core/quic_crypto_server_handshaker.h"
 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
 #include "net/third_party/quiche/src/quic/core/quic_versions.h"
 #include "net/third_party/quiche/src/quic/core/tls_server_handshaker.h"
@@ -79,21 +79,22 @@
 
 const size_t kMaxStreamsForTest = 10;
 
-class MockQuicCryptoServerStream : public QuicCryptoServerStream {
+class MockQuicCryptoServerHandshaker : public QuicCryptoServerHandshaker {
  public:
-  explicit MockQuicCryptoServerStream(
+  explicit MockQuicCryptoServerHandshaker(
       const QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
       QuicSession* session,
       QuicCryptoServerStreamBase::Helper* helper)
-      : QuicCryptoServerStream(crypto_config,
-                               compressed_certs_cache,
-                               session,
-                               helper) {}
-  MockQuicCryptoServerStream(const MockQuicCryptoServerStream&) = delete;
-  MockQuicCryptoServerStream& operator=(const MockQuicCryptoServerStream&) =
+      : QuicCryptoServerHandshaker(crypto_config,
+                                   compressed_certs_cache,
+                                   session,
+                                   helper) {}
+  MockQuicCryptoServerHandshaker(const MockQuicCryptoServerHandshaker&) =
       delete;
-  ~MockQuicCryptoServerStream() override {}
+  MockQuicCryptoServerHandshaker& operator=(
+      const MockQuicCryptoServerHandshaker&) = delete;
+  ~MockQuicCryptoServerHandshaker() override {}
 
   MOCK_METHOD1(SendServerConfigUpdate,
                void(const CachedNetworkParameters* cached_network_parameters));
@@ -124,7 +125,7 @@
     QuicCryptoServerStreamBase::Helper* helper) {
   switch (session->connection()->version().handshake_protocol) {
     case PROTOCOL_QUIC_CRYPTO:
-      return new MockQuicCryptoServerStream(
+      return new MockQuicCryptoServerHandshaker(
           crypto_config, compressed_certs_cache, session, helper);
     case PROTOCOL_TLS1_3:
       return new MockTlsServerHandshaker(session, crypto_config->ssl_ctx(),