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 a locally-initiated QUIC stream with an
+//     internally assigned ID. SignalIncomingStream is emitted when the remote
+//     peer initiates a QUIC stream with a new ID.
+//
+// TODO(mikescarlett): Implement secure QUIC handshake and 0-RTT handshakes.
+// Eliminate inheritance of Transport when TransportController no longer
+// requires it internally.
 class QuicTransportChannel : public TransportChannelImpl,
+                             public Transport,

[Taylor Brandstetter, 2016/04/01 23:23:42]

As discussed, I think it will be confusing for a QuicTransportChannel to also be
a Transport. Can you make a separate "QuicTransport" class, which is essentially
just a QuicTransportChannel factory? Look at P2PTransport for example.

[mikescarlett, 2016/04/05 19:58:53]

Done and split into a new CL.

                              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.
   bool SetLocalCertificate(
       const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) override;
-  rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const override;
+  rtc::scoped_refptr<rtc::RTCCertificate> GetLocalCertificate() const;
   // TODO(mikescarlett): Implement fingerprint authentication.
   bool SetRemoteFingerprint(const std::string& digest_alg,
                             const uint8_t* digest,
                             size_t digest_len) override;
   // TODO(mikescarlett): Remove this DTLS-specific method when TransportChannel
   // does not require defining it.
   bool IsDtlsActive() const override { return true; }
   // Sends a RTP packet if the PF_SRTP_BYPASS flag is set.
   int SendPacket(const char* data,
                  size_t size,
@@ skipping 103 matching lines @@
   // QuicCryptoClientStream::ProofHandler overrides.
   // Called by client crypto handshake when cached proof is marked valid.
   void OnProofValid(
       const net::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 net::ProofVerifyDetails& verify_details) override;
 
+  // Transport override.
+  bool GetLocalCertificate(
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
+    return false;
+  }
+
   // 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 or receive data.

[pthatcher1, 2016/03/30 20:34:50]

Isn't this just for sending data (because each message gets its own stream)?

[mikescarlett, 2016/04/05 19:58:53]

Changed comment.

+  ReliableQuicStream* CreateQuicStream();
+
+  // Emitted when |quic_| creates a QUIC stream to receive incoming 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.
+  // It might occur before this channel is writable if the handshake fails, or
+  // after a successful handshake when a peer explicitly closes the connection.
+  sigslot::signal0<> SignalClosed;
+
+  // Testing methods.
+  const TransportDescription* local_description_for_test() const {

[Taylor Brandstetter, 2016/04/01 23:23:42]

I don't like having "for test" methods that expose the internals of a class. Is
there a way to do without these?

[mikescarlett, 2016/04/05 19:58:53]

This class doesn't need these anyway since it no longer subclasses Transport.

+    return local_description();
+  }
+  const TransportDescription* remote_description_for_test() const {
+    return remote_description();
+  }
+
+ protected:
+  // Transport overrides.
+  bool NegotiateTransportDescription(ContentAction local_role,
+                                     std::string* error_desc) override;
+  // TODO(mikescarlett): Remove these methods once Transport does not require
+  // them. The QuicTransportChannel should be created/deleted directly.
+  TransportChannelImpl* CreateTransportChannel(int component) override {
+    return this;
+  }
+  void DestroyTransportChannel(TransportChannelImpl* channel) override {}
 
  private:
   // Fingerprint of remote peer.
   struct RemoteFingerprint {
     std::string value;
     std::string algorithm;
   };
 
   // Callbacks for |channel_|.
   void OnReadableState(TransportChannel* channel);
@@ skipping 14 matching lines @@
   void OnSelectedCandidatePairChanged(
       TransportChannel* channel,
       CandidatePairInterface* selected_candidate_pair);
   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_