Fixing some issues with the direction attribute of m-lines in offers.

talk/app/webrtc/peerconnectioninterface_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 226 matching lines @@
 using rtc::scoped_ptr;
 using rtc::scoped_refptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrack;
 using webrtc::AudioTrackInterface;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInterface;
 using webrtc::FakeConstraints;
 using webrtc::FakePortAllocatorFactory;
 using webrtc::IceCandidateInterface;
+using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStream;
 using webrtc::MediaStreamInterface;
 using webrtc::MediaStreamTrackInterface;
 using webrtc::MockCreateSessionDescriptionObserver;
 using webrtc::MockDataChannelObserver;
 using webrtc::MockSetSessionDescriptionObserver;
 using webrtc::MockStatsObserver;
 using webrtc::PeerConnectionInterface;
 using webrtc::PeerConnectionObserver;
 using webrtc::PortAllocatorFactoryInterface;
@@ skipping 378 matching lines @@
             audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
     stream->AddTrack(audio_track.get());
     scoped_refptr<VideoTrackInterface> video_track(
         pc_factory_->CreateVideoTrack(video_track_label, NULL));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
-  bool DoCreateOfferAnswer(SessionDescriptionInterface** desc, bool offer) {
+  bool DoCreateOfferAnswer(SessionDescriptionInterface** desc,
+                           bool offer,
+                           MediaConstraintsInterface* constraints = nullptr) {

[pthatcher1, 2015/10/15 06:02:03]

Usually our style is to not have optional args, but instead to just change all
the call sites.  Is that doable here?

[Taylor Brandstetter, 2015/10/15 18:23:36]

Done.

     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockCreateSessionDescriptionObserver>());
     if (offer) {
-      pc_->CreateOffer(observer, NULL);
+      pc_->CreateOffer(observer, constraints);
     } else {
-      pc_->CreateAnswer(observer, NULL);
+      pc_->CreateAnswer(observer, constraints);
     }
     EXPECT_EQ_WAIT(true, observer->called(), kTimeout);
     *desc = observer->release_desc();
     return observer->result();
   }
 
-  bool DoCreateOffer(SessionDescriptionInterface** desc) {
-    return DoCreateOfferAnswer(desc, true);
+  bool DoCreateOffer(SessionDescriptionInterface** desc,
+                     MediaConstraintsInterface* constraints = nullptr) {
+    return DoCreateOfferAnswer(desc, true, constraints);
   }
 
-  bool DoCreateAnswer(SessionDescriptionInterface** desc) {
-    return DoCreateOfferAnswer(desc, false);
+  bool DoCreateAnswer(SessionDescriptionInterface** desc,
+                      MediaConstraintsInterface* constraints = nullptr) {
+    return DoCreateOfferAnswer(desc, false, constraints);
   }
 
   bool DoSetSessionDescription(SessionDescriptionInterface* desc, bool local) {
     rtc::scoped_refptr<MockSetSessionDescriptionObserver>
         observer(new rtc::RefCountedObject<
             MockSetSessionDescriptionObserver>());
     if (local) {
       pc_->SetLocalDescription(observer, desc);
     } else {
       pc_->SetRemoteDescription(observer, desc);
@@ skipping 890 matching lines @@
   EXPECT_TRUE(DoSetSessionDescription(answer, false));
 
   SessionDescriptionInterface* updated_offer =
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        webrtc::kAudioSdpWithUnsupportedCodecs,
                                        nullptr);
   EXPECT_TRUE(DoSetSessionDescription(updated_offer, false));
   CreateAnswerAsLocalDescription();
 }
 
+// Test that if we're receiving (but not sending) a track, subsequent offers
+// will have m-lines with a=recvonly.
+TEST_F(PeerConnectionInterfaceTest, CreateSubsequentRecvOnlyOffer) {
+  FakeConstraints constraints;
+  constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
+                           true);
+  CreatePeerConnection(&constraints);
+  CreateAndSetRemoteOffer(kSdpStringWithStream1);
+  CreateAnswerAsLocalDescription();
+
+  // At this point we should be receiving stream 1, but not sending anything.
+  // A new offer should be recvonly.
+  SessionDescriptionInterface* offer;
+  DoCreateOffer(&offer);
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  const cricket::VideoContentDescription* video_desc =
+      static_cast<const cricket::VideoContentDescription*>(
+          video_content->description);
+  ASSERT_EQ(cricket::MD_RECVONLY, video_desc->direction());
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  const cricket::AudioContentDescription* audio_desc =
+      static_cast<const cricket::AudioContentDescription*>(
+          audio_content->description);
+  ASSERT_EQ(cricket::MD_RECVONLY, audio_desc->direction());
+}
+
+// Test that if we're receiving (but not sending) a track, and the
+// offerToReceiveVideo/offerToReceiveAudio constraints are explicitly set to
+// false, the generated m-lines will be a=inactive.
+TEST_F(PeerConnectionInterfaceTest, CreateSubsequentInactiveOffer) {
+  FakeConstraints constraints;
+  constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
+                           true);
+  CreatePeerConnection(&constraints);
+  CreateAndSetRemoteOffer(kSdpStringWithStream1);
+  CreateAnswerAsLocalDescription();
+
+  // At this point we should be receiving stream 1, but not sending anything.
+  // A new offer should be recvonly.
+  SessionDescriptionInterface* offer;
+  FakeConstraints offer_constraints;
+  offer_constraints.AddMandatory(
+      webrtc::MediaConstraintsInterface::kOfferToReceiveVideo, false);
+  offer_constraints.AddMandatory(
+      webrtc::MediaConstraintsInterface::kOfferToReceiveAudio, false);
+  DoCreateOffer(&offer, &offer_constraints);
+
+  const cricket::ContentInfo* video_content =
+      cricket::GetFirstVideoContent(offer->description());
+  const cricket::VideoContentDescription* video_desc =
+      static_cast<const cricket::VideoContentDescription*>(
+          video_content->description);
+  ASSERT_EQ(cricket::MD_INACTIVE, video_desc->direction());
+
+  const cricket::ContentInfo* audio_content =
+      cricket::GetFirstAudioContent(offer->description());
+  const cricket::AudioContentDescription* audio_desc =
+      static_cast<const cricket::AudioContentDescription*>(
+          audio_content->description);
+  ASSERT_EQ(cricket::MD_INACTIVE, audio_desc->direction());
+}
+
 // Test that PeerConnection::Close changes the states to closed and all remote
 // tracks change state to ended.
 TEST_F(PeerConnectionInterfaceTest, CloseAndTestStreamsAndStates) {
   // Initialize a PeerConnection and negotiate local and remote session
   // description.
   InitiateCall();
   ASSERT_EQ(1u, pc_->local_streams()->count());
   ASSERT_EQ(1u, pc_->remote_streams()->count());
 
   pc_->Close();
@@ skipping 463 matching lines @@
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 }
 
 // The following tests verify that session options are created correctly.
 
 TEST(CreateSessionOptionsTest, GetOptionsForOfferWithInvalidAudioOption) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_audio = RTCOfferAnswerOptions::kUndefined - 1;
 
   cricket::MediaSessionOptions options;
-  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
 
   rtc_options.offer_to_receive_audio =
       RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1;
-  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
 }
 
 TEST(CreateSessionOptionsTest, GetOptionsForOfferWithInvalidVideoOption) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_video = RTCOfferAnswerOptions::kUndefined - 1;
 
   cricket::MediaSessionOptions options;
-  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
 
   rtc_options.offer_to_receive_video =
       RTCOfferAnswerOptions::kMaxOfferToReceiveMedia + 1;
-  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_FALSE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
 }
 
 // Test that a MediaSessionOptions is created for an offer if
 // OfferToReceiveAudio and OfferToReceiveVideo options are set but no
 // MediaStreams are sent.
 TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithAudioVideo) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_audio = 1;
   rtc_options.offer_to_receive_video = 1;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_TRUE(options.has_audio());
   EXPECT_TRUE(options.has_video());
   EXPECT_TRUE(options.bundle_enabled);
 }
 
 // Test that a correct MediaSessionOptions is created for an offer if
 // OfferToReceiveAudio is set but no MediaStreams are sent.
 TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithAudio) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_audio = 1;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_TRUE(options.has_audio());
   EXPECT_FALSE(options.has_video());
   EXPECT_TRUE(options.bundle_enabled);
 }
 
 // Test that a correct MediaSessionOptions is created for an offer if
-// the default OfferOptons is used or MediaStreams are sent.
+// the default OfferOptions are used and no MediaStreams are sent.
 TEST(CreateSessionOptionsTest, GetDefaultMediaSessionOptionsForOffer) {
   RTCOfferAnswerOptions rtc_options;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_FALSE(options.has_audio());
   EXPECT_FALSE(options.has_video());
   EXPECT_FALSE(options.bundle_enabled);
   EXPECT_TRUE(options.vad_enabled);
   EXPECT_FALSE(options.transport_options.ice_restart);
 }
 
 // Test that a correct MediaSessionOptions is created for an offer if
+// the default OfferOptions are used and no MediaStreams are sent, but
+// MediaStreams are being received.
+TEST(CreateSessionOptionsTest,
+     GetDefaultMediaSessionOptionsForAlreadyReceivingOffer) {
+  RTCOfferAnswerOptions rtc_options;
+
+  cricket::MediaSessionOptions options;
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, true, true));
+  EXPECT_TRUE(options.has_audio());
+  EXPECT_TRUE(options.has_video());
+  EXPECT_TRUE(options.bundle_enabled);
+  EXPECT_TRUE(options.vad_enabled);
+  EXPECT_FALSE(options.transport_options.ice_restart);
+}
+
+// Test that a correct MediaSessionOptions is created for an offer if
 // OfferToReceiveVideo is set but no MediaStreams are sent.
 TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithVideo) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_audio = 0;
   rtc_options.offer_to_receive_video = 1;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_FALSE(options.has_audio());
   EXPECT_TRUE(options.has_video());
   EXPECT_TRUE(options.bundle_enabled);
 }
 
 // Test that a correct MediaSessionOptions is created for an offer if
 // UseRtpMux is set to false.
 TEST(CreateSessionOptionsTest,
      GetMediaSessionOptionsForOfferWithBundleDisabled) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.offer_to_receive_audio = 1;
   rtc_options.offer_to_receive_video = 1;
   rtc_options.use_rtp_mux = false;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_TRUE(options.has_audio());
   EXPECT_TRUE(options.has_video());
   EXPECT_FALSE(options.bundle_enabled);
 }
 
 // Test that a correct MediaSessionOptions is created to restart ice if
 // IceRestart is set. It also tests that subsequent MediaSessionOptions don't
 // have |transport_options.ice_restart| set.
 TEST(CreateSessionOptionsTest, GetMediaSessionOptionsForOfferWithIceRestart) {
   RTCOfferAnswerOptions rtc_options;
   rtc_options.ice_restart = true;
 
   cricket::MediaSessionOptions options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_TRUE(options.transport_options.ice_restart);
 
   rtc_options = RTCOfferAnswerOptions();
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_options, &options, false, false));
   EXPECT_FALSE(options.transport_options.ice_restart);
 }
 
 // Test that the MediaConstraints in an answer don't affect if audio and video
 // is offered in an offer but that if kOfferToReceiveAudio or
 // kOfferToReceiveVideo constraints are true in an offer, the media type will be
 // included in subsequent answers.
 TEST(CreateSessionOptionsTest, MediaConstraintsInAnswer) {
   FakeConstraints answer_c;
   answer_c.SetMandatoryReceiveAudio(true);
   answer_c.SetMandatoryReceiveVideo(true);
 
   cricket::MediaSessionOptions answer_options;
   EXPECT_TRUE(ParseConstraintsForAnswer(&answer_c, &answer_options));
   EXPECT_TRUE(answer_options.has_audio());
   EXPECT_TRUE(answer_options.has_video());
 
   RTCOfferAnswerOptions rtc_offer_optoins;
 
   cricket::MediaSessionOptions offer_options;
-  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_offer_optoins, &offer_options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(rtc_offer_optoins, &offer_options,
+                                        false, false));
   EXPECT_FALSE(offer_options.has_audio());
   EXPECT_FALSE(offer_options.has_video());
 
   RTCOfferAnswerOptions updated_rtc_offer_optoins;
   updated_rtc_offer_optoins.offer_to_receive_audio = 1;
   updated_rtc_offer_optoins.offer_to_receive_video = 1;
 
   cricket::MediaSessionOptions updated_offer_options;
   EXPECT_TRUE(ConvertRtcOptionsForOffer(updated_rtc_offer_optoins,
-                                        &updated_offer_options));
+                                        &updated_offer_options, false, false));
   EXPECT_TRUE(updated_offer_options.has_audio());
   EXPECT_TRUE(updated_offer_options.has_video());
 
   // Since an offer has been created with both audio and video, subsequent
   // offers and answers should contain both audio and video.
   // Answers will only contain the media types that exist in the offer
   // regardless of the value of |updated_answer_options.has_audio| and
   // |updated_answer_options.has_video|.
   FakeConstraints updated_answer_c;
   answer_c.SetMandatoryReceiveAudio(false);
   answer_c.SetMandatoryReceiveVideo(false);
 
   cricket::MediaSessionOptions updated_answer_options;
   EXPECT_TRUE(
       ParseConstraintsForAnswer(&updated_answer_c, &updated_answer_options));
   EXPECT_TRUE(updated_answer_options.has_audio());
   EXPECT_TRUE(updated_answer_options.has_video());
 
   RTCOfferAnswerOptions default_rtc_options;
-  EXPECT_TRUE(
-      ConvertRtcOptionsForOffer(default_rtc_options, &updated_offer_options));
+  EXPECT_TRUE(ConvertRtcOptionsForOffer(default_rtc_options,
+                                        &updated_offer_options, false, false));
   // By default, |has_audio| or |has_video| are false if there is no media
   // track.
   EXPECT_FALSE(updated_offer_options.has_audio());
   EXPECT_FALSE(updated_offer_options.has_video());
 }