Landing Recent QUIC changes until Sat Oct 29 14:59:35.

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 13 matching lines @@
 namespace net {
 
 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 {
+  void Run(QuicErrorCode error,
+           const string& error_details,
+           std::unique_ptr<CryptoHandshakeMessage> message,
+           std::unique_ptr<DiversificationNonce> diversification_nonce,
+           std::unique_ptr<net::ProofSource::Details> proof_source_details)
+      override {
     if (stream_ == nullptr) {
       return;
     }
 
     // Note: set the parent's callback to nullptr here because
     // FinishProcessingHandshakeMessageAfterProcessClientHello can be invoked
     // from either synchronous or asynchronous codepaths.  When the synchronous
     // codepaths are removed, this assignment should move to
     // FinishProcessingHandshakeMessageAfterProcessClientHello.
     stream_->process_client_hello_cb_ = nullptr;
 
     stream_->FinishProcessingHandshakeMessageAfterProcessClientHello(
         *result_, error, error_details, std::move(message),
-        std::move(diversification_nonce));
+        std::move(diversification_nonce), std::move(proof_source_details));
   }
 
   void Cancel() { stream_ = nullptr; }
 
  private:
   QuicCryptoServerStream* stream_;
   scoped_refptr<ValidateClientHelloResultCallback::Result> result_;
 };
 
 QuicCryptoServerStreamBase::QuicCryptoServerStreamBase(QuicSession* session)
@@ skipping 120 matching lines @@
   process_client_hello_cb_ = cb.get();
   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) {
+        std::unique_ptr<DiversificationNonce> diversification_nonce,
+        std::unique_ptr<ProofSource::Details> proof_source_details) {
   const CryptoHandshakeMessage& message = result.client_hello;
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(error, error_details);
     return;
   }
 
   if (reply->tag() != kSHLO) {
     if (reply->tag() == kSREJ) {
       DCHECK(use_stateless_rejects_if_peer_supported_);
       DCHECK(peer_supports_stateless_rejects_);
@@ skipping 79 matching lines @@
   if (FLAGS_enable_async_get_proof) {
     if (send_server_config_update_cb_ != nullptr) {
       DVLOG(1)
           << "Skipped server config update since one is already in progress";
       return;
     }
 
     std::unique_ptr<SendServerConfigUpdateCallback> cb(
         new SendServerConfigUpdateCallback(this));
     send_server_config_update_cb_ = cb.get();
+
     crypto_config_->BuildServerConfigUpdateMessage(
         session()->connection()->version(), chlo_hash_,
         previous_source_address_tokens_,
         session()->connection()->self_address().address(),
         session()->connection()->peer_address().address(),
         session()->connection()->clock(),
         session()->connection()->random_generator(), compressed_certs_cache_,
-        *crypto_negotiated_params_, cached_network_params, std::move(cb));
+        *crypto_negotiated_params_, cached_network_params,
+        (session()->config()->HasReceivedConnectionOptions()
+             ? session()->config()->ReceivedConnectionOptions()
+             : QuicTagVector()),
+        std::move(cb));
     return;
   }
 
   CryptoHandshakeMessage server_config_update_message;
   if (!crypto_config_->BuildServerConfigUpdateMessage(
           session()->connection()->version(), chlo_hash_,
           previous_source_address_tokens_,
           session()->connection()->self_address().address(),
           session()->connection()->peer_address().address(),
           session()->connection()->clock(),
           session()->connection()->random_generator(), compressed_certs_cache_,
           *crypto_negotiated_params_, cached_network_params,
+          (session()->config()->HasReceivedConnectionOptions()
+               ? session()->config()->ReceivedConnectionOptions()
+               : QuicTagVector()),
           &server_config_update_message)) {
     DVLOG(1) << "Server: Failed to build server config update (SCUP)!";
     return;
   }
 
   DVLOG(1) << "Server: Sending server config update: "
            << server_config_update_message.DebugString();
   const QuicData& data = server_config_update_message.GetSerialized();
   WriteOrBufferData(StringPiece(data.data(), data.length()), false, nullptr);
 
@@ skipping 108 matching lines @@
 }
 
 void QuicCryptoServerStream::ProcessClientHello(
     scoped_refptr<ValidateClientHelloResultCallback::Result> result,
     std::unique_ptr<ProofSource::Details> proof_source_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)) {
-    done_cb->Run(QUIC_HANDSHAKE_FAILED, error_details, nullptr, nullptr);
+    done_cb->Run(QUIC_HANDSHAKE_FAILED, error_details, nullptr, 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));
@@ skipping 39 matching lines @@
 QuicConnectionId QuicCryptoServerStream::GenerateConnectionIdForReject(
     bool use_stateless_rejects) {
   if (!use_stateless_rejects) {
     return 0;
   }
   return helper_->GenerateConnectionIdForReject(
       session()->connection()->connection_id());
 }
 
 }  // namespace net