Land Recent QUIC Changes.

net/quic/crypto/quic_crypto_server_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_SERVER_CONFIG_H_
 #define NET_QUIC_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 class QuicServerConfigProtobuf;
 class StrikeRegister;
 class StrikeRegisterClient;
 
 struct ClientHelloInfo;
 
 namespace test {
 class QuicCryptoServerConfigPeer;
 }  // namespace test
 
+// Hook that allows application code to subscribe to primary config changes.
+class PrimaryConfigChangedCallback {
+ public:
+  PrimaryConfigChangedCallback();
+  virtual ~PrimaryConfigChangedCallback();
+  virtual void Run(const std::string& scid) = 0;
+};
+
 // Callback used to accept the result of the |client_hello| validation step.
 class NET_EXPORT_PRIVATE ValidateClientHelloResultCallback {
  public:
   // Opaque token that holds information about the client_hello and
   // its validity.  Can be interpreted by calling ProcessClientHello.
   struct Result;
 
   ValidateClientHelloResultCallback();
   virtual ~ValidateClientHelloResultCallback();
   void Run(const Result* result);
@@ skipping 75 matching lines @@
   // SetConfigs takes a vector of config protobufs and the current time.
   // Configs are assumed to be uniquely identified by their server config ID.
   // Previously unknown configs are added and possibly made the primary config
   // depending on their |primary_time| and the value of |now|. Configs that are
   // known, but are missing from the protobufs are deleted, unless they are
   // currently the primary config. SetConfigs returns false if any errors were
   // encountered and no changes to the QuicCryptoServerConfig will occur.
   bool SetConfigs(const std::vector<QuicServerConfigProtobuf*>& protobufs,
                   QuicWallTime now);
 
+  // Get the server config ids for all known configs.
+  void GetConfigIds(std::vector<std::string>* scids) const;
+
   // Checks |client_hello| for gross errors and determines whether it
   // can be shown to be fresh (i.e. not a replay).  The result of the
   // validation step must be interpreted by calling
   // QuicCryptoServerConfig::ProcessClientHello from the done_cb.
   //
   // ValidateClientHello may invoke the done_cb before unrolling the
   // stack if it is able to assess the validity of the client_nonce
   // without asynchronous operations.
   //
   // client_hello: the incoming client hello message.
@@ skipping 100 matching lines @@
   // the client and back.
   void set_server_nonce_strike_register_max_entries(uint32 max_entries);
 
   // set_server_nonce_strike_register_window_secs sets the number of seconds
   // around the current time that the server-nonce strike-register will accept
   // nonces from. Setting a larger value allows for clients to delay follow-up
   // client hellos for longer and still use server nonces as proofs of
   // uniqueness.
   void set_server_nonce_strike_register_window_secs(uint32 window_secs);
 
+  // Set and take ownership of the callback to invoke on primary config changes.
+  void AcquirePrimaryConfigChangedCb(PrimaryConfigChangedCallback* cb);
+
  private:
   friend class test::QuicCryptoServerConfigPeer;
 
   // Config represents a server config: a collection of preferences and
   // Diffie-Hellman public values.
   class NET_EXPORT_PRIVATE Config : public QuicCryptoConfig,
                                     public base::RefCounted<Config> {
    public:
     Config();
 
@@ skipping 108 matching lines @@
   mutable base::Lock configs_lock_;
   // configs_ contains all active server configs. It's expected that there are
   // about half-a-dozen configs active at any one time.
   ConfigMap configs_;
   // primary_config_ points to a Config (which is also in |configs_|) which is
   // the primary config - i.e. the one that we'll give out to new clients.
   mutable scoped_refptr<Config> primary_config_;
   // next_config_promotion_time_ contains the nearest, future time when an
   // active config will be promoted to primary.
   mutable QuicWallTime next_config_promotion_time_;
+  // Callback to invoke when the primary config changes.
+  scoped_ptr<PrimaryConfigChangedCallback> primary_config_changed_cb_;
 
   // Protects access to the pointer held by strike_register_client_.
   mutable base::Lock strike_register_client_lock_;
   // strike_register_ contains a data structure that keeps track of previously
   // observed client nonces in order to prevent replay attacks.
   mutable scoped_ptr<StrikeRegisterClient> strike_register_client_;
 
   // source_address_token_boxer_ is used to protect the source-address tokens
   // that are given to clients.
   CryptoSecretBoxer source_address_token_boxer_;
@@ skipping 28 matching lines @@
   uint32 strike_register_window_secs_;
   uint32 source_address_token_future_secs_;
   uint32 source_address_token_lifetime_secs_;
   uint32 server_nonce_strike_register_max_entries_;
   uint32 server_nonce_strike_register_window_secs_;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_