Landing Recent QUIC changes until 2015-11-09 20:32 UTC

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 "base/metrics/histogram_macros.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 137 matching lines @@
   return channel_id_source_callback_run_;
 }
 
 void QuicCryptoClientStream::HandleServerConfigUpdateMessage(
     const CryptoHandshakeMessage& server_config_update) {
   DCHECK(server_config_update.tag() == kSCUP);
   string error_details;
   QuicCryptoClientConfig::CachedState* cached =
       crypto_config_->LookupOrCreate(server_id_);
   QuicErrorCode error = crypto_config_->ProcessServerConfigUpdate(
-      server_config_update,
-      session()->connection()->clock()->WallNow(),
-      cached,
-      &crypto_negotiated_params_,
+      server_config_update, session()->connection()->clock()->WallNow(),
+      session()->connection()->version(), cached, &crypto_negotiated_params_,
       &error_details);
 
   if (error != QUIC_NO_ERROR) {
     CloseConnectionWithDetails(
         error, "Server config update invalid: " + error_details);
     return;
   }
 
   DCHECK(handshake_confirmed());
   if (proof_verify_callback_) {
@@ skipping 191 matching lines @@
   // that we need.
   if ((in->tag() != kREJ) && (in->tag() != kSREJ)) {
     next_state_ = STATE_NONE;
     CloseConnectionWithDetails(QUIC_INVALID_CRYPTO_MESSAGE_TYPE,
                                "Expected REJ");
     return;
   }
   stateless_reject_received_ = in->tag() == kSREJ;
   string error_details;
   QuicErrorCode error = crypto_config_->ProcessRejection(
-      *in, session()->connection()->clock()->WallNow(), cached,
-      &crypto_negotiated_params_, &error_details);
+      *in, session()->connection()->clock()->WallNow(),
+      session()->connection()->version(), cached, &crypto_negotiated_params_,
+      &error_details);
 
   if (error != QUIC_NO_ERROR) {
     next_state_ = STATE_NONE;
     CloseConnectionWithDetails(error, error_details);
     return;
   }
   if (!cached->proof_valid()) {
     if (!cached->signature().empty()) {
       // Note that we only verify the proof if the cached proof is not
       // valid. If the cached proof is valid here, someone else must have
@@ skipping 14 matching lines @@
   next_state_ = STATE_VERIFY_PROOF_COMPLETE;
   generation_counter_ = cached->generation_counter();
 
   ProofVerifierCallbackImpl* proof_verify_callback =
       new ProofVerifierCallbackImpl(this);
 
   verify_ok_ = false;
 
   QuicAsyncStatus status = verifier->VerifyProof(
       server_id_.host(), cached->server_config(), cached->certs(),
-      cached->signature(), verify_context_.get(), &verify_error_details_,
-      &verify_details_, proof_verify_callback);
+      cached->cert_sct(), cached->signature(), verify_context_.get(),
+      &verify_error_details_, &verify_details_, proof_verify_callback);
 
   switch (status) {
     case QUIC_PENDING:
       proof_verify_callback_ = proof_verify_callback;
       DVLOG(1) << "Doing VerifyProof";
       break;
     case QUIC_FAILURE:
       delete proof_verify_callback;
       break;
     case QUIC_SUCCESS:
@@ skipping 194 matching lines @@
     }
   }
   return false;
 }
 
 QuicClientSessionBase* QuicCryptoClientStream::client_session() {
   return reinterpret_cast<QuicClientSessionBase*>(session());
 }
 
 }  // namespace net