Adds a test for an one-way media PeerConnection.

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 397 matching lines @@
                                                     &source_constraints);
     std::string label = stream_label + kVideoTrackLabelBase;
     return peer_connection_factory_->CreateVideoTrack(label, source);
   }
 
   DataChannelInterface* data_channel() { return data_channel_; }
   const MockDataChannelObserver* data_observer() const {
     return data_observer_.get();
   }
 
-  webrtc::PeerConnectionInterface* pc() { return peer_connection_.get(); }
+  webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); }
 
   void StopVideoCapturers() {
     for (std::vector<cricket::VideoCapturer*>::iterator it =
              video_capturers_.begin();
          it != video_capturers_.end(); ++it) {
       (*it)->Stop();
     }
   }
 
   bool AudioFramesReceivedCheck(int number_of_frames) const {
+    // Only check frames if the incoming stream exists.
+    if (remote_streams()->count() == 0) {

[perkj_webrtc, 2016/03/08 23:07:50]

can you please refactor LocalP2PTest instead? There is already a check for
can_receive... to fix this this. But it checks both the sender and the receiver
as one unit instead of separate. ie number_of_frames should be 0 if you dont
expect a frame.

[hta-webrtc, 2016/03/09 04:09:53]

I'd like not to, because I've got another CL in flight that significantly
restructures this whole piece of infrastructure (constraint removal). Would a
TODO be sufficient at this time?

The check for can_receive.... was wrong. It did not work for one-way media - in
the one-way media case, we're perfectly happy to receive, there just isn't
anyone sending.

[hta-webrtc, 2016/03/09 09:40:17]

Only took an hour to restructure the counting. Looks better?

+      return true;
+    }
     return number_of_frames <= fake_audio_capture_module_->frames_received();
   }
 
   int audio_frames_received() const {
     return fake_audio_capture_module_->frames_received();
   }
 
   bool VideoFramesReceivedCheck(int number_of_frames) {
+    // Only check frames if the incoming stream exists.
+    if (remote_streams()->count() == 0) {
+      return true;
+    }
     if (video_decoder_factory_enabled_) {
       const std::vector<FakeWebRtcVideoDecoder*>& decoders
           = fake_video_decoder_factory_->decoders();
       if (decoders.empty()) {
         return number_of_frames <= 0;
       }
 
       for (FakeWebRtcVideoDecoder* decoder : decoders) {
         if (number_of_frames > decoder->GetNumFramesReceived()) {
           return false;
@@ skipping 206 matching lines @@
     return fake_video_renderers_.empty() ? 1 :
         fake_video_renderers_.begin()->second->height();
   }
 
   size_t number_of_remote_streams() {
     if (!pc())
       return 0;
     return pc()->remote_streams()->count();
   }
 
-  StreamCollectionInterface* remote_streams() {
+  StreamCollectionInterface* remote_streams() const {
     if (!pc()) {
       ADD_FAILURE();
       return nullptr;
     }
     return pc()->remote_streams();
   }
 
   StreamCollectionInterface* local_streams() {
     if (!pc()) {
       ADD_FAILURE();
@@ skipping 532 matching lines @@
   LocalP2PTest();
   VerifyRenderedSize(1280, 720);
 }
 
 // This test sets up a call between two endpoints that are configured to use
 // DTLS key agreement. As a result, DTLS is negotiated and used for transport.
 TEST_F(P2PTestConductor, LocalP2PTestDtls) {
   SetupAndVerifyDtlsCall();
 }
 
+// This test sets up an one-way call, with media only from initiator to
+// responder.
+TEST_F(P2PTestConductor, OneWayMediaCall) {
+  ASSERT_TRUE(CreateTestClients());
+  receiving_client()->set_auto_add_stream(false);
+  LocalP2PTest();
+}
+
 // This test sets up a audio call initially and then upgrades to audio/video,
 // using DTLS.
 TEST_F(P2PTestConductor, LocalP2PTestDtlsRenegotiate) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->SetReceiveAudioVideo(true, false);
   LocalP2PTest();
@@ skipping 777 matching lines @@
   PeerConnectionInterface::IceServer server;
   server.urls.push_back("turn:hostname");
   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)