Modified PeerConnection and WebRtcSession for end-to-end QuicDataChannel usage.

webrtc/api/peerconnection_unittest.cc

 /*
  *  Copyright 2012 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.
  */
 
@@ skipping 155 matching lines @@
 };
 
 class PeerConnectionTestClient : public webrtc::PeerConnectionObserver,
                                  public SignalingMessageReceiver,
                                  public ObserverInterface {
  public:
   static PeerConnectionTestClient* CreateClientWithDtlsIdentityStore(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
+      const PeerConnectionInterface::RTCConfiguration& config,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       bool prefer_constraint_apis,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     PeerConnectionTestClient* client(new PeerConnectionTestClient(id));
-    if (!client->Init(constraints, options, std::move(cert_generator),
+    if (!client->Init(constraints, options, config, std::move(cert_generator),
                       prefer_constraint_apis, network_thread, worker_thread)) {
       delete client;
       return nullptr;
     }
     return client;
   }
 
   static PeerConnectionTestClient* CreateClient(
       const std::string& id,
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
+      const PeerConnectionInterface::RTCConfiguration& config,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeRTCCertificateGenerator() : nullptr);
 
-    return CreateClientWithDtlsIdentityStore(
-        id, constraints, options, std::move(cert_generator), true,
-        network_thread, worker_thread);
+    return CreateClientWithDtlsIdentityStore(id, constraints, options, config,
+                                             std::move(cert_generator), true,
+                                             network_thread, worker_thread);
   }
 
   static PeerConnectionTestClient* CreateClientPreferNoConstraints(
       const std::string& id,
       const PeerConnectionFactory::Options* options,
+      const PeerConnectionInterface::RTCConfiguration& config,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeRTCCertificateGenerator() : nullptr);
 
-    return CreateClientWithDtlsIdentityStore(
-        id, nullptr, options, std::move(cert_generator), false,
-        network_thread, worker_thread);
+    return CreateClientWithDtlsIdentityStore(id, nullptr, options, config,
+                                             std::move(cert_generator), false,
+                                             network_thread, worker_thread);
   }
 
   ~PeerConnectionTestClient() {
   }
 
   void Negotiate() { Negotiate(true, true); }
 
   void Negotiate(bool audio, bool video) {
     std::unique_ptr<SessionDescriptionInterface> offer;
     ASSERT_TRUE(DoCreateOffer(&offer));
@@ skipping 223 matching lines @@
                PeerConnectionInterface::RTCOfferAnswerOptions::kUndefined;
   }
 
   void OnDataChannel(
       rtc::scoped_refptr<DataChannelInterface> data_channel) override {
     LOG(INFO) << id_ << "OnDataChannel";
     data_channel_ = data_channel;
     data_observer_.reset(new MockDataChannelObserver(data_channel));
   }
 
-  void CreateDataChannel() {
-    data_channel_ = pc()->CreateDataChannel(kDataChannelLabel, nullptr);
+  void CreateDataChannel() { CreateDataChannel(nullptr); }
+
+  void CreateDataChannel(const webrtc::DataChannelInit* init) {
+    data_channel_ = pc()->CreateDataChannel(kDataChannelLabel, init);
     ASSERT_TRUE(data_channel_.get() != nullptr);
     data_observer_.reset(new MockDataChannelObserver(data_channel_));
   }
 
   rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack(
       const std::string& stream_label) {
     FakeConstraints constraints;
     // Disable highpass filter so that we can get all the test audio frames.
     constraints.AddMandatory(MediaConstraintsInterface::kHighpassFilter, false);
     rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
@@ skipping 366 matching lines @@
    private:
     bool completed_;
     std::vector<std::string> tones_;
   };
 
   explicit PeerConnectionTestClient(const std::string& id) : id_(id) {}
 
   bool Init(
       const MediaConstraintsInterface* constraints,
       const PeerConnectionFactory::Options* options,
+      const PeerConnectionInterface::RTCConfiguration& config,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       bool prefer_constraint_apis,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread) {
     EXPECT_TRUE(!peer_connection_);
     EXPECT_TRUE(!peer_connection_factory_);
     if (!prefer_constraint_apis) {
       EXPECT_TRUE(!constraints);
     }
     prefer_constraint_apis_ = prefer_constraint_apis;
@@ skipping 11 matching lines @@
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
         network_thread, worker_thread, signaling_thread,
         fake_audio_capture_module_, fake_video_encoder_factory_,
         fake_video_decoder_factory_);
     if (!peer_connection_factory_) {
       return false;
     }
     if (options) {
       peer_connection_factory_->SetOptions(*options);
     }
-    peer_connection_ = CreatePeerConnection(
-        std::move(port_allocator), constraints, std::move(cert_generator));
+    peer_connection_ =
+        CreatePeerConnection(std::move(port_allocator), constraints, config,
+                             std::move(cert_generator));
+
     return peer_connection_.get() != nullptr;
   }
 
   rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
       std::unique_ptr<cricket::PortAllocator> port_allocator,
       const MediaConstraintsInterface* constraints,
+      const PeerConnectionInterface::RTCConfiguration& config,
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator) {
-    // CreatePeerConnection with RTCConfiguration.
-    webrtc::PeerConnectionInterface::RTCConfiguration config;
-    webrtc::PeerConnectionInterface::IceServer ice_server;
-    ice_server.uri = "stun:stun.l.google.com:19302";
-    config.servers.push_back(ice_server);
-
     return peer_connection_factory_->CreatePeerConnection(
         config, constraints, std::move(port_allocator),
         std::move(cert_generator), this);
   }
 
   void HandleIncomingOffer(const std::string& msg) {
     LOG(INFO) << id_ << "HandleIncomingOffer ";
     if (NumberOfLocalMediaStreams() == 0 && auto_add_stream_) {
       // If we are not sending any streams ourselves it is time to add some.
       AddMediaStream(true, true);
@@ skipping 167 matching lines @@
 
 class P2PTestConductor : public testing::Test {
  public:
   P2PTestConductor()
       : pss_(new rtc::PhysicalSocketServer),
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         network_thread_(new rtc::Thread(ss_.get())),
         worker_thread_(rtc::Thread::Create()) {
     RTC_CHECK(network_thread_->Start());
     RTC_CHECK(worker_thread_->Start());
+    webrtc::PeerConnectionInterface::IceServer ice_server;
+    ice_server.uri = "stun:stun.l.google.com:19302";
+    config_.servers.push_back(ice_server);
   }
 
   bool SessionActive() {
     return initiating_client_->SessionActive() &&
            receiving_client_->SessionActive();
   }
 
   // Return true if the number of frames provided have been received
   // on the video and audio tracks provided.
   bool FramesHaveArrived(int audio_frames_to_receive,
@@ skipping 89 matching lines @@
 
   bool CreateTestClients(MediaConstraintsInterface* init_constraints,
                          MediaConstraintsInterface* recv_constraints) {
     return CreateTestClients(init_constraints, nullptr, recv_constraints,
                              nullptr);
   }
 
   bool CreateTestClientsThatPreferNoConstraints() {
     initiating_client_.reset(
         PeerConnectionTestClient::CreateClientPreferNoConstraints(
-            "Caller: ", nullptr, network_thread_.get(), worker_thread_.get()));
+            "Caller: ", nullptr, config_, network_thread_.get(),
+            worker_thread_.get()));
     receiving_client_.reset(
         PeerConnectionTestClient::CreateClientPreferNoConstraints(
-            "Callee: ", nullptr, network_thread_.get(), worker_thread_.get()));
+            "Callee: ", nullptr, config_, network_thread_.get(),
+            worker_thread_.get()));
     if (!initiating_client_ || !receiving_client_) {
       return false;
     }
     // Remember the choice for possible later resets of the clients.
     prefer_constraint_apis_ = false;
     SetSignalingReceivers();
     return true;
   }
 
   void SetSignalingReceivers() {
     initiating_client_->set_signaling_message_receiver(receiving_client_.get());
     receiving_client_->set_signaling_message_receiver(initiating_client_.get());
   }
 
   bool CreateTestClients(MediaConstraintsInterface* init_constraints,
                          PeerConnectionFactory::Options* init_options,
                          MediaConstraintsInterface* recv_constraints,
                          PeerConnectionFactory::Options* recv_options) {
     initiating_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Caller: ", init_constraints, init_options, network_thread_.get(),
-        worker_thread_.get()));
+        "Caller: ", init_constraints, init_options, config_,
+        network_thread_.get(), worker_thread_.get()));
     receiving_client_.reset(PeerConnectionTestClient::CreateClient(
-        "Callee: ", recv_constraints, recv_options, network_thread_.get(),
-        worker_thread_.get()));
+        "Callee: ", recv_constraints, recv_options, config_,
+        network_thread_.get(), worker_thread_.get()));
     if (!initiating_client_ || !receiving_client_) {
       return false;
     }
     SetSignalingReceivers();
     return true;
   }
 
   void SetVideoConstraints(const webrtc::FakeConstraints& init_constraints,
                            const webrtc::FakeConstraints& recv_constraints) {
     initiating_client_->SetVideoConstraints(init_constraints);
@@ skipping 79 matching lines @@
     setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                    true);
 
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
             new FakeRTCCertificateGenerator() : nullptr);
     cert_generator->use_alternate_key();
 
     // Make sure the new client is using a different certificate.
     return PeerConnectionTestClient::CreateClientWithDtlsIdentityStore(
-        "New Peer: ", &setup_constraints, nullptr,
+        "New Peer: ", &setup_constraints, nullptr, config_,
         std::move(cert_generator), prefer_constraint_apis_,
         network_thread_.get(), worker_thread_.get());
   }
 
   void SendRtpData(webrtc::DataChannelInterface* dc, const std::string& data) {
     // Messages may get lost on the unreliable DataChannel, so we send multiple
     // times to avoid test flakiness.
     static const size_t kSendAttempts = 5;
 
     for (size_t i = 0; i < kSendAttempts; ++i) {
@@ skipping 19 matching lines @@
   }
 
   // Set the |receiving_client_| to the |client| passed in and return the
   // original |receiving_client_|.
   PeerConnectionTestClient* set_receiving_client(
       PeerConnectionTestClient* client) {
     PeerConnectionTestClient* old = receiving_client_.release();
     receiving_client_.reset(client);
     return old;
   }
+  webrtc::PeerConnectionInterface::RTCConfiguration* config() {
+    return &config_;
+  }
 
   bool AllObserversReceived(
       const std::vector<std::unique_ptr<MockRtpReceiverObserver>>& observers) {
     for (auto& observer : observers) {
       if (!observer->first_packet_received()) {
         return false;
       }
     }
     return true;
   }
 
  private:
   // |ss_| is used by |network_thread_| so it must be destroyed later.
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   // |network_thread_| and |worker_thread_| are used by both
   // |initiating_client_| and |receiving_client_| so they must be destroyed
   // later.
   std::unique_ptr<rtc::Thread> network_thread_;
   std::unique_ptr<rtc::Thread> worker_thread_;
   std::unique_ptr<PeerConnectionTestClient> initiating_client_;
   std::unique_ptr<PeerConnectionTestClient> receiving_client_;
   bool prefer_constraint_apis_ = true;
+  webrtc::PeerConnectionInterface::RTCConfiguration config_;
 };
 
 // Disable for TSan v2, see
 // https://code.google.com/p/webrtc/issues/detail?id=1205 for details.
 #if !defined(THREAD_SANITIZER)
 
 TEST_F(P2PTestConductor, TestRtpReceiverObserverCallbackFunction) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
   EXPECT_TRUE_WAIT(
@@ skipping 677 matching lines @@
                  kMaxWaitForFramesMs);
   // Now set the tracks, and expect frames to immediately start flowing.
   EXPECT_TRUE(
       audio_sender->SetTrack(initializing_client()->CreateLocalAudioTrack("")));
   EXPECT_TRUE(
       video_sender->SetTrack(initializing_client()->CreateLocalVideoTrack("")));
   EXPECT_TRUE_WAIT(FramesHaveArrived(kEndAudioFrameCount, kEndVideoFrameCount),
                    kMaxWaitForFramesMs);
 }
 
+#ifdef HAVE_QUIC
+// This test sets up a call between two parties using QUIC instead of DTLS for
+// audio and video, and a QUIC data channel.
+TEST_F(P2PTestConductor, LocalP2PTestQuicDataChannel) {
+  config()->enable_quic = true;
+  ASSERT_TRUE(CreateTestClients());
+  webrtc::DataChannelInit init;
+  init.ordered = false;
+  init.reliable = true;
+  init.id = 1;
+  initializing_client()->CreateDataChannel(&init);
+  receiving_client()->CreateDataChannel(&init);
+  LocalP2PTest();
+  ASSERT_NE(nullptr, initializing_client()->data_channel());
+  ASSERT_NE(nullptr, receiving_client()->data_channel());
+  EXPECT_TRUE_WAIT(initializing_client()->data_observer()->IsOpen(),
+                   kMaxWaitMs);
+  EXPECT_TRUE_WAIT(receiving_client()->data_observer()->IsOpen(), kMaxWaitMs);
+
+  std::string data = "hello world";
+
+  initializing_client()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, receiving_client()->data_observer()->last_message(),
+                 kMaxWaitMs);
+
+  receiving_client()->data_channel()->Send(DataBuffer(data));
+  EXPECT_EQ_WAIT(data, initializing_client()->data_observer()->last_message(),
+                 kMaxWaitMs);
+}
+
+// Tests that negotiation of QUIC data channels is completed without error.
+TEST_F(P2PTestConductor, NegotiateQuicDataChannel) {
+  config()->enable_quic = true;
+  FakeConstraints constraints;
+  constraints.SetMandatory(MediaConstraintsInterface::kEnableDtlsSrtp, true);
+  ASSERT_TRUE(CreateTestClients(&constraints, &constraints));
+  webrtc::DataChannelInit init;
+  init.ordered = false;
+  init.reliable = true;
+  init.id = 1;
+  initializing_client()->CreateDataChannel(&init);
+  initializing_client()->Negotiate(false, false);
+}
+
+// This test sets up a JSEP call using QUIC. The callee only receives video.
+TEST_F(P2PTestConductor, LocalP2PTestVideoOnlyWithQuic) {
+  config()->enable_quic = true;
+  ASSERT_TRUE(CreateTestClients());
+  receiving_client()->SetReceiveAudioVideo(false, true);
+  LocalP2PTest();
+}
+
+// This test sets up a JSEP call using QUIC. The callee only receives audio.
+TEST_F(P2PTestConductor, LocalP2PTestAudioOnlyWithQuic) {
+  config()->enable_quic = true;
+  ASSERT_TRUE(CreateTestClients());
+  receiving_client()->SetReceiveAudioVideo(true, false);
+  LocalP2PTest();
+}
+
+// This test sets up a JSEP call using QUIC. The callee rejects both audio and
+// video.
+TEST_F(P2PTestConductor, LocalP2PTestNoVideoAudioWithQuic) {
+  config()->enable_quic = true;
+  ASSERT_TRUE(CreateTestClients());
+  receiving_client()->SetReceiveAudioVideo(false, false);
+  LocalP2PTest();
+}
+
+#endif  // HAVE_QUIC
+
 TEST_F(P2PTestConductor, ForwardVideoOnlyStream) {
   ASSERT_TRUE(CreateTestClients());
   // One-way stream
   receiving_client()->set_auto_add_stream(false);
   // Video only, audio forwarding not expected to work.
   initializing_client()->AddMediaStream(false, true);
   initializing_client()->Negotiate();
 
   ASSERT_TRUE_WAIT(SessionActive(), kMaxWaitForActivationMs);
   VerifySessionDescriptions();
@@ skipping 205 matching lines @@
   server.urls.push_back("turn:hostname2");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_servers_, &turn_servers_));
   EXPECT_EQ(2U, turn_servers_.size());
   EXPECT_NE(turn_servers_[0].priority, turn_servers_[1].priority);
 }
 
 #endif // if !defined(THREAD_SANITIZER)
 
 }  // namespace