Landing Recent QUIC changes until 2016-07-02 02:45 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 <memory>
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 303 matching lines @@
   AppendFixed(&out);
 
   // Send a local timestamp to the server.
   out.SetValue(kCTIM,
                session()->connection()->clock()->WallNow().ToUNIXSeconds());
 
   if (!cached->IsComplete(session()->connection()->clock()->WallNow())) {
     crypto_config_->FillInchoateClientHello(
         server_id_, session()->connection()->supported_versions().front(),
         cached, session()->connection()->random_generator(),
-        &crypto_negotiated_params_, &out);
+        /* demand_x509_proof= */ true, &crypto_negotiated_params_, &out);
     // Pad the inchoate client hello to fill up a packet.
     const QuicByteCount kFramingOverhead = 50;  // A rough estimate.
     const QuicByteCount max_packet_size =
         session()->connection()->max_packet_length();
     if (max_packet_size <= kFramingOverhead) {
       DLOG(DFATAL) << "max_packet_length (" << max_packet_size
                    << ") has no room for framing overhead.";
       CloseConnectionWithDetails(QUIC_INTERNAL_ERROR,
                                  "max_packet_size too smalll");
       return;
@@ skipping 48 matching lines @@
       ENCRYPTION_INITIAL,
       crypto_negotiated_params_.initial_crypters.decrypter.release(),
       true /* latch once used */);
   // Send subsequent packets under encryption on the assumption that the
   // server will accept the handshake.
   session()->connection()->SetEncrypter(
       ENCRYPTION_INITIAL,
       crypto_negotiated_params_.initial_crypters.encrypter.release());
   session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
 
-  if (FLAGS_quic_reply_to_rej) {
-    // TODO(ianswett): Merge ENCRYPTION_REESTABLISHED and
-    // ENCRYPTION_FIRST_ESTABLSIHED.
-    encryption_established_ = true;
-    session()->OnCryptoHandshakeEvent(QuicSession::ENCRYPTION_REESTABLISHED);
-  } else {
-    if (!encryption_established_) {
-      encryption_established_ = true;
-      session()->OnCryptoHandshakeEvent(
-          QuicSession::ENCRYPTION_FIRST_ESTABLISHED);
-    } else {
-      session()->OnCryptoHandshakeEvent(QuicSession::ENCRYPTION_REESTABLISHED);
-    }
-  }
+  // TODO(ianswett): Merge ENCRYPTION_REESTABLISHED and
+  // ENCRYPTION_FIRST_ESTABLSIHED
+  encryption_established_ = true;
+  session()->OnCryptoHandshakeEvent(QuicSession::ENCRYPTION_REESTABLISHED);
 }
 
 void QuicCryptoClientStream::DoReceiveREJ(
     const CryptoHandshakeMessage* in,
     QuicCryptoClientConfig::CachedState* cached) {
   // We sent a dummy CHLO because we didn't have enough information to
   // perform a handshake, or we sent a full hello that the server
   // rejected. Here we hope to have a REJ that contains the information
   // that we need.
   if ((in->tag() != kREJ) && (in->tag() != kSREJ)) {
@@ skipping 62 matching lines @@
 
   ProofVerifierCallbackImpl* proof_verify_callback =
       new ProofVerifierCallbackImpl(this);
 
   verify_ok_ = false;
 
   QuicAsyncStatus status = verifier->VerifyProof(
       server_id_.host(), server_id_.port(), cached->server_config(),
       session()->connection()->version(), chlo_hash_, cached->certs(),
       cached->cert_sct(), cached->signature(), verify_context_.get(),
-      &verify_error_details_, &verify_details_, proof_verify_callback);
+      &verify_error_details_, &verify_details_,
+      std::unique_ptr<ProofVerifierCallback>(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:
-      delete proof_verify_callback;
       verify_ok_ = true;
       break;
   }
   return status;
 }
 
 void QuicCryptoClientStream::DoVerifyProofComplete(
     QuicCryptoClientConfig::CachedState* cached) {
   if (!proof_verify_start_time_.is_null()) {
     UMA_HISTOGRAM_TIMES("Net.QuicSession.VerifyProofTime.CachedServerConfig",
@@ skipping 185 matching lines @@
   }
   for (size_t i = 0; i < num_their_proof_demands; i++) {
     if (their_proof_demands[i] == kCHID) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net