Refactor QuicCryptoClientStream to use QuicSession directly.

net/quic/quic_crypto_client_stream.h

 // Copyright (c) 2012 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_QUIC_CRYPTO_CLIENT_STREAM_H_
 #define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_
 
 #include <stdint.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/proof_verifier.h"
 #include "net/quic/crypto/quic_crypto_client_config.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_crypto_stream.h"
 #include "net/quic/quic_server_id.h"
 
 namespace net {
 
-class QuicClientSessionBase;
-
 namespace test {
 class CryptoTestUtils;
 class QuicChromiumClientSessionPeer;
 }  // namespace test
 
 class NET_EXPORT_PRIVATE QuicCryptoClientStreamBase : public QuicCryptoStream {
  public:
-  explicit QuicCryptoClientStreamBase(QuicClientSessionBase* session);
+  explicit QuicCryptoClientStreamBase(QuicSession* session);
 
   ~QuicCryptoClientStreamBase() override{};
 
   // Performs a crypto handshake with the server.
   virtual void CryptoConnect() = 0;
 
   // num_sent_client_hellos returns the number of client hello messages that
   // have been sent. If the handshake has completed then this is one greater
   // than the number of round-trips needed for the handshake.
   virtual int num_sent_client_hellos() const = 0;
 };
 
 class NET_EXPORT_PRIVATE QuicCryptoClientStream
     : public QuicCryptoClientStreamBase {
  public:
   // kMaxClientHellos is the maximum number of times that we'll send a client
   // hello. The value 3 accounts for:
   //   * One failure due to an incorrect or missing source-address token.
   //   * One failure due the server's certificate chain being unavailible and
   //     the server being unwilling to send it without a valid source-address
   //     token.
   static const int kMaxClientHellos = 3;
+
+  // ProofHandler is an interface that handles callbacks from the crypto
+  // stream when the client has proof verification details of the server.
+  class NET_EXPORT_PRIVATE ProofHandler {
+   public:
+    virtual ~ProofHandler() {}
+
+    // Called when the proof in |cached| is marked valid.  If this is a secure
+    // QUIC session, then this will happen only after the proof verifier
+    // completes.
+    virtual void OnProofValid(
+        const QuicCryptoClientConfig::CachedState& cached) = 0;
+
+    // Called when proof verification details become available, either because
+    // proof verification is complete, or when cached details are used. This
+    // will only be called for secure QUIC connections.
+    virtual void OnProofVerifyDetailsAvailable(
+        const ProofVerifyDetails& verify_details) = 0;
+  };
+
   QuicCryptoClientStream(const QuicServerId& server_id,
-                         QuicClientSessionBase* session,
+                         QuicSession* session,
                          ProofVerifyContext* verify_context,
-                         QuicCryptoClientConfig* crypto_config);
+                         QuicCryptoClientConfig* crypto_config,
+                         ProofHandler* proof_handler);
 
   ~QuicCryptoClientStream() override;
 
   // From QuicCryptoClientStreamBase
   void CryptoConnect() override;
   int num_sent_client_hellos() const override;
 
   // CryptoFramerVisitorInterface implementation
   void OnHandshakeMessage(const CryptoHandshakeMessage& message) override;
 
@@ skipping 108 matching lines @@
       QuicCryptoClientConfig::CachedState* cached);
 
   // Called to set the proof of |cached| valid.  Also invokes the session's
   // OnProofValid() method.
   void SetCachedProofValid(QuicCryptoClientConfig::CachedState* cached);
 
   // Returns true if the server crypto config in |cached| requires a ChannelID
   // and the client config settings also allow sending a ChannelID.
   bool RequiresChannelID(QuicCryptoClientConfig::CachedState* cached);
 
-  QuicClientSessionBase* client_session();
-
   State next_state_;
   // num_client_hellos_ contains the number of client hello messages that this
   // connection has sent.
   int num_client_hellos_;
 
   QuicCryptoClientConfig* const crypto_config_;
 
   // Client's connection nonce (4-byte timestamp + 28 random bytes)
   std::string nonce_;
   // Server's (hostname, port, is_https, privacy_mode) tuple.
@@ skipping 18 matching lines @@
   // STATE_GET_CHANNEL_ID_COMPLETE.
   scoped_ptr<ChannelIDKey> channel_id_key_;
 
   // verify_context_ contains the context object that we pass to asynchronous
   // proof verifications.
   scoped_ptr<ProofVerifyContext> verify_context_;
 
   // proof_verify_callback_ contains the callback object that we passed to an
   // asynchronous proof verification. The ProofVerifier owns this object.
   ProofVerifierCallbackImpl* proof_verify_callback_;
+  // proof_handler_ contains the callback object used by a quic client
+  // for proof verification. It is not owned by this class.
+  ProofHandler* proof_handler_;
 
   // These members are used to store the result of an asynchronous proof
   // verification. These members must not be used after
   // STATE_VERIFY_PROOF_COMPLETE.
   bool verify_ok_;
   std::string verify_error_details_;
   scoped_ptr<ProofVerifyDetails> verify_details_;
 
   // True if the server responded to a previous CHLO with a stateless
   // reject.  Used for book-keeping between the STATE_RECV_REJ,
   // STATE_VERIFY_PROOF*, and subsequent STATE_SEND_CHLO state.
   bool stateless_reject_received_;
 
   base::TimeTicks proof_verify_start_time_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoClientStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_H_