Add plumbing for passing stats from calls to ProofSource::GetProof through QUIC. These stats are n…

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 87 matching lines @@
     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);
+  void Run(const Result* result, std::unique_ptr<ProofSource::Details> details);
 
  protected:
   virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
-                       const Result& result) = 0;
+                       const 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 402 matching lines @@
   // 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;
 
   // BuildRejection sets |out| to be a REJ message in reply to |client_hello|.
   void BuildRejection(QuicVersion version,
                       const Config& config,
                       const CryptoHandshakeMessage& client_hello,
                       const ClientHelloInfo& info,
                       const CachedNetworkParameters& cached_network_params,
@@ skipping 113 matching lines @@
         QuicVersion version,
         QuicCompressedCertsCache* compressed_certs_cache,
         const CommonCertSets* common_cert_sets,
         const QuicCryptoNegotiatedParameters& params,
         CryptoHandshakeMessage message,
         std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb);
 
     void Run(bool ok,
              const scoped_refptr<ProofSource::Chain>& chain,
              const std::string& signature,
-             const std::string& leaf_cert_sct) override;
+             const std::string& leaf_cert_sct,
+             std::unique_ptr<ProofSource::Details> details) override;
 
    private:
     const QuicCryptoServerConfig* config_;
     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
   // 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,
       const scoped_refptr<ProofSource::Chain>& chain,
       const std::string& signature,
       const std::string& leaf_cert_sct,
+      std::unique_ptr<ProofSource::Details> details,
       CryptoHandshakeMessage message,
       std::unique_ptr<BuildServerConfigUpdateMessageResultCallback> cb) const;
 
   // replay_protection_ controls whether the server enforces that handshakes
   // aren't replays.
   bool replay_protection_;
 
   // The multiple of the CHLO message size that a REJ message must stay under
   // when the client doesn't present a valid source-address token. This is
   // used to protect QUIC from amplification attacks.
@@ skipping 75 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_