Conversion of a QUIC method to an async signature and resulting fallout. No functional change inten…

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 118 matching lines @@
   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);
   }
 
-  CryptoHandshakeMessage reply;
-  DiversificationNonce diversification_nonce;
   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,
-                         &diversification_nonce, &error_details);
+      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));
+}
+
+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;
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(error, error_details);
     return;
   }
 
-  if (reply.tag() != kSHLO) {
-    if (reply.tag() == kSREJ) {
+  if (reply->tag() != kSHLO) {
+    if (reply->tag() == kSREJ) {
       DCHECK(use_stateless_rejects_if_peer_supported_);
       DCHECK(peer_supports_stateless_rejects_);
       // Before sending the SREJ, cause the connection to save crypto packets
       // so that they can be added to the time wait list manager and
       // retransmitted.
       session()->connection()->EnableSavingCryptoPackets();
     }
-    SendHandshakeMessage(reply);
+    SendHandshakeMessage(*reply);
 
-    if (reply.tag() == kSREJ) {
+    if (reply->tag() == kSREJ) {
       DCHECK(use_stateless_rejects_if_peer_supported_);
       DCHECK(peer_supports_stateless_rejects_);
       DCHECK(!handshake_confirmed());
       DVLOG(1) << "Closing connection "
                << session()->connection()->connection_id()
                << " because of a stateless reject.";
       session()->connection()->CloseConnection(
           QUIC_CRYPTO_HANDSHAKE_STATELESS_REJECT, "stateless reject",
           ConnectionCloseBehavior::SILENT_CLOSE);
     }
     return;
   }
 
   // If we are returning a SHLO then we accepted the handshake.  Now
   // process the negotiated configuration options as part of the
   // session config.
   QuicConfig* config = session()->config();
   OverrideQuicConfigDefaults(config);
-  error = config->ProcessPeerHello(message, CLIENT, &error_details);
-  if (error != QUIC_NO_ERROR) {
-    CloseConnectionWithDetails(error, error_details);
+  string process_error_details;
+  const QuicErrorCode process_error =
+      config->ProcessPeerHello(message, CLIENT, &process_error_details);
+  if (process_error != QUIC_NO_ERROR) {
+    CloseConnectionWithDetails(process_error, process_error_details);
     return;
   }
 
   session()->OnConfigNegotiated();
 
-  config->ToHandshakeMessage(&reply);
+  config->ToHandshakeMessage(reply.get());
 
   // Receiving a full CHLO implies the client is prepared to decrypt with
   // the new server write key.  We can start to encrypt with the new server
   // write key.
   //
   // NOTE: the SHLO will be encrypted with the new server write key.
   session()->connection()->SetEncrypter(
       ENCRYPTION_INITIAL,
       crypto_negotiated_params_.initial_crypters.encrypter.release());
   session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
   // Set the decrypter immediately so that we no longer accept unencrypted
   // packets.
   session()->connection()->SetDecrypter(
       ENCRYPTION_INITIAL,
       crypto_negotiated_params_.initial_crypters.decrypter.release());
   if (version() > QUIC_VERSION_32) {
-    session()->connection()->SetDiversificationNonce(diversification_nonce);
+    session()->connection()->SetDiversificationNonce(*diversification_nonce);
   }
 
-  SendHandshakeMessage(reply);
+  SendHandshakeMessage(*reply);
 
   session()->connection()->SetEncrypter(
       ENCRYPTION_FORWARD_SECURE,
       crypto_negotiated_params_.forward_secure_crypters.encrypter.release());
   session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_FORWARD_SECURE);
 
   session()->connection()->SetAlternativeDecrypter(
       ENCRYPTION_FORWARD_SECURE,
       crypto_negotiated_params_.forward_secure_crypters.decrypter.release(),
       false /* don't latch */);
@@ skipping 152 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(
     scoped_refptr<ValidateClientHelloResultCallback::Result> result,
     std::unique_ptr<ProofSource::Details> proof_source_details,
     CryptoHandshakeMessage* reply,
     DiversificationNonce* out_diversification_nonce,
     string* error_details) {
   const CryptoHandshakeMessage& message = result->client_hello;
   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));
   }
   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);
-  return crypto_config_->ProcessClientHello(
+
+  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_, reply, out_diversification_nonce, error_details);
+      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;
 }
 
 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