Reimplement QuicCryptoClientStream::WasChannelIDSent with a boolean

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 "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_client_session_base.h"
@@ skipping 60 matching lines @@
     const QuicServerId& server_id,
     QuicClientSessionBase* session,
     ProofVerifyContext* verify_context,
     QuicCryptoClientConfig* crypto_config)
     : QuicCryptoStream(session),
       next_state_(STATE_IDLE),
       num_client_hellos_(0),
       crypto_config_(crypto_config),
       server_id_(server_id),
       generation_counter_(0),
+      channel_id_sent_(false),
       channel_id_source_callback_(NULL),
       verify_context_(verify_context),
       proof_verify_callback_(NULL) {
 }
 
 QuicCryptoClientStream::~QuicCryptoClientStream() {
   if (channel_id_source_callback_) {
     channel_id_source_callback_->Cancel();
   }
   if (proof_verify_callback_) {
@@ skipping 12 matching lines @@
   next_state_ = STATE_INITIALIZE;
   DoHandshakeLoop(NULL);
   return true;
 }
 
 int QuicCryptoClientStream::num_sent_client_hellos() const {
   return num_client_hellos_;
 }
 
 bool QuicCryptoClientStream::WasChannelIDSent() const {
-  // TODO(rch): we should replace this with a boolean member so we
-  // can free the memory associated with the key after we're finished with it.
-  return channel_id_key_.get() != NULL;
+  return channel_id_sent_;
 }
 
 // kMaxClientHellos is the maximum number of times that we'll send a client
 // hello. The value 3 accounts for:
 //   * One failure due to an incorrect or missing source-address token.
 //   * One failure due the server's certificate chain being unavailible and the
 //     server being unwilling to send it without a valid source-address token.
 static const int kMaxClientHellos = 3;
 
 void QuicCryptoClientStream::DoHandshakeLoop(
@@ skipping 59 matching lines @@
           return;
         }
         session()->config()->ToHandshakeMessage(&out);
         error = crypto_config_->FillClientHello(
             server_id_,
             session()->connection()->connection_id(),
             session()->connection()->supported_versions().front(),
             cached,
             session()->connection()->clock()->WallNow(),
             session()->connection()->random_generator(),
             channel_id_key_.get(),

[wtc, 2014/07/16 02:01:27]

If channel_id_key_.get() is not null, crypto_config_->FillClientHello will send
a ChannelID in the CHLO message.

             &crypto_negotiated_params_,
             &out,
             &error_details);
         if (error != QUIC_NO_ERROR) {
           // Flush the cached config so that, if it's bad, the server has a
           // chance to send us another in the future.
           cached->InvalidateServerConfig();
           CloseConnectionWithDetails(error, error_details);
           return;
         }
+        channel_id_sent_ = (channel_id_key_.get() != NULL);
         if (cached->proof_verify_details()) {
           client_session()->OnProofVerifyDetailsAvailable(
               *cached->proof_verify_details());
         }
         next_state_ = STATE_RECV_SHLO;
         DVLOG(1) << "Client: Sending " << out.DebugString();
         SendHandshakeMessage(out);
         // Be prepared to decrypt with the new server write key.
         session()->connection()->SetAlternativeDecrypter(
             crypto_negotiated_params_.initial_crypters.decrypter.release(),
@@ skipping 240 matching lines @@
     }
   }
   return false;
 }
 
 QuicClientSessionBase* QuicCryptoClientStream::client_session() {
   return reinterpret_cast<QuicClientSessionBase*>(session());
 }
 
 }  // namespace net