Refactors for server-side asynchronous handshakes

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"
@@ skipping 105 matching lines @@
   CryptoUtils::HashHandshakeMessage(message, &chlo_hash_);
 
   std::unique_ptr<ValidateCallback> cb(new ValidateCallback(this));
   validate_client_hello_cb_ = cb.get();
   crypto_config_->ValidateClientHello(
       message, session()->connection()->peer_address().address(),
       session()->connection()->self_address().address(), version(),
       session()->connection()->clock(), &crypto_proof_, std::move(cb));
 }
 
+class QuicCryptoServerStream::ProcessClientHelloCallback
+    : public ProcessClientHelloResultCallback {
+ public:
+  ProcessClientHelloCallback(
+      QuicCryptoServerStream* stream,
+      const scoped_refptr<ValidateClientHelloResultCallback::Result>& result)
+      : stream_(stream), result_(result) {}
+
+  void Run(
+      QuicErrorCode error,
+      const string& error_details,
+      std::unique_ptr<CryptoHandshakeMessage> message,
+      std::unique_ptr<DiversificationNonce> diversification_nonce) override {
+    stream_->FinishProcessingHandshakeMessageAfterProcessClientHello(
+        *result_, error, error_details, std::move(message),
+        std::move(diversification_nonce));
+  }
+
+ private:
+  QuicCryptoServerStream* stream_;
+  scoped_refptr<ValidateClientHelloResultCallback::Result> result_;
+};
+
 void QuicCryptoServerStream::FinishProcessingHandshakeMessage(
     scoped_refptr<ValidateClientHelloResultCallback::Result> result,
     std::unique_ptr<ProofSource::Details> details) {
   const CryptoHandshakeMessage& message = result->client_hello;
 
   // Clear the callback that got us here.
   DCHECK(validate_client_hello_cb_ != nullptr);
   validate_client_hello_cb_ = nullptr;
 
   if (use_stateless_rejects_if_peer_supported_) {
     peer_supports_stateless_rejects_ = DoesPeerSupportStatelessRejects(message);
   }
 
-  string error_details;
-  std::unique_ptr<CryptoHandshakeMessage> reply(new CryptoHandshakeMessage);
-  std::unique_ptr<DiversificationNonce> diversification_nonce(
-      new DiversificationNonce);
-  QuicErrorCode error =
-      ProcessClientHello(result, std::move(details), reply.get(),
-                         diversification_nonce.get(), &error_details);
-
-  // Note: this split exists to facilitate a future conversion of
-  // ProcessClientHello to an async signature.
-  FinishProcessingHandshakeMessageAfterProcessClientHello(
-      *result, error, error_details, std::move(reply),
-      std::move(diversification_nonce));
+  std::unique_ptr<ProcessClientHelloCallback> cb(
+      new ProcessClientHelloCallback(this, result));
+  ProcessClientHello(result, std::move(details), std::move(cb));
 }
 
 void QuicCryptoServerStream::
     FinishProcessingHandshakeMessageAfterProcessClientHello(
         const ValidateClientHelloResultCallback::Result& result,
         QuicErrorCode error,
         const string& error_details,
         std::unique_ptr<CryptoHandshakeMessage> reply,
         std::unique_ptr<DiversificationNonce> diversification_nonce) {
   const CryptoHandshakeMessage& message = result.client_hello;
@@ skipping 228 matching lines @@
       len--;
       if ((*output)[len - 1] == '=') {
         len--;
       }
       output->resize(len);
     }
   }
   return true;
 }
 
-class QuicCryptoServerStream::ProcessClientHelloCallback
-    : public ProcessClientHelloResultCallback {
- public:
-  ProcessClientHelloCallback(QuicErrorCode* error,
-                             string* error_details,
-                             CryptoHandshakeMessage* message,
-                             DiversificationNonce* diversification_nonce)
-      : error_(error),
-        error_details_(error_details),
-        message_(message),
-        diversification_nonce_(diversification_nonce) {}
-
-  void Run(
-      QuicErrorCode error,
-      const string& error_details,
-      std::unique_ptr<CryptoHandshakeMessage> message,
-      std::unique_ptr<DiversificationNonce> diversification_nonce) override {
-    *error_ = error;
-    *error_details_ = error_details;
-    if (message != nullptr) {
-      *message_ = *message;
-    }
-    if (diversification_nonce != nullptr) {
-      *diversification_nonce_ = *diversification_nonce;
-    }
-    // NOTE: copies the message, nonce, and error details.  This is a temporary
-    // condition until this codepath is fully asynchronized.
-    // TODO(gredner): Fix this.
-  }
-
- private:
-  QuicErrorCode* error_;
-  string* error_details_;
-  CryptoHandshakeMessage* message_;
-  DiversificationNonce* diversification_nonce_;
-};
-
-QuicErrorCode QuicCryptoServerStream::ProcessClientHello(
+void QuicCryptoServerStream::ProcessClientHello(
     scoped_refptr<ValidateClientHelloResultCallback::Result> result,
     std::unique_ptr<ProofSource::Details> proof_source_details,
-    CryptoHandshakeMessage* reply,
-    DiversificationNonce* out_diversification_nonce,
-    string* error_details) {
+    std::unique_ptr<ProcessClientHelloResultCallback> done_cb) {
   const CryptoHandshakeMessage& message = result->client_hello;
+  string error_details;
   if (!helper_->CanAcceptClientHello(
-          message, session()->connection()->self_address(), error_details)) {
-    return QUIC_HANDSHAKE_FAILED;
+          message, session()->connection()->self_address(), &error_details)) {
+    done_cb->Run(QUIC_HANDSHAKE_FAILED, error_details, nullptr, nullptr);
+    return;
   }
 
   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));
   }
   previous_source_address_tokens_ = result->info.source_address_tokens;
 
   const bool use_stateless_rejects_in_crypto_config =
       use_stateless_rejects_if_peer_supported_ &&
       peer_supports_stateless_rejects_;
   QuicConnection* connection = session()->connection();
   const QuicConnectionId server_designated_connection_id =
       GenerateConnectionIdForReject(use_stateless_rejects_in_crypto_config);
-
-  QuicErrorCode error = QUIC_NO_ERROR;
-  std::unique_ptr<ProcessClientHelloCallback> cb(new ProcessClientHelloCallback(
-      &error, error_details, reply, out_diversification_nonce));
   crypto_config_->ProcessClientHello(
       result, /*reject_only=*/false, connection->connection_id(),
       connection->self_address().address(), connection->peer_address(),
       version(), connection->supported_versions(),
       use_stateless_rejects_in_crypto_config, server_designated_connection_id,
       connection->clock(), connection->random_generator(),
       compressed_certs_cache_, &crypto_negotiated_params_, &crypto_proof_,
       QuicCryptoStream::CryptoMessageFramingOverhead(version()),
-      chlo_packet_size_, std::move(cb));
-  // NOTE: assumes that ProcessClientHello invokes the callback synchronously.
-  // This is a temporary condition until these codepaths are fully
-  // asynchronized.
-  // TODO(gredner): fix this.
-
-  return error;
+      chlo_packet_size_, std::move(done_cb));
 }
 
 void QuicCryptoServerStream::OverrideQuicConfigDefaults(QuicConfig* config) {}
 
 QuicCryptoServerStream::ValidateCallback::ValidateCallback(
     QuicCryptoServerStream* parent)
     : parent_(parent) {}
 
 void QuicCryptoServerStream::ValidateCallback::Cancel() {
   parent_ = nullptr;
@@ skipping 11 matching lines @@
 QuicConnectionId QuicCryptoServerStream::GenerateConnectionIdForReject(
     bool use_stateless_rejects) {
   if (!use_stateless_rejects) {
     return 0;
   }
   return helper_->GenerateConnectionIdForReject(
       session()->connection()->connection_id());
 }
 
 }  // namespace net