Merge internal change: 63891842 - QuicServerId changes

net/quic/crypto/quic_crypto_client_config.h

 // 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.
 
 #ifndef NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 #define NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_server_id.h"
 
 namespace net {
 
 class ChannelIDSigner;
 class CryptoHandshakeMessage;
 class ProofVerifier;
 class ProofVerifyDetails;
 class QuicRandom;
-class QuicSessionKey;
 
 // QuicCryptoClientConfig contains crypto-related configuration settings for a
 // client. Note that this object isn't thread-safe. It's designed to be used on
 // a single thread at a time.
 class NET_EXPORT_PRIVATE QuicCryptoClientConfig : public QuicCryptoConfig {
  public:
   // A CachedState contains the information that the client needs in order to
   // perform a 0-RTT handshake with a server. This information can be reused
   // over several connections to the same server.
   class NET_EXPORT_PRIVATE CachedState {
@@ skipping 89 matching lines @@
 
     DISALLOW_COPY_AND_ASSIGN(CachedState);
   };
 
   QuicCryptoClientConfig();
   ~QuicCryptoClientConfig();
 
   // Sets the members to reasonable, default values.
   void SetDefaults();
 
-  // LookupOrCreate returns a CachedState for the given |server_key|. If no such
+  // LookupOrCreate returns a CachedState for the given |server_id|. If no such
   // CachedState currently exists, it will be created and cached.
-  CachedState* LookupOrCreate(const QuicSessionKey& server_key);
+  CachedState* LookupOrCreate(const QuicServerId& server_id);
 
   // FillInchoateClientHello sets |out| to be a CHLO message that elicits a
   // source-address token or SCFG from a server. If |cached| is non-NULL, the
   // source-address token will be taken from it. |out_params| is used in order
   // to store the cached certs that were sent as hints to the server in
   // |out_params->cached_certs|. |preferred_version| is the version of the
   // QUIC protocol that this client chose to use initially. This allows the
   // server to detect downgrade attacks.
-  void FillInchoateClientHello(const QuicSessionKey& server_key,
+  void FillInchoateClientHello(const QuicServerId& server_id,
                                const QuicVersion preferred_version,
                                const CachedState* cached,
                                QuicCryptoNegotiatedParameters* out_params,
                                CryptoHandshakeMessage* out) const;
 
   // FillClientHello sets |out| to be a CHLO message based on the configuration
   // of this object. This object must have cached enough information about
   // the server's hostname in order to perform a handshake. This can be checked
   // with the |IsComplete| member of |CachedState|.
   //
   // |initial_flow_control_window_bytes| is the size of the initial flow
   // control window this client will use for new streams.
   //
   // |clock| and |rand| are used to generate the nonce and |out_params| is
   // filled with the results of the handshake that the server is expected to
   // accept. |preferred_version| is the version of the QUIC protocol that this
   // client chose to use initially. This allows the server to detect downgrade
   // attacks.
-  QuicErrorCode FillClientHello(const QuicSessionKey& server_key,
+  QuicErrorCode FillClientHello(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,
                                 std::string* error_details) const;
 
@@ skipping 33 matching lines @@
   void SetProofVerifier(ProofVerifier* verifier);
 
   ChannelIDSigner* channel_id_signer() const;
 
   // SetChannelIDSigner sets a ChannelIDSigner that will be called when the
   // server supports channel IDs to sign a message proving possession of the
   // given ChannelID. This object takes ownership of |signer|.
   void SetChannelIDSigner(ChannelIDSigner* signer);
 
   // Initialize the CachedState from |canonical_crypto_config| for the
-  // |canonical_server_key| as the initial CachedState for |server_key|. We will
+  // |canonical_server_id| as the initial CachedState for |server_id|. We will
   // copy config data only if |canonical_crypto_config| has valid proof.
-  void InitializeFrom(const QuicSessionKey& server_key,
-                      const QuicSessionKey& canonical_server_key,
+  void InitializeFrom(const QuicServerId& server_id,
+                      const QuicServerId& canonical_server_id,
                       QuicCryptoClientConfig* canonical_crypto_config);
 
   // Adds |suffix| as a domain suffix for which the server's crypto config
   // is expected to be shared among servers with the domain suffix. If a server
   // matches this suffix, then the server config from another server with the
   // suffix will be used to initialize the cached state for this server.
   void AddCanonicalSuffix(const std::string& suffix);
 
   // Prefers AES-GCM (kAESG) over other AEAD algorithms. Call this method if
   // the CPU has hardware acceleration for AES-GCM. This method can only be
   // called after SetDefaults().
   void PreferAesGcm();
 
  private:
-  typedef std::map<QuicSessionKey, CachedState*> CachedStateMap;
+  typedef std::map<QuicServerId, CachedState*> CachedStateMap;
 
-  // If the suffix of the hostname in |server_key| is in |canoncial_suffixes_|,
+  // If the suffix of the hostname in |server_id| is in |canoncial_suffixes_|,
   // then populate |cached| with the canonical cached state from
   // |canonical_server_map_| for that suffix.
-  void PopulateFromCanonicalConfig(const QuicSessionKey& server_key,
+  void PopulateFromCanonicalConfig(const QuicServerId& server_id,
                                    CachedState* cached);
 
-  // cached_states_ maps from the server_key to the cached information about
+  // cached_states_ maps from the server_id to the cached information about
   // that server.
   CachedStateMap cached_states_;
 
   // Contains a map of servers which could share the same server config. Map
   // from a canonical host suffix/port/scheme to a representative server with
   // the canonical suffix, which has a plausible set of initial certificates
   // (or at least server public key).
-  std::map<QuicSessionKey, QuicSessionKey> canonical_server_map_;
+  std::map<QuicServerId, QuicServerId> canonical_server_map_;
 
   // Contains list of suffixes (for exmaple ".c.youtube.com",
   // ".googlevideo.com") of canoncial hostnames.
   std::vector<std::string> canoncial_suffixes_;
 
   scoped_ptr<ProofVerifier> proof_verifier_;
   scoped_ptr<ChannelIDSigner> channel_id_signer_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientConfig);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_QUIC_CRYPTO_CLIENT_CONFIG_H_