Define Stable API for WebRTC/Quartc

net/quic/quartc/quartc_session.h

+// Copyright (c) 2016 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_QUARTC_QUARTC_SESSION_H_
+#define NET_QUIC_QUARTC_QUARTC_SESSION_H_
+
+#include "net/quic/core/quic_crypto_client_stream.h"
+#include "net/quic/core/quic_crypto_server_stream.h"
+#include "net/quic/core/quic_crypto_stream.h"
+#include "net/quic/core/quic_session.h"
+#include "net/quic/quartc/quartc_connection_helper.h"
+#include "net/quic/quartc/quartc_reliable_stream.h"
+#include "net/quic/quartc/quartc_session_interface.h"
+
+namespace net {
+class NET_EXPORT_PRIVATE QuartcCryptoServerStreamHelper
+    : public QuicCryptoServerStream::Helper {
+ public:
+  QuicConnectionId GenerateConnectionIdForReject(
+      QuicConnectionId connection_id) const override;
+
+  bool CanAcceptClientHello(const CryptoHandshakeMessage& message,
+                            const IPEndPoint& self_address,
+                            std::string* error_details) const override;
+};
+
+// This class is used to solve the issue that the interface and the base class
+// have the same function signature.
+class NET_EXPORT_PRIVATE QuartcSessionTransportObserver
+    : public QuartcSessionInterface::Transport::Observer {
+ public:
+  void OnCanWrite() override;
+
+ protected:
+  virtual void OnQuartcCanWrite() = 0;
+};
+
+// This class provides a QUIC session over peer-to-peer transport that
+// negotiates the crypto handshake (using QuicCryptoHandshake) and provides
+// reading/writing of data using QUIC packets.
+class NET_EXPORT_PRIVATE QuartcSession
+    : public QuicSession,
+      public QuartcSessionInterface,
+      public QuartcSessionTransportObserver,
+      public QuicCryptoClientStream::ProofHandler {
+ public:
+  QuartcSession(std::unique_ptr<QuicConnection> connection,
+                const QuicConfig& config,
+                const std::string& remote_finger_print_value,
+                Perspective perspective);
+  ~QuartcSession() override;
+
+  // QuicSession overrides.
+  QuicCryptoStream* GetCryptoStream() override;
+  QuartcReliableStream* CreateOutgoingDynamicStream(
+      SpdyPriority priority) override;
+  void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
+  void CloseStream(QuicStreamId stream_id) override;
+  // QuicConnectionVisitorInterface overrides.
+  void OnConnectionClosed(QuicErrorCode error,
+                          const std::string& error_details,
+                          ConnectionCloseSource source) override;
+
+  // QuartcSessionInterface overrides
+  void StartCryptoHandshake() override;
+  bool ExportKeyingMaterial(const std::string& label,
+                            const uint8_t* context,
+                            size_t context_len,
+                            uint8_t* result,
+                            size_t result_len) override;
+  QuartcReliableStreamInterface* CreateOutgoingStream(
+      const OutgoingStreamParameters& param) override;
+  void SetTransport(
+      QuartcSessionInterface::Transport* session_transport) override;
+  void SetObserver(QuartcSessionInterface::Observer* session_observer) override;
+
+  // QuartcSessionTransportObserver overrides.
+  void OnQuartcCanWrite() override;
+  // QuartcSessionInterface::Transport::Observer overrides.
+  // Decrypts an incoming QUIC packet to a data stream.
+  bool OnReceived(const char* data, size_t data_len) override;
+
+  // ProofHandler overrides.
+  void OnProofValid(const QuicCryptoClientConfig::CachedState& cached) override;
+  // Called by the client crypto handshake when proof verification details
+  // become available, either because proof verification is complete, or when
+  // cached details are used.
+  void OnProofVerifyDetailsAvailable(
+      const ProofVerifyDetails& verify_details) override;
+
+  // Override the default crypto configuration.
+  // The session will take the ownership of the configurations.
+  void SetClientCryptoConfig(QuicCryptoClientConfig* client_config);
+  void SetServerCryptoConfig(QuicCryptoServerConfig* server_config);
+
+ protected:
+  // QuicSession override.
+  ReliableQuicStream* CreateIncomingDynamicStream(QuicStreamId id) override;
+
+  virtual QuartcReliableStream* CreateDataStream(QuicStreamId id,
+                                                 SpdyPriority priority);
+
+ private:
+  // For crypto handshake.
+  std::unique_ptr<QuicCryptoStream> crypto_stream_;
+  // For recording packet receipt time
+  QuicClock clock_;
+  // Take ownership of the QuicConnection.
+  std::unique_ptr<QuicConnection> connection_;
+  // QuartcSession will not take the ownership.
+  QuartcSessionInterface::Transport* session_transport_ = nullptr;
+  QuartcSessionInterface::Observer* session_observer_ = nullptr;
+  const std::string remote_finger_print_value_;
+  Perspective perspective_;
+  QuartcConnectionHelper helper_;
+  // Used by QUIC crypto server stream to track most recently compressed certs.
+  std::unique_ptr<QuicCompressedCertsCache> quic_compressed_certs_cache_;
+  // This helper is needed when create QuicCryptoServerStream.
+  QuartcCryptoServerStreamHelper stream_helper_;
+  // Config for QUIC crypto client stream, used by the client.
+  std::unique_ptr<QuicCryptoClientConfig> quic_crypto_client_config_;
+  // Config for QUIC crypto server stream, used by the server.
+  std::unique_ptr<QuicCryptoServerConfig> quic_crypto_server_config_;
+
+  DISALLOW_COPY_AND_ASSIGN(QuartcSession);
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_QUARTC_QUARTC_SESSION_H_