Refactoring some tests in peerconnectioninterface_unittest.cc.

webrtc/api/peerconnectioninterface_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 221 matching lines @@
 static const char kSdpStringMs1Video1[] =
     "a=ssrc:4 cname:stream1\r\n"
     "a=ssrc:4 msid:stream1 videotrack1\r\n";
 
 #define MAYBE_SKIP_TEST(feature)                    \
   if (!(feature())) {                               \
     LOG(LS_INFO) << "Feature disabled... skipping"; \
     return;                                         \
   }
 
+using ::testing::Exactly;
+using cricket::StreamParams;
 using rtc::scoped_refptr;
-using ::testing::Exactly;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrack;
 using webrtc::AudioTrackInterface;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInterface;
 using webrtc::FakeConstraints;
 using webrtc::IceCandidateInterface;
+using webrtc::JsepSessionDescription;
 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::NotifierInterface;
 using webrtc::ObserverInterface;
@@ skipping 57 matching lines @@
     const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
     const std::string& id) {
   for (const auto& sender : senders) {
     if (sender->id() == id) {
       return true;
     }
   }
   return false;
 }
 
+// Check if |senders| contains the specified sender, by id and stream id.
+bool ContainsSender(
+    const std::vector<rtc::scoped_refptr<RtpSenderInterface>>& senders,
+    const std::string& id,
+    const std::string& stream_id) {
+  for (const auto& sender : senders) {
+    if (sender->id() == id && sender->stream_id() == stream_id) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // Create a collection of streams.
 // CreateStreamCollection(1) creates a collection that
 // correspond to kSdpStringWithStream1.
 // CreateStreamCollection(2) correspond to kSdpStringWithStream1And2.
 rtc::scoped_refptr<StreamCollection> CreateStreamCollection(
-    int number_of_streams) {
+    int number_of_streams,
+    int tracks_per_stream) {
   rtc::scoped_refptr<StreamCollection> local_collection(
       StreamCollection::Create());
 
   for (int i = 0; i < number_of_streams; ++i) {
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
         webrtc::MediaStream::Create(kStreams[i]));
 
-    // Add a local audio track.
-    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
-        webrtc::AudioTrack::Create(kAudioTracks[i], nullptr));
-    stream->AddTrack(audio_track);
+    for (int j = 0; j < tracks_per_stream; ++j) {
+      // Add a local audio track.
+      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
+          webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
+                                     nullptr));
+      stream->AddTrack(audio_track);
 
-    // Add a local video track.
-    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        webrtc::VideoTrack::Create(kVideoTracks[i],
-                                   webrtc::FakeVideoTrackSource::Create()));
-    stream->AddTrack(video_track);
+      // Add a local video track.
+      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
+          webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
+                                     webrtc::FakeVideoTrackSource::Create()));
+      stream->AddTrack(video_track);
+    }
 
     local_collection->AddStream(stream);
   }
   return local_collection;
 }
 
 // Check equality of StreamCollections.
 bool CompareStreamCollections(StreamCollectionInterface* s1,
                               StreamCollectionInterface* s2) {
   if (s1 == nullptr || s2 == nullptr || s1->count() != s2->count()) {
@@ skipping 1616 matching lines @@
 // This test verifies that the remote MediaStreams corresponding to a received
 // SDP string is created. In this test the two separate MediaStreams are
 // signaled.
 TEST_F(PeerConnectionInterfaceTest, UpdateRemoteStreams) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
 
-  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1));
+  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
   EXPECT_TRUE(
       CompareStreamCollections(observer_.remote_streams(), reference.get()));
   MediaStreamInterface* remote_stream = observer_.remote_streams()->at(0);
   EXPECT_TRUE(remote_stream->GetVideoTracks()[0]->GetSource() != nullptr);
 
   // Create a session description based on another SDP with another
   // MediaStream.
   CreateAndSetRemoteOffer(kSdpStringWithStream1And2);
 
-  rtc::scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2));
+  rtc::scoped_refptr<StreamCollection> reference2(CreateStreamCollection(2, 1));
   EXPECT_TRUE(
       CompareStreamCollections(observer_.remote_streams(), reference2.get()));
 }
 
 // This test verifies that when remote tracks are added/removed from SDP, the
 // created remote streams are updated appropriately.
 TEST_F(PeerConnectionInterfaceTest,
        AddRemoveTrackFromExistingRemoteMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
@@ skipping 245 matching lines @@
 }
 
 // This tests that a default MediaStream is not created if a remote session
 // description is updated to not have any MediaStreams.
 TEST_F(PeerConnectionInterfaceTest, VerifyDefaultStreamIsNotCreated) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
   CreateAndSetRemoteOffer(kSdpStringWithStream1);
-  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1));
+  rtc::scoped_refptr<StreamCollection> reference(CreateStreamCollection(1, 1));
   EXPECT_TRUE(
       CompareStreamCollections(observer_.remote_streams(), reference.get()));
 
   CreateAndSetRemoteOffer(kSdpStringWithoutStreams);
   EXPECT_EQ(0u, observer_.remote_streams()->count());
 }
 
 // This tests that an RtpSender is created when the local description is set
 // after adding a local stream.
 // TODO(deadbeef): This test and the one below it need to be updated when
 // an RtpSender's lifetime isn't determined by when a local description is set.
 TEST_F(PeerConnectionInterfaceTest, LocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  // Create an offer just to ensure we have an identity before we manually
-  // call SetLocalDescription.
-  std::unique_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  std::unique_ptr<SessionDescriptionInterface> desc_1 =
-      CreateSessionDescriptionAndReference(2, 2);
+  // Create an offer with 1 stream with 2 tracks of each type.
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(1, 2);
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
-  pc_->AddStream(reference_collection_->at(0));
-  EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 
   // Remove an audio and video track.
-  pc_->RemoveStream(reference_collection_->at(0));
-  std::unique_ptr<SessionDescriptionInterface> desc_2 =
-      CreateSessionDescriptionAndReference(1, 1);
-  pc_->AddStream(reference_collection_->at(0));
-  EXPECT_TRUE(DoSetLocalDescription(desc_2.release()));
+  pc_->RemoveStream(stream_collection->at(0));
+  stream_collection = CreateStreamCollection(1, 1);
+  pc_->AddStream(stream_collection->at(0));
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
+
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_FALSE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_FALSE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that an RtpSender is created when the local description is set
 // before adding a local stream.
 TEST_F(PeerConnectionInterfaceTest,
        AddLocalStreamAfterLocalDescriptionChanged) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  // Create an offer just to ensure we have an identity before we manually
-  // call SetLocalDescription.
-  std::unique_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  std::unique_ptr<SessionDescriptionInterface> desc_1 =
-      CreateSessionDescriptionAndReference(2, 2);
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(1, 2);
+  // Add a stream to create the offer, but remove it afterwards.
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  pc_->RemoveStream(stream_collection->at(0));
 
-  EXPECT_TRUE(DoSetLocalDescription(desc_1.release()));
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(0u, senders.size());
 
-  pc_->AddStream(reference_collection_->at(0));
+  pc_->AddStream(stream_collection->at(0));
   senders = pc_->GetSenders();
   EXPECT_EQ(4u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[1]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[1]));
 }
 
 // This tests that the expected behavior occurs if the SSRC on a local track is
 // changed when SetLocalDescription is called.
 TEST_F(PeerConnectionInterfaceTest,
        ChangeSsrcOnTrackInLocalSessionDescription) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  // Create an offer just to ensure we have an identity before we manually
-  // call SetLocalDescription.
-  std::unique_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  std::unique_ptr<SessionDescriptionInterface> desc =
-      CreateSessionDescriptionAndReference(1, 1);
-  std::string sdp;
-  desc->ToString(&sdp);
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(2, 1);
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  // Grab a copy of the offer before it gets passed into the PC.
+  std::unique_ptr<JsepSessionDescription> modified_offer(
+      new JsepSessionDescription(JsepSessionDescription::kOffer));
+  modified_offer->Initialize(offer->description()->Copy(), offer->session_id(),
+                             offer->session_version());
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
-  pc_->AddStream(reference_collection_->at(0));
-  EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
 
   // Change the ssrc of the audio and video track.
-  std::string ssrc_org = "a=ssrc:1";
-  std::string ssrc_to = "a=ssrc:97";
-  rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(), ssrc_to.c_str(),
-                       ssrc_to.length(), &sdp);
-  ssrc_org = "a=ssrc:2";
-  ssrc_to = "a=ssrc:98";
-  rtc::replace_substrs(ssrc_org.c_str(), ssrc_org.length(), ssrc_to.c_str(),
-                       ssrc_to.length(), &sdp);
-  std::unique_ptr<SessionDescriptionInterface> updated_desc(
-      webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, sdp,
-                                       nullptr));
+  cricket::MediaContentDescription* desc =
+      cricket::GetFirstAudioContentDescription(modified_offer->description());
+  ASSERT_TRUE(desc != NULL);
+  for (StreamParams& stream : desc->mutable_streams()) {
+    for (unsigned int& ssrc : stream.ssrcs) {

[tommi, 2016/05/12 11:41:44]

nit: since we rarely use unsigned int, and should generally by using int
instead, suggest you just use "auto&" here and below.

+      ++ssrc;
+    }
+  }
 
-  EXPECT_TRUE(DoSetLocalDescription(updated_desc.release()));
+  desc =
+      cricket::GetFirstVideoContentDescription(modified_offer->description());
+  ASSERT_TRUE(desc != NULL);
+  for (StreamParams& stream : desc->mutable_streams()) {
+    for (unsigned int& ssrc : stream.ssrcs) {
+      ++ssrc;
+    }
+  }
+
+  EXPECT_TRUE(DoSetLocalDescription(modified_offer.release()));
   senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
   EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
   // TODO(deadbeef): Once RtpSenders expose parameters, check that the SSRC
   // changed.
 }
 
 // This tests that the expected behavior occurs if a new session description is
 // set with the same tracks, but on a different MediaStream.
 TEST_F(PeerConnectionInterfaceTest,
        SignalSameTracksInSeparateMediaStream) {
   FakeConstraints constraints;
   constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp,
                            true);
   CreatePeerConnection(&constraints);
-  // Create an offer just to ensure we have an identity before we manually
-  // call SetLocalDescription.
-  std::unique_ptr<SessionDescriptionInterface> throwaway;
-  ASSERT_TRUE(DoCreateOffer(&throwaway, nullptr));
 
-  std::unique_ptr<SessionDescriptionInterface> desc =
-      CreateSessionDescriptionAndReference(1, 1);
-  std::string sdp;
-  desc->ToString(&sdp);
+  rtc::scoped_refptr<StreamCollection> stream_collection =
+      CreateStreamCollection(2, 1);
+  pc_->AddStream(stream_collection->at(0));
+  std::unique_ptr<SessionDescriptionInterface> offer;
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
-  pc_->AddStream(reference_collection_->at(0));
-  EXPECT_TRUE(DoSetLocalDescription(desc.release()));
   auto senders = pc_->GetSenders();
   EXPECT_EQ(2u, senders.size());
-  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
-  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0], kStreams[0]));
+  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0]));
 
   // Add a new MediaStream but with the same tracks as in the first stream.
   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
       webrtc::MediaStream::Create(kStreams[1]));
-  stream_1->AddTrack(reference_collection_->at(0)->GetVideoTracks()[0]);
-  stream_1->AddTrack(reference_collection_->at(0)->GetAudioTracks()[0]);
+  stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
+  stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
   pc_->AddStream(stream_1);
 
-  // Replace msid in the original SDP.
-  rtc::replace_substrs(kStreams[0], strlen(kStreams[0]), kStreams[1],
-                       strlen(kStreams[1]), &sdp);
+  ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
+  EXPECT_TRUE(DoSetLocalDescription(offer.release()));
 
-  std::unique_ptr<SessionDescriptionInterface> updated_desc(
-      webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer, sdp,
-                                       nullptr));
-
-  EXPECT_TRUE(DoSetLocalDescription(updated_desc.release()));
-  senders = pc_->GetSenders();
-  EXPECT_EQ(2u, senders.size());
-  EXPECT_TRUE(ContainsSender(senders, kAudioTracks[0]));
-  EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0]));
+  auto new_senders = pc_->GetSenders();
+  // Should be the same senders as before, but with updated stream id.
+  // Note that this behavior is subject to change in the future.
+  // We may decide the PC should ignore existing tracks in AddStream.
+  EXPECT_EQ(senders, new_senders);
+  EXPECT_TRUE(ContainsSender(new_senders, kAudioTracks[0], kStreams[1]));
+  EXPECT_TRUE(ContainsSender(new_senders, kVideoTracks[0], kStreams[1]));
 }
 
 // The PeerConnectionMediaConfig tests below verify that configuration
 // and constraints are propagated into the MediaConfig passed to
 // CreateMediaController. These settings are intended for MediaChannel
 // constructors, but that is not exercised by these unittest.
 class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
  public:
   webrtc::MediaControllerInterface* CreateMediaController(
       const cricket::MediaConfig& config) const override {
@@ skipping 268 matching lines @@
   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());
 }