Modify PeerConnection for end-to-end QuicDataChannel usage

webrtc/p2p/quic/quictransportchannel.h

 /*
  *  Copyright 2016 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_QUIC_QUICTRANSPORTCHANNEL_H_
 #define WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_
 
 #include <string>
 #include <vector>
 
 #include "net/quic/quic_crypto_client_stream.h"
 #include "net/quic/quic_packet_writer.h"
 #include "webrtc/base/optional.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/p2p/base/transport.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/p2p/quic/quicconnectionhelper.h"
 #include "webrtc/p2p/quic/quicsession.h"
 
 namespace cricket {
 
 enum QuicTransportState {
   // Haven't started QUIC handshake.
   QUIC_TRANSPORT_NEW = 0,
   // Started QUIC handshake.
@@ skipping 10 matching lines @@
 // Once the wrapped transport channel is connected, QuicTransportChannel
 // negotiates the crypto handshake and establishes SRTP keying material.
 //
 // How it works:
 //
 //   QuicTransportChannel {
 //       QuicSession* quic_;
 //       TransportChannelImpl* channel_;
 //   }
 //
-//   - Data written to SendPacket() is passed directly to |channel_| if  it is
+//   - Data written to SendPacket() is passed directly to |channel_| if it is
 //     an SRTP packet with the PF_SRTP_BYPASS flag.
 //
 //   - |quic_| passes outgoing packets to WritePacket(), which transfers them
 //     to |channel_| to be sent across the network.
 //
 //   - Data which comes into QuicTransportChannel::OnReadPacket is checked to
 //     see if it is QUIC, and if it is, passed to |quic_|. SRTP packets are
 //     signaled upwards as bypass packets.
 //
 //   - When the QUIC handshake is completed, quic_state() returns
 //     QUIC_TRANSPORT_CONNECTED and SRTP keying material can be exported.
 //
-// TODO(mikescarlett): Implement secure QUIC handshake, 0-RTT handshakes, and
-// QUIC data streams.
+//   - CreateQuicStream() creates an outgoing QUIC stream. Once the local peer
+//     sends data from this stream, the remote peer emits SignalIncomingStream
+//     with a QUIC stream of the same id to handle received data.
+//
+// TODO(mikescarlett): Implement secure QUIC handshake and 0-RTT handshakes.
 class QuicTransportChannel : public TransportChannelImpl,
                              public net::QuicPacketWriter,
                              public net::QuicCryptoClientStream::ProofHandler {
  public:
   // |channel| - the TransportChannelImpl we are wrapping.
   explicit QuicTransportChannel(TransportChannelImpl* channel);
   ~QuicTransportChannel() override;
 
   // TransportChannel overrides.
   // TODO(mikescarlett): Implement certificate authentication.
@@ skipping 30 matching lines @@
   // this extracts the keys negotiated during the QUIC handshake, for use
   // in external encryption such as for extracting SRTP keys.
   bool ExportKeyingMaterial(const std::string& label,
                             const uint8_t* context,
                             size_t context_len,
                             bool use_context,
                             uint8_t* result,
                             size_t result_len) override;
   // TODO(mikescarlett): Remove this method once TransportChannel does not
   // require defining it.
-  bool GetRemoteSSLCertificate(rtc::SSLCertificate** cert) const override {
-    return false;
+  rtc::scoped_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate()
+      const override {
+    return nullptr;
   }
 
   // TransportChannelImpl overrides that we forward to the wrapped transport.
   void SetIceRole(IceRole role) override { channel_->SetIceRole(role); }
   IceRole GetIceRole() const override { return channel_->GetIceRole(); }
   int SetOption(rtc::Socket::Option opt, int value) override {
     return channel_->SetOption(opt, value);
   }
   bool GetOption(rtc::Socket::Option opt, int* value) override {
     return channel_->GetOption(opt, value);
@@ skipping 71 matching lines @@
   void OnProofVerifyDetailsAvailable(
       const net::ProofVerifyDetails& verify_details) override;
 
   // Returns true if |quic_| has queued data which wasn't written due
   // to |channel_| being write blocked.
   bool HasDataToWrite() const;
   // Writes queued data for |quic_| when |channel_| is no longer write blocked.
   void OnCanWrite();
   // Connectivity state of QuicTransportChannel.
   QuicTransportState quic_state() const { return quic_state_; }
+  // Creates a new QUIC stream that can send data.
+  ReliableQuicStream* CreateQuicStream();
+
+  // Emitted when |quic_| creates a QUIC stream to receive data from the remote
+  // peer, when the stream did not exist previously.
+  sigslot::signal1<ReliableQuicStream*> SignalIncomingStream;
+  // Emitted when the QuicTransportChannel state becomes QUIC_TRANSPORT_CLOSED.
+  sigslot::signal0<> SignalClosed;
 
  private:
   // Fingerprint of remote peer.
   struct RemoteFingerprint {
     std::string value;
     std::string algorithm;
   };
 
   // Callbacks for |channel_|.
   void OnReadableState(TransportChannel* channel);
@@ skipping 15 matching lines @@
       TransportChannel* channel,
       CandidatePairInterface* selected_candidate_pair,
       int last_sent_packet_id);
   void OnConnectionRemoved(TransportChannelImpl* channel);
 
   // Callbacks for |quic_|.
   // Called when |quic_| has established the crypto handshake.
   void OnHandshakeComplete();
   // Called when |quic_| has closed the connection.
   void OnConnectionClosed(net::QuicErrorCode error, bool from_peer);
+  // Called when |quic_| has created a new QUIC stream for incoming data.
+  void OnIncomingStream(ReliableQuicStream* stream);
 
   // Called by OnReadPacket() when a QUIC packet is received.
   bool HandleQuicPacket(const char* data, size_t size);
   // Sets up the QUIC handshake.
   bool MaybeStartQuic();
   // Creates the QUIC connection and |quic_|.
   bool CreateQuicSession();
   // Creates the crypto stream and initializes the handshake.
   bool StartQuicHandshake();
   // Sets the QuicTransportChannel connectivity state.
@@ skipping 26 matching lines @@
   rtc::scoped_refptr<rtc::RTCCertificate> local_certificate_;
   // Fingerprint of the remote peer. This must be set before we start QUIC.
   rtc::Optional<RemoteFingerprint> remote_fingerprint_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(QuicTransportChannel);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_P2P_QUIC_QUICTRANSPORTCHANNEL_H_