Merge internal change: 63891842 - QuicServerId changes

net/quic/crypto/quic_crypto_client_config.cc

 // Copyright 2013 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/crypto/quic_crypto_client_config.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/quic/crypto/cert_compressor.h"
 #include "net/quic/crypto/chacha20_poly1305_encrypter.h"
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/curve25519_key_exchange.h"
 #include "net/quic/crypto/key_exchange.h"
 #include "net/quic/crypto/p256_key_exchange.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_encrypter.h"
-#include "net/quic/quic_session_key.h"
+#include "net/quic/quic_server_id.h"
 #include "net/quic/quic_utils.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 using base::StringPiece;
 using std::find;
 using std::make_pair;
 using std::map;
@@ skipping 223 matching lines @@
 
   // Authenticated encryption algorithms. Prefer ChaCha20 by default.
   aead.clear();
   if (ChaCha20Poly1305Encrypter::IsSupported()) {
     aead.push_back(kCC12);
   }
   aead.push_back(kAESG);
 }
 
 QuicCryptoClientConfig::CachedState* QuicCryptoClientConfig::LookupOrCreate(
-    const QuicSessionKey& server_key) {
-  CachedStateMap::const_iterator it = cached_states_.find(server_key);
+    const QuicServerId& server_id) {
+  CachedStateMap::const_iterator it = cached_states_.find(server_id);
   if (it != cached_states_.end()) {
     return it->second;
   }
 
   CachedState* cached = new CachedState;
-  cached_states_.insert(make_pair(server_key, cached));
-  PopulateFromCanonicalConfig(server_key, cached);
+  cached_states_.insert(make_pair(server_id, cached));
+  PopulateFromCanonicalConfig(server_id, cached);
   return cached;
 }
 
 void QuicCryptoClientConfig::FillInchoateClientHello(
-    const QuicSessionKey& server_key,
+    const QuicServerId& server_id,
     const QuicVersion preferred_version,
     const CachedState* cached,
     QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out) const {
   out->set_tag(kCHLO);
   out->set_minimum_size(kClientHelloMinimumSize);
 
   // Server name indication. We only send SNI if it's a valid domain name, as
   // per the spec.
-  if (CryptoUtils::IsValidSNI(server_key.host())) {
-    out->SetStringPiece(kSNI, server_key.host());
+  if (CryptoUtils::IsValidSNI(server_id.host())) {
+    out->SetStringPiece(kSNI, server_id.host());
   }
   out->SetValue(kVER, QuicVersionToQuicTag(preferred_version));
 
   if (!cached->source_address_token().empty()) {
     out->SetStringPiece(kSourceAddressTokenTag, cached->source_address_token());
   }
 
-  if (server_key.is_https()) {
+  if (server_id.is_https()) {
     // Don't request ECDSA proofs on platforms that do not support ECDSA
     // certificates.
     bool disableECDSA = false;
 #if defined(OS_WIN)
     if (base::win::GetVersion() < base::win::VERSION_VISTA)
       disableECDSA = true;
 #endif
     if (disableECDSA) {
       out->SetTaglist(kPDMD, kX59R, 0);
     } else {
@@ skipping 16 matching lines @@
     hashes.reserve(certs.size());
     for (vector<string>::const_iterator i = certs.begin();
          i != certs.end(); ++i) {
       hashes.push_back(QuicUtils::FNV1a_64_Hash(i->data(), i->size()));
     }
     out->SetVector(kCCRT, hashes);
   }
 }
 
 QuicErrorCode QuicCryptoClientConfig::FillClientHello(
-    const QuicSessionKey& server_key,
+    const QuicServerId& server_id,
     QuicConnectionId connection_id,
     const QuicVersion preferred_version,
     uint32 initial_flow_control_window_bytes,
     const CachedState* cached,
     QuicWallTime now,
     QuicRandom* rand,
     QuicCryptoNegotiatedParameters* out_params,
     CryptoHandshakeMessage* out,
     string* error_details) const {
   DCHECK(error_details != NULL);
 
-  FillInchoateClientHello(server_key, preferred_version, cached,
+  FillInchoateClientHello(server_id, preferred_version, cached,
                           out_params, out);
 
   // Set initial receive window for flow control.
   out->SetValue(kIFCW, initial_flow_control_window_bytes);
 
   const CryptoHandshakeMessage* scfg = cached->GetServerConfig();
   if (!scfg) {
     // This should never happen as our caller should have checked
     // cached->IsComplete() before calling this function.
     *error_details = "Handshake not ready";
@@ skipping 107 matching lines @@
     const QuicData& client_hello_serialized = out->GetSerialized();
     hkdf_input.append(QuicCryptoConfig::kCETVLabel,
                       strlen(QuicCryptoConfig::kCETVLabel) + 1);
     hkdf_input.append(reinterpret_cast<char*>(&connection_id),
                       sizeof(connection_id));
     hkdf_input.append(client_hello_serialized.data(),
                       client_hello_serialized.length());
     hkdf_input.append(cached->server_config());
 
     string key, signature;
-    if (!channel_id_signer_->Sign(server_key.host(), hkdf_input,
+    if (!channel_id_signer_->Sign(server_id.host(), hkdf_input,
                                   &key, &signature)) {
       *error_details = "Channel ID signature failed";
       return QUIC_INVALID_CHANNEL_ID_SIGNATURE;
     }
 
     cetv.SetStringPiece(kCIDK, key);
     cetv.SetStringPiece(kCIDS, signature);
 
     CrypterPair crypters;
     if (!CryptoUtils::DeriveKeys(out_params->initial_premaster_secret,
@@ skipping 192 matching lines @@
 
 ChannelIDSigner* QuicCryptoClientConfig::channel_id_signer() const {
   return channel_id_signer_.get();
 }
 
 void QuicCryptoClientConfig::SetChannelIDSigner(ChannelIDSigner* signer) {
   channel_id_signer_.reset(signer);
 }
 
 void QuicCryptoClientConfig::InitializeFrom(
-    const QuicSessionKey& server_key,
-    const QuicSessionKey& canonical_server_key,
+    const QuicServerId& server_id,
+    const QuicServerId& canonical_server_id,
     QuicCryptoClientConfig* canonical_crypto_config) {
   CachedState* canonical_cached =
-      canonical_crypto_config->LookupOrCreate(canonical_server_key);
+      canonical_crypto_config->LookupOrCreate(canonical_server_id);
   if (!canonical_cached->proof_valid()) {
     return;
   }
-  CachedState* cached = LookupOrCreate(server_key);
+  CachedState* cached = LookupOrCreate(server_id);
   cached->InitializeFrom(*canonical_cached);
 }
 
 void QuicCryptoClientConfig::AddCanonicalSuffix(const string& suffix) {
   canoncial_suffixes_.push_back(suffix);
 }
 
 void QuicCryptoClientConfig::PreferAesGcm() {
   DCHECK(!aead.empty());
   if (aead.size() <= 1) {
     return;
   }
   QuicTagVector::iterator pos = find(aead.begin(), aead.end(), kAESG);
   if (pos != aead.end()) {
     aead.erase(pos);
     aead.insert(aead.begin(), kAESG);
   }
 }
 
 void QuicCryptoClientConfig::PopulateFromCanonicalConfig(
-    const QuicSessionKey& server_key,
+    const QuicServerId& server_id,
     CachedState* server_state) {
   DCHECK(server_state->IsEmpty());
   unsigned i = 0;
   for (; i < canoncial_suffixes_.size(); ++i) {
-    if (EndsWith(server_key.host(), canoncial_suffixes_[i], false)) {
+    if (EndsWith(server_id.host(), canoncial_suffixes_[i], false)) {
       break;
     }
   }
   if (i == canoncial_suffixes_.size())
     return;
 
-  QuicSessionKey suffix_server_key(canoncial_suffixes_[i], server_key.port(),
-                                   server_key.is_https(),
-                                   server_key.privacy_mode());
-  if (!ContainsKey(canonical_server_map_, suffix_server_key)) {
+  QuicServerId suffix_server_id(canoncial_suffixes_[i], server_id.port(),
+                                server_id.is_https(),
+                                server_id.privacy_mode());
+  if (!ContainsKey(canonical_server_map_, suffix_server_id)) {
     // This is the first host we've seen which matches the suffix, so make it
     // canonical.
-    canonical_server_map_[suffix_server_key] = server_key;
+    canonical_server_map_[suffix_server_id] = server_id;
     return;
   }
 
-  const QuicSessionKey& canonical_server_key =
-      canonical_server_map_[suffix_server_key];
-  CachedState* canonical_state = cached_states_[canonical_server_key];
+  const QuicServerId& canonical_server_id =
+      canonical_server_map_[suffix_server_id];
+  CachedState* canonical_state = cached_states_[canonical_server_id];
   if (!canonical_state->proof_valid()) {
     return;
   }
 
   // Update canonical version to point at the "most recent" entry.
-  canonical_server_map_[suffix_server_key] = server_key;
+  canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
 }
 
 }  // namespace net