Change the prototype of ChannelIDSource::GetChannelIDKey() to allow an

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/channel_id.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/crypto/proof_verifier.h"
 #include "net/quic/quic_client_session_base.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 
 namespace net {
 
@@ skipping 127 matching lines @@
             CloseConnection(QUIC_INTERNAL_ERROR);
             return;
           }
           out.set_minimum_size(max_packet_size - kFramingOverhead);
           next_state_ = STATE_RECV_REJ;
           DVLOG(1) << "Client: Sending " << out.DebugString();
           SendHandshakeMessage(out);
           return;
         }
         session()->config()->ToHandshakeMessage(&out);
+
+        scoped_ptr<ChannelIDKey> channel_id_key;
+        bool do_channel_id = false;
+        if (crypto_config_->channel_id_source()) {
+          const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
+          DCHECK(scfg);
+          const QuicTag* their_proof_demands;
+          size_t num_their_proof_demands;
+          if (scfg->GetTaglist(kPDMD, &their_proof_demands,
+                               &num_their_proof_demands) == QUIC_NO_ERROR) {
+            for (size_t i = 0; i < num_their_proof_demands; i++) {
+              if (their_proof_demands[i] == kCHID) {
+                do_channel_id = true;
+                break;
+              }
+            }
+          }
+        }
+        if (do_channel_id) {
+          QuicAsyncStatus status =
+              crypto_config_->channel_id_source()->GetChannelIDKey(
+                  server_id_.host(), &channel_id_key, NULL);
+          if (status != QUIC_SUCCESS) {
+            CloseConnectionWithDetails(QUIC_INVALID_CHANNEL_ID_SIGNATURE,
+                                       "Channel ID lookup failed");
+            return;
+          }
+        }
+
         error = crypto_config_->FillClientHello(
             server_id_,
             session()->connection()->connection_id(),
             session()->connection()->supported_versions().front(),
             session()->max_flow_control_receive_window_bytes(),
             cached,
             session()->connection()->clock()->WallNow(),
             session()->connection()->random_generator(),
+            channel_id_key.get(),
             &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;
         }
@@ skipping 186 matching lines @@
     QuicCryptoClientConfig::CachedState* cached) {
   cached->SetProofValid();
   client_session()->OnProofValid(*cached);
 }
 
 QuicClientSessionBase* QuicCryptoClientStream::client_session() {
   return reinterpret_cast<QuicClientSessionBase*>(session());
 }
 
 }  // namespace net