Landing Recent QUIC changes until Sat Sep 10 00:32:41

net/quic/core/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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 31 matching lines @@
 class QuicRandom;
 class QuicServerConfigProtobuf;
 class StrikeRegister;
 class StrikeRegisterClient;
 struct QuicCryptoProof;
 
 // ClientHelloInfo contains information about a client hello message that is
 // only kept for as long as it's being processed.
 struct ClientHelloInfo {
   ClientHelloInfo(const IPAddress& in_client_ip, QuicWallTime in_now);
+  ClientHelloInfo(const ClientHelloInfo& other);
   ~ClientHelloInfo();
 
   // Inputs to EvaluateClientHello.
   const IPAddress client_ip;
   const QuicWallTime now;
 
   // Outputs from EvaluateClientHello.
   bool valid_source_address_token;
   base::StringPiece sni;
   base::StringPiece client_nonce;
@@ skipping 19 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PrimaryConfigChangedCallback);
 };
 
 // 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 {
+  struct NET_EXPORT_PRIVATE Result {
     Result(const CryptoHandshakeMessage& in_client_hello,
            IPAddress in_client_ip,
            QuicWallTime in_now);
     ~Result();
 
     CryptoHandshakeMessage client_hello;
     ClientHelloInfo info;
     QuicErrorCode error_code;
     std::string error_details;
 
     // Populated if the CHLO STK contained a CachedNetworkParameters proto.
     CachedNetworkParameters cached_network_params;
   };
 
   ValidateClientHelloResultCallback();
   virtual ~ValidateClientHelloResultCallback();
-  void Run(const Result* result, std::unique_ptr<ProofSource::Details> details);
-
- protected:
-  virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
-                       const Result& result,
-                       std::unique_ptr<ProofSource::Details> details) = 0;
+  virtual void Run(std::unique_ptr<Result> result,
+                   std::unique_ptr<ProofSource::Details> details) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ValidateClientHelloResultCallback);
 };
 
 // Callback used to receive the results of a call to
 // BuildServerConfigUpdateMessage.
 class BuildServerConfigUpdateMessageResultCallback {
  public:
   BuildServerConfigUpdateMessageResultCallback() = default;
@@ skipping 111 matching lines @@
   //     certificate selection.
   // version: protocol version used for this connection.
   // clock: used to validate client nonces and ephemeral keys.
   // crypto_proof: output structure containing the crypto proof used in reply to
   //     a proof demand.
   // done_cb: single-use callback that accepts an opaque
   //     ValidatedClientHelloMsg token that holds information about
   //     the client hello.  The callback will always be called exactly
   //     once, either under the current call stack, or after the
   //     completion of an asynchronous operation.
-  void ValidateClientHello(const CryptoHandshakeMessage& client_hello,
-                           const IPAddress& client_ip,
-                           const IPAddress& server_ip,
-                           QuicVersion version,
-                           const QuicClock* clock,
-                           QuicCryptoProof* crypto_proof,
-                           ValidateClientHelloResultCallback* done_cb) const;
+  void ValidateClientHello(
+      const CryptoHandshakeMessage& client_hello,
+      const IPAddress& client_ip,
+      const IPAddress& server_ip,
+      QuicVersion version,
+      const QuicClock* clock,
+      QuicCryptoProof* crypto_proof,
+      std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const;
 
   // ProcessClientHello processes |client_hello| and decides whether to accept
   // or reject the connection. If the connection is to be accepted, |out| is
   // set to the contents of the ServerHello, |out_params| is completed and
   // QUIC_NO_ERROR is returned. Otherwise |out| is set to be a REJ or SREJ
   // message and QUIC_NO_ERROR is returned.
   //
   // validate_chlo_result: Output from the asynchronous call to
   //     ValidateClientHello.  Contains the client hello message and
   //     information about it.
@@ skipping 150 matching lines @@
   // 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_t window_secs);
 
   // set_enable_serving_sct enables or disables serving signed cert timestamp
   // (RFC6962) in server hello.
   void set_enable_serving_sct(bool enable_serving_sct);
 
   // Set and take ownership of the callback to invoke on primary config changes.
-  void AcquirePrimaryConfigChangedCb(PrimaryConfigChangedCallback* cb);
+  void AcquirePrimaryConfigChangedCb(
+      std::unique_ptr<PrimaryConfigChangedCallback> cb);
 
   // Returns the number of configs this object owns.
   int NumberOfConfigs() const;
 
  private:
   friend class test::QuicCryptoServerConfigPeer;
   friend struct QuicCryptoProof;
 
   // Config represents a server config: a collection of preferences and
   // Diffie-Hellman public values.
@@ skipping 79 matching lines @@
   // EvaluateClientHello checks |client_hello| for gross errors and determines
   // whether it can be shown to be fresh (i.e. not a replay). The results are
   // written to |info|.
   void EvaluateClientHello(
       const IPAddress& server_ip,
       QuicVersion version,
       const uint8_t* primary_orbit,
       scoped_refptr<Config> requested_config,
       scoped_refptr<Config> primary_config,
       QuicCryptoProof* crypto_proof,
-      ValidateClientHelloResultCallback::Result* client_hello_state,
-      ValidateClientHelloResultCallback* done_cb) const;
+      std::unique_ptr<ValidateClientHelloResultCallback::Result>
+          client_hello_state,
+      std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const;
 
   // Callback class for bridging between EvaluateClientHello and
   // EvaluateClientHelloAfterGetProof
   friend class EvaluateClientHelloCallback;
 
   // Continuation of EvaluateClientHello after the call to
   // ProofSource::GetProof.  |found_error| indicates whether an error was
   // detected in EvaluateClientHello, and |get_proof_failed| indicates whether
   // GetProof failed.  If GetProof was not run, then |get_proof_failed| will be
   // set to false.
   void EvaluateClientHelloAfterGetProof(
       bool found_error,
       const IPAddress& server_ip,
       QuicVersion version,
       const uint8_t* primary_orbit,
       scoped_refptr<Config> requested_config,
       scoped_refptr<Config> primary_config,
       QuicCryptoProof* crypto_proof,
       std::unique_ptr<ProofSource::Details> proof_source_details,
       bool get_proof_failed,
-      ValidateClientHelloResultCallback::Result* client_hello_state,
-      ValidateClientHelloResultCallback* done_cb) const;
+      std::unique_ptr<ValidateClientHelloResultCallback::Result>
+          client_hello_state,
+      std::unique_ptr<ValidateClientHelloResultCallback> done_cb) const;
 
   // BuildRejection sets |out| to be a REJ message in reply to |client_hello|.
   void BuildRejection(QuicVersion version,
                       QuicWallTime now,
                       const Config& config,
                       const CryptoHandshakeMessage& client_hello,
                       const ClientHelloInfo& info,
                       const CachedNetworkParameters& cached_network_params,
                       bool use_stateless_rejects,
                       QuicConnectionId server_designated_connection_id,
@@ skipping 126 matching lines @@
     const QuicVersion version_;
     QuicCompressedCertsCache* compressed_certs_cache_;
     const CommonCertSets* common_cert_sets_;
     const std::string client_common_set_hashes_;
     const std::string client_cached_cert_hashes_;
     const bool sct_supported_by_client_;
     CryptoHandshakeMessage message_;
     std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb_;
   };
 
-  // Invoked by BuildServerConfigUpdateMessageProofSourceCallback::RunImpl once
+  // Invoked by BuildServerConfigUpdateMessageProofSourceCallback::Run once
   // the proof has been acquired.  Finishes building the server config update
   // message and invokes |cb|.
   void FinishBuildServerConfigUpdateMessage(
       QuicVersion version,
       QuicCompressedCertsCache* compressed_certs_cache,
       const CommonCertSets* common_cert_sets,
       const std::string& client_common_set_hashes,
       const std::string& client_cached_cert_hashes,
       bool sct_supported_by_client,
       bool ok,
@@ skipping 87 matching lines @@
   std::string cert_sct;
   // The server config that is used for this proof (and the rest of the
   // request).
   scoped_refptr<QuicCryptoServerConfig::Config> config;
   std::string primary_scid;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CRYPTO_QUIC_CRYPTO_SERVER_CONFIG_H_