Exposing RtpSenders and RtpReceivers from PeerConnection.

talk/app/webrtc/mediastreamsignaling_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 52 matching lines @@
 using webrtc::MediaStreamInterface;
 using webrtc::MediaStreamTrackInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::SdpParseError;
 using webrtc::SessionDescriptionInterface;
 using webrtc::StreamCollection;
 using webrtc::StreamCollectionInterface;
 
 typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
 
+static const char kAudioMid[] = "audio";
+static const char kVideoMid[] = "video";
+
 // Reference SDP with a MediaStream with label "stream1" and audio track with
 // id "audio_1" and a video track with id "video_1;
 static const char kSdpStringWithStream1[] =
     "v=0\r\n"
     "o=- 0 0 IN IP4 127.0.0.1\r\n"
     "s=-\r\n"
     "t=0 0\r\n"
     "m=audio 1 RTP/AVPF 103\r\n"
     "a=mid:audio\r\n"
     "a=rtpmap:103 ISAC/16000\r\n"
@@ skipping 222 matching lines @@
   // Remote stream is no longer available.
   virtual void OnRemoveRemoteStream(MediaStreamInterface* remote_stream) {
     remote_media_streams_->RemoveStream(remote_stream);
   }
 
   virtual void OnAddDataChannel(DataChannelInterface* data_channel) {
   }
 
   virtual void OnAddLocalAudioTrack(MediaStreamInterface* stream,
                                     AudioTrackInterface* audio_track,
-                                    uint32 ssrc) {
-    AddTrack(&local_audio_tracks_, stream, audio_track, ssrc);
+                                    uint32 ssrc,
+                                    const std::string& mid) {
+    AddTrack(&local_audio_tracks_, stream, audio_track, ssrc, mid);
   }
 
   virtual void OnAddLocalVideoTrack(MediaStreamInterface* stream,
                                     VideoTrackInterface* video_track,
-                                    uint32 ssrc) {
-    AddTrack(&local_video_tracks_, stream, video_track, ssrc);
+                                    uint32 ssrc,
+                                    const std::string& mid) {
+    AddTrack(&local_video_tracks_, stream, video_track, ssrc, mid);
   }
 
   virtual void OnRemoveLocalAudioTrack(MediaStreamInterface* stream,
                                        AudioTrackInterface* audio_track,
                                        uint32 ssrc) {
     RemoveTrack(&local_audio_tracks_, stream, audio_track);
   }
 
   virtual void OnRemoveLocalVideoTrack(MediaStreamInterface* stream,
                                        VideoTrackInterface* video_track) {
     RemoveTrack(&local_video_tracks_, stream, video_track);
   }
 
   virtual void OnAddRemoteAudioTrack(MediaStreamInterface* stream,
                                      AudioTrackInterface* audio_track,
-                                     uint32 ssrc) {
-    AddTrack(&remote_audio_tracks_, stream, audio_track, ssrc);
+                                     uint32 ssrc,
+                                     const std::string& mid) {
+    AddTrack(&remote_audio_tracks_, stream, audio_track, ssrc, mid);
   }
 
   virtual void OnAddRemoteVideoTrack(MediaStreamInterface* stream,
                                      VideoTrackInterface* video_track,
-                                     uint32 ssrc) {
-    AddTrack(&remote_video_tracks_, stream, video_track, ssrc);
+                                     uint32 ssrc,
+                                     const std::string& mid) {
+    AddTrack(&remote_video_tracks_, stream, video_track, ssrc, mid);
   }
 
   virtual void OnRemoveRemoteAudioTrack(MediaStreamInterface* stream,
                                         AudioTrackInterface* audio_track) {
     RemoveTrack(&remote_audio_tracks_, stream, audio_track);
   }
 
   virtual void OnRemoveRemoteVideoTrack(MediaStreamInterface* stream,
                                         VideoTrackInterface* video_track) {
     RemoveTrack(&remote_video_tracks_, stream, video_track);
   }
 
   virtual void OnRemoveLocalStream(MediaStreamInterface* stream) {
   }
 
   MediaStreamInterface* RemoteStream(const std::string& label) {
     return remote_media_streams_->find(label);
   }
 
   StreamCollectionInterface* remote_streams() const {
     return remote_media_streams_;
   }
 
   size_t NumberOfRemoteAudioTracks() { return remote_audio_tracks_.size(); }
 
-  void  VerifyRemoteAudioTrack(const std::string& stream_label,
-                               const std::string& track_id,
-                               uint32 ssrc) {
-    VerifyTrack(remote_audio_tracks_, stream_label, track_id, ssrc);
+  void VerifyRemoteAudioTrack(const std::string& stream_label,
+                              const std::string& track_id,
+                              uint32 ssrc,
+                              const std::string& mid) {
+    VerifyTrack(remote_audio_tracks_, stream_label, track_id, ssrc, mid);
   }
 
   size_t NumberOfRemoteVideoTracks() { return remote_video_tracks_.size(); }
 
-  void  VerifyRemoteVideoTrack(const std::string& stream_label,
-                               const std::string& track_id,
-                               uint32 ssrc) {
-    VerifyTrack(remote_video_tracks_, stream_label, track_id, ssrc);
+  void VerifyRemoteVideoTrack(const std::string& stream_label,
+                              const std::string& track_id,
+                              uint32 ssrc,
+                              const std::string& mid) {
+    VerifyTrack(remote_video_tracks_, stream_label, track_id, ssrc, mid);
   }
 
   size_t NumberOfLocalAudioTracks() { return local_audio_tracks_.size(); }
-  void  VerifyLocalAudioTrack(const std::string& stream_label,
-                              const std::string& track_id,
-                              uint32 ssrc) {
-    VerifyTrack(local_audio_tracks_, stream_label, track_id, ssrc);
+  void VerifyLocalAudioTrack(const std::string& stream_label,
+                             const std::string& track_id,
+                             uint32 ssrc,
+                             const std::string& mid) {
+    VerifyTrack(local_audio_tracks_, stream_label, track_id, ssrc, mid);
   }
 
   size_t NumberOfLocalVideoTracks() { return local_video_tracks_.size(); }
 
-  void  VerifyLocalVideoTrack(const std::string& stream_label,
-                              const std::string& track_id,
-                              uint32 ssrc) {
-    VerifyTrack(local_video_tracks_, stream_label, track_id, ssrc);
+  void VerifyLocalVideoTrack(const std::string& stream_label,
+                             const std::string& track_id,
+                             uint32 ssrc,
+                             const std::string& mid) {
+    VerifyTrack(local_video_tracks_, stream_label, track_id, ssrc, mid);
   }
 
  private:
   struct TrackInfo {
     TrackInfo() {}
-    TrackInfo(const std::string& stream_label, const std::string track_id,
-              uint32 ssrc)
+    TrackInfo(const std::string& stream_label,
+              const std::string track_id,
+              uint32 ssrc,
+              const std::string& mid)
         : stream_label(stream_label),
           track_id(track_id),
-          ssrc(ssrc) {
-    }
+          ssrc(ssrc),
+          mid(mid) {}
     std::string stream_label;
     std::string track_id;
     uint32 ssrc;
+    std::string mid;
   };
   typedef std::vector<TrackInfo> TrackInfos;
 
-  void AddTrack(TrackInfos* track_infos, MediaStreamInterface* stream,
+  void AddTrack(TrackInfos* track_infos,
+                MediaStreamInterface* stream,
                 MediaStreamTrackInterface* track,
-                uint32 ssrc) {
-    (*track_infos).push_back(TrackInfo(stream->label(), track->id(),
-                                       ssrc));
+                uint32 ssrc,
+                const std::string& mid) {
+    (*track_infos)
+        .push_back(TrackInfo(stream->label(), track->id(), ssrc, mid));
   }
 
   void RemoveTrack(TrackInfos* track_infos, MediaStreamInterface* stream,
                    MediaStreamTrackInterface* track) {
     for (TrackInfos::iterator it = track_infos->begin();
          it != track_infos->end(); ++it) {
       if (it->stream_label == stream->label() && it->track_id == track->id()) {
         track_infos->erase(it);
         return;
       }
     }
     ADD_FAILURE();
   }
 
   const TrackInfo* FindTrackInfo(const TrackInfos& infos,
                                  const std::string& stream_label,
                                  const std::string track_id) const {
     for (TrackInfos::const_iterator it = infos.begin();
         it != infos.end(); ++it) {
       if (it->stream_label == stream_label && it->track_id == track_id)
         return &*it;
     }
     return NULL;
   }
 
-
   void VerifyTrack(const TrackInfos& track_infos,
                    const std::string& stream_label,
                    const std::string& track_id,
-                   uint32 ssrc) {
+                   uint32 ssrc,
+                   const std::string& mid) {
     const TrackInfo* track_info = FindTrackInfo(track_infos,
                                                 stream_label,
                                                 track_id);
     ASSERT_TRUE(track_info != NULL);
     EXPECT_EQ(ssrc, track_info->ssrc);
+    EXPECT_EQ(mid, track_info->mid);
   }
 
   TrackInfos remote_audio_tracks_;
   TrackInfos remote_video_tracks_;
   TrackInfos local_audio_tracks_;
   TrackInfos local_video_tracks_;
 
   rtc::scoped_refptr<StreamCollection> remote_media_streams_;
 };
 
@@ skipping 333 matching lines @@
   EXPECT_TRUE(desc != NULL);
   signaling_->OnRemoteDescriptionChanged(desc.get());
 
   rtc::scoped_refptr<StreamCollection> reference(
       CreateStreamCollection(1));
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
                                        reference.get()));
   EXPECT_TRUE(CompareStreamCollections(observer_->remote_streams(),
                                        reference.get()));
   EXPECT_EQ(1u, observer_->NumberOfRemoteAudioTracks());
-  observer_->VerifyRemoteAudioTrack(kStreams[0], kAudioTracks[0], 1);
+  observer_->VerifyRemoteAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
   EXPECT_EQ(1u, observer_->NumberOfRemoteVideoTracks());
-  observer_->VerifyRemoteVideoTrack(kStreams[0], kVideoTracks[0], 2);
+  observer_->VerifyRemoteVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
   ASSERT_EQ(1u, observer_->remote_streams()->count());
   MediaStreamInterface* remote_stream =  observer_->remote_streams()->at(0);
   EXPECT_TRUE(remote_stream->GetVideoTracks()[0]->GetSource() != NULL);
 
   // Create a session description based on another SDP with another
   // MediaStream.
   rtc::scoped_ptr<SessionDescriptionInterface> update_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWith2Stream, NULL));
   EXPECT_TRUE(update_desc != NULL);
   signaling_->OnRemoteDescriptionChanged(update_desc.get());
 
   rtc::scoped_refptr<StreamCollection> reference2(
       CreateStreamCollection(2));
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
                                        reference2.get()));
   EXPECT_TRUE(CompareStreamCollections(observer_->remote_streams(),
                                        reference2.get()));
 
   EXPECT_EQ(2u, observer_->NumberOfRemoteAudioTracks());
-  observer_->VerifyRemoteAudioTrack(kStreams[0], kAudioTracks[0], 1);
-  observer_->VerifyRemoteAudioTrack(kStreams[1], kAudioTracks[1], 3);
+  observer_->VerifyRemoteAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyRemoteAudioTrack(kStreams[1], kAudioTracks[1], 3, kAudioMid);
   EXPECT_EQ(2u, observer_->NumberOfRemoteVideoTracks());
-  observer_->VerifyRemoteVideoTrack(kStreams[0], kVideoTracks[0], 2);
-  observer_->VerifyRemoteVideoTrack(kStreams[1], kVideoTracks[1], 4);
+  observer_->VerifyRemoteVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
+  observer_->VerifyRemoteVideoTrack(kStreams[1], kVideoTracks[1], 4, kVideoMid);
 }
 
 // This test verifies that the remote MediaStreams corresponding to a received
 // SDP string is created. In this test the same remote MediaStream is signaled
 // but MediaStream tracks are added and removed.
 TEST_F(MediaStreamSignalingTest, AddRemoveTrackFromExistingRemoteMediaStream) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc_ms1;
   CreateSessionDescriptionAndReference(1, 1, desc_ms1.use());
   signaling_->OnRemoteDescriptionChanged(desc_ms1.get());
   EXPECT_TRUE(CompareStreamCollections(signaling_->remote_streams(),
@@ skipping 105 matching lines @@
   rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringWithoutStreams, NULL));
   ASSERT_TRUE(desc != NULL);
   signaling_->OnRemoteDescriptionChanged(desc.get());
   EXPECT_EQ(1u, signaling_->remote_streams()->count());
   ASSERT_EQ(1u, remote_stream->GetAudioTracks().size());
   EXPECT_EQ("defaulta0", remote_stream->GetAudioTracks()[0]->id());
   ASSERT_EQ(1u, remote_stream->GetVideoTracks().size());
   EXPECT_EQ("defaultv0", remote_stream->GetVideoTracks()[0]->id());
-  observer_->VerifyRemoteAudioTrack("default", "defaulta0", 0);
-  observer_->VerifyRemoteVideoTrack("default", "defaultv0", 0);
+  observer_->VerifyRemoteAudioTrack("default", "defaulta0", 0, kAudioMid);
+  observer_->VerifyRemoteVideoTrack("default", "defaultv0", 0, kVideoMid);
 }
 
 // This tests that a default MediaStream is created if a remote session
 // description doesn't contain any streams and media direction is send only.
 TEST_F(MediaStreamSignalingTest, RecvOnlySdpWithoutMsidCreatesDefaultStream) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        kSdpStringSendOnlyWithWithoutStreams,
                                        NULL));
   ASSERT_TRUE(desc != NULL);
@@ skipping 85 matching lines @@
 // when MediaStreamSignaling::OnLocalDescriptionChanged is called with an
 // updated local session description.
 TEST_F(MediaStreamSignalingTest, LocalDescriptionChanged) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
   CreateSessionDescriptionAndReference(2, 2, desc_1.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
   signaling_->OnLocalDescriptionChanged(desc_1.get());
   EXPECT_EQ(2u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(2u, observer_->NumberOfLocalVideoTracks());
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2);
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[1], 3);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[1], 4);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[1], 3, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[1], 4, kVideoMid);
 
   // Remove an audio and video track.
   rtc::scoped_ptr<SessionDescriptionInterface> desc_2;
   CreateSessionDescriptionAndReference(1, 1, desc_2.use());
   signaling_->OnLocalDescriptionChanged(desc_2.get());
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(1u, observer_->NumberOfLocalVideoTracks());
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
 }
 
 // This test that the correct MediaStreamSignalingObserver methods are called
 // when MediaStreamSignaling::AddLocalStream is called after
 // MediaStreamSignaling::OnLocalDescriptionChanged is called.
 TEST_F(MediaStreamSignalingTest, AddLocalStreamAfterLocalDescriptionChanged) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc_1;
   CreateSessionDescriptionAndReference(2, 2, desc_1.use());
 
   signaling_->OnLocalDescriptionChanged(desc_1.get());
   EXPECT_EQ(0u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(0u, observer_->NumberOfLocalVideoTracks());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
   EXPECT_EQ(2u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(2u, observer_->NumberOfLocalVideoTracks());
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2);
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[1], 3);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[1], 4);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[1], 3, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[1], 4, kVideoMid);
 }
 
 // This test that the correct MediaStreamSignalingObserver methods are called
 // if the ssrc on a local track is changed when
 // MediaStreamSignaling::OnLocalDescriptionChanged is called.
 TEST_F(MediaStreamSignalingTest, ChangeSsrcOnTrackInLocalSessionDescription) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc;
   CreateSessionDescriptionAndReference(1, 1, desc.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
   signaling_->OnLocalDescriptionChanged(desc.get());
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(1u, observer_->NumberOfLocalVideoTracks());
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 2, kVideoMid);
 
   // Change the ssrc of the audio and video track.
   std::string sdp;
   desc->ToString(&sdp);
   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);
   rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL));
 
   signaling_->OnLocalDescriptionChanged(updated_desc.get());
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(1u, observer_->NumberOfLocalVideoTracks());
-  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 97);
-  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 98);
+  observer_->VerifyLocalAudioTrack(kStreams[0], kAudioTracks[0], 97, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 98, kVideoMid);
 }
 
 // This test that the correct MediaStreamSignalingObserver methods are called
 // if a new session description is set with the same tracks but they are now
 // sent on a another MediaStream.
 TEST_F(MediaStreamSignalingTest, SignalSameTracksInSeparateMediaStream) {
   rtc::scoped_ptr<SessionDescriptionInterface> desc;
   CreateSessionDescriptionAndReference(1, 1, desc.use());
 
   signaling_->AddLocalStream(reference_collection_->at(0));
   signaling_->OnLocalDescriptionChanged(desc.get());
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(1u, observer_->NumberOfLocalVideoTracks());
 
   std::string stream_label_0 = kStreams[0];
-  observer_->VerifyLocalAudioTrack(stream_label_0, kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(stream_label_0, kVideoTracks[0], 2);
+  observer_->VerifyLocalAudioTrack(stream_label_0, kAudioTracks[0], 1,
+                                   kAudioMid);
+  observer_->VerifyLocalVideoTrack(stream_label_0, kVideoTracks[0], 2,
+                                   kVideoMid);
 
   // Add a new MediaStream but with the same tracks as in the first stream.
   std::string stream_label_1 = kStreams[1];
   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]);
   signaling_->AddLocalStream(stream_1);
 
   // Replace msid in the original SDP.
   std::string sdp;
   desc->ToString(&sdp);
   rtc::replace_substrs(
       kStreams[0], strlen(kStreams[0]), kStreams[1], strlen(kStreams[1]), &sdp);
 
   rtc::scoped_ptr<SessionDescriptionInterface> updated_desc(
       webrtc::CreateSessionDescription(SessionDescriptionInterface::kOffer,
                                        sdp, NULL));
 
   signaling_->OnLocalDescriptionChanged(updated_desc.get());
-  observer_->VerifyLocalAudioTrack(kStreams[1], kAudioTracks[0], 1);
-  observer_->VerifyLocalVideoTrack(kStreams[1], kVideoTracks[0], 2);
+  observer_->VerifyLocalAudioTrack(kStreams[1], kAudioTracks[0], 1, kAudioMid);
+  observer_->VerifyLocalVideoTrack(kStreams[1], kVideoTracks[0], 2, kVideoMid);
   EXPECT_EQ(1u, observer_->NumberOfLocalAudioTracks());
   EXPECT_EQ(1u, observer_->NumberOfLocalVideoTracks());
 }
 
 // Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
 // SSL_SERVER.
 TEST_F(MediaStreamSignalingTest, SctpIdAllocationBasedOnRole) {
   int id;
   ASSERT_TRUE(signaling_->AllocateSctpSid(rtc::SSL_SERVER, &id));
   EXPECT_EQ(1, id);
@@ skipping 149 matching lines @@
   webrtc::WriteDataChannelOpenMessage("a", config, &payload);
   cricket::ReceiveDataParams params;
   params.ssrc = config.id;
   EXPECT_TRUE(signaling_->AddDataChannelFromOpenMessage(params, payload));
   EXPECT_TRUE(signaling_->HasDataChannels());
 
   // Removes the DataChannel and verifies that no DataChannel is left.
   signaling_->RemoveSctpDataChannel(config.id);
   EXPECT_FALSE(signaling_->HasDataChannels());
 }