QUIC - Start the process for reading crypto config data from disk cache

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>
@@ skipping 13 matching lines @@
 // 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 {
    public:
     CachedState();
+    CachedState(scoped_ptr<QuicServerInfo> quic_server_info);

[wtc, 2014/01/30 20:14:26]

Please add "explicit" because this constructor takes one argument.

[ramant (doing other things), 2014/02/02 19:35:10]

Done.

     ~CachedState();
 
     // IsComplete returns true if this object contains enough information to
     // perform a handshake with the server. |now| is used to judge whether any
     // cached server config has expired.
     bool IsComplete(QuicWallTime now) const;
 
     // GetServerConfig returns the parsed contents of |server_config|, or NULL
     // if |server_config| is empty. The return value is owned by this object
     // and is destroyed when this object is.
@@ skipping 38 matching lines @@
 
     // SetProofVerifyDetails takes ownership of |details|.
     void SetProofVerifyDetails(ProofVerifyDetails* details);
 
     // Copy the |server_config_|, |source_address_token_|, |certs_| and
     // |server_config_sig_| from the |other|.  The remaining fields,
     // |generation_counter_|, |proof_verify_details_|, and |scfg_| remain
     // unchanged.
     void InitializeFrom(const CachedState& other);
 
-    // TODO(rtenneti): Need to flesh out the details of this method. A temporary
-    // place holder to load CachedState from disk cache.
-    void LoadFromDiskCache(QuicServerInfoFactory* quic_server_info_factory,
-                           const std::string& server_hostname);
-
    private:
     std::string server_config_id_;      // An opaque id from the server.
     std::string server_config_;         // A serialized handshake message.
     std::string source_address_token_;  // An opaque proof of IP ownership.
     std::vector<std::string> certs_;    // A list of certificates in leaf-first
                                         // order.
     std::string server_config_sig_;     // A signature of |server_config_|.
     bool server_config_valid_;          // True if |server_config_| is correctly
                                         // signed and |certs_| has been
                                         // validated.
     // Generation counter associated with the |server_config_|, |certs_| and
     // |server_config_sig_| combination. It is incremented whenever we set
     // server_config_valid_ to false.
     uint64 generation_counter_;
 
     scoped_ptr<ProofVerifyDetails> proof_verify_details_;
 
     // scfg contains the cached, parsed value of |server_config|.
     mutable scoped_ptr<CryptoHandshakeMessage> scfg_;
 
     scoped_ptr<QuicServerInfo> quic_server_info_;
 
     DISALLOW_COPY_AND_ASSIGN(CachedState);
   };
 
   QuicCryptoClientConfig();
-  explicit QuicCryptoClientConfig(
-      QuicServerInfoFactory* quic_server_info_factory);
+  explicit QuicCryptoClientConfig(scoped_ptr<QuicServerInfo> quic_server_info);

[wtc, 2014/01/30 20:14:26]

Just to make sure I understand correctly: this change implies the
QuicCryptoClientConfig object can only handle one server hostname, even though
it is originally designed to handle multiple server hostnames (which is why
cached_states_ is a std::map). Correct?

[ramant (doing other things), 2014/02/02 19:35:10]

Thanks for the catch. Deleted this member.

   ~QuicCryptoClientConfig();
 
   // Sets the members to reasonable, default values.
   void SetDefaults();
 
   // 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
@@ skipping 77 matching lines @@
   // |canonical_crypto_config| has valid proof.
   void InitializeFrom(const std::string& server_hostname,
                       const std::string& canonical_server_hostname,
                       QuicCryptoClientConfig* canonical_crypto_config);
 
  private:
   // cached_states_ maps from the server hostname to the cached information
   // about that server.
   std::map<std::string, CachedState*> cached_states_;
 
-  QuicServerInfoFactory* quic_server_info_factory_;
+  scoped_ptr<QuicServerInfo> quic_server_info_;
   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_