Land Recent QUIC changes

net/quic/crypto/crypto_handshake.h

 // Copyright (c) 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_CRYPTO_HANDSHAKE_H_
 #define NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_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_protocol.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_time.h"
 
 namespace net {
 
+class CommonCertSet;
 class KeyExchange;
 class ProofVerifier;
 class QuicClock;
 class QuicDecrypter;
 class QuicEncrypter;
 class QuicRandom;
 
 // An intermediate format of a handshake message that's convenient for a
 // CryptoFramer to serialize from or parse into.
 class NET_EXPORT_PRIVATE CryptoHandshakeMessage {
@@ skipping 96 matching lines @@
   ~QuicCryptoNegotiatedParameters();
 
   uint16 version;
   CryptoTag key_exchange;
   CryptoTag aead;
   std::string premaster_secret;
   scoped_ptr<QuicEncrypter> encrypter;
   scoped_ptr<QuicDecrypter> decrypter;
   std::string server_config_id;
   std::string server_nonce;
+  // cached_certs contains the cached certificates that a client used when
+  // sending a client hello.
+  std::vector<std::string> cached_certs;
 };
 
 // QuicCryptoConfig contains common configuration between clients and servers.
 class NET_EXPORT_PRIVATE QuicCryptoConfig {
  public:
   enum {
     // CONFIG_VERSION is the one (and, for the moment, only) version number that
     // we implement.
     CONFIG_VERSION = 0,
   };
 
   // kLabel is constant that is used in key derivation to tie the resulting key
   // to this protocol.
   static const char kLabel[];
 
   QuicCryptoConfig();
   ~QuicCryptoConfig();
 
   // Protocol version
   uint16 version;
   // Key exchange methods. The following two members' values correspond by
   // index.
   CryptoTagVector kexs;
   // Authenticated encryption with associated data (AEAD) algorithms.
   CryptoTagVector aead;
 
+  scoped_ptr<CommonCertSet> common_cert_set_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoConfig);
 };
 
 // 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
@@ skipping 12 matching lines @@
     // if |server_config| is empty. The return value is owned by this object
     // and is destroyed when this object is.
     const CryptoHandshakeMessage* GetServerConfig() const;
 
     // SetServerConfig checks that |scfg| parses correctly and stores it in
     // |server_config|. It returns true if the parsing succeeds and false
     // otherwise.
     bool SetServerConfig(base::StringPiece scfg);
 
     // SetProof stores a certificate chain and signature.
-    void SetProof(const std::vector<base::StringPiece>& certs,
+    void SetProof(const std::vector<std::string>& certs,
                   base::StringPiece signature);
 
     // SetProofValid records that the certificate chain and signature have been
     // validated and that it's safe to assume that the server is legitimate.
     // (Note: this does not check the chain or signature.)
     void SetProofValid();
 
     const std::string& server_config() const;
     const std::string& source_address_token() const;
     const std::vector<std::string>& certs() const;
@@ skipping 24 matching lines @@
 
   // LookupOrCreate returns a CachedState for the given hostname. If no such
   // CachedState currently exists, it will be created and cached.
   CachedState* LookupOrCreate(const std::string& server_hostname);
 
   // 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.
   void FillInchoateClientHello(const std::string& server_hostname,
                                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
   // |server_hostname| in order to perform a handshake. This can be checked
   // with the |is_complete| member of |CachedState|.
   //
   // |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.
@@ skipping 39 matching lines @@
   std::map<std::string, CachedState*> cached_states_;
 
   scoped_ptr<ProofVerifier> proof_verifier_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientConfig);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_CRYPTO_HANDSHAKE_H_