Create QuicSession

webrtc/p2p/base/quicsession.h

+/*
+ *  Copyright 2011 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_P2P_BASE_QUICSESSION_H_
+#define WEBRTC_P2P_BASE_QUICSESSION_H_
+
+#include <string>
+
+#include "net/quic/quic_crypto_stream.h"
+#include "net/quic/quic_crypto_client_stream.h"
+#include "net/quic/quic_crypto_server_stream.h"
+#include "net/quic/quic_session.h"
+
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/sslidentity.h"
+#include "webrtc/p2p/base/reliablequicstream.h"
+
+#include "webrtc/base/sigslot.h"
+
+namespace cricket {
+
+// 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 QuicSession : public net::QuicSession, public sigslot::has_slots<> {
+ public:
+  QuicSession(const net::QuicConfig& config,
+              scoped_ptr<net::QuicConnection> connection);
+  ~QuicSession() override;
+
+  // Inititates client crypto handshake by sending client hello.
+  void StartClientHandshake(net::QuicCryptoClientStream* crypto_stream);
+
+  // Responds to a client who has inititated the crypto handshake.
+  void StartServerHandshake(net::QuicCryptoServerStream* crypto_stream);
+
+  // QuicSession overrides.
+  net::QuicCryptoStream* GetCryptoStream() override {
+    return crypto_stream_.get();
+  }
+  ReliableQuicStream* CreateOutgoingDynamicStream(
+      net::SpdyPriority priority) override;
+
+  // QuicSession optional overrides.
+  void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
+
+  // QuicConnectionVisitorInterface overrides.
+  void OnConnectionClosed(net::QuicErrorCode error, bool from_peer) override;
+
+  // Exports keying material for SRTP.
+  bool ExportKeyingMaterial(base::StringPiece label,
+                            base::StringPiece context,
+                            size_t result_len,
+                            string* result);
+
+  // Decrypts an incoming QUIC packet to a data stream.
+  bool OnReadPacket(const char* data, size_t data_len);
+
+  // Called when peers have established forward-secure encryption
+  sigslot::signal0<> SignalHandshakeComplete;
+  // Called when connection closes locally, or remotely by peer
+  sigslot::signal2<net::QuicErrorCode, bool> SignalConnectionClosed;
+  // Called when an incoming QUIC stream is created so we can process data
+  // from it by registering a listener to ReliableQuicStream::SignalDataReceived
+  sigslot::signal1<ReliableQuicStream*> SignalIncomingStream;
+
+ protected:
+  // Sets the QUIC crypto stream and takes ownership of it.
+  void SetCryptoStream(net::QuicCryptoStream* crypto_stream);
+
+  // QuicSession override
+  ReliableQuicStream* CreateIncomingDynamicStream(
+      net::QuicStreamId id) override;
+
+  ReliableQuicStream* CreateDataStream(net::QuicStreamId id);

[pthatcher1, 2016/01/30 03:01:52]

Why is this protected but not virtual?

[mikescarlett, 2016/02/03 17:41:01]

I agree this should be virtual for more flexibility.

+
+ private:
+  scoped_ptr<net::QuicCryptoStream> crypto_stream_;
+
+  RTC_DISALLOW_COPY_AND_ASSIGN(QuicSession);
+};
+
+}  // namespace cricket
+
+#endif  // WEBRTC_P2P_BASE_QUICSESSION_H_