1 files changed, 169 insertions, 19 deletions

diff --git a/chromium/third_party/libjingle/source/talk/app/webrtc/mediastreamsignaling_unittest.cc b/chromium/third_party/libjingle/source/talk/app/webrtc/mediastreamsignaling_unittest.cc
index 5b88aa0c53f..150058eea06 100644
--- a/chromium/third_party/libjingle/source/talk/app/webrtc/mediastreamsignaling_unittest.cc
+++ b/chromium/third_party/libjingle/source/talk/app/webrtc/mediastreamsignaling_unittest.cc
@@ -26,10 +26,12 @@
  */
 
 #include <string>
+#include <vector>
 
 #include "talk/app/webrtc/audiotrack.h"
 #include "talk/app/webrtc/mediastream.h"
 #include "talk/app/webrtc/mediastreamsignaling.h"
+#include "talk/app/webrtc/sctputils.h"
 #include "talk/app/webrtc/streamcollection.h"
 #include "talk/app/webrtc/test/fakeconstraints.h"
 #include "talk/app/webrtc/test/fakedatachannelprovider.h"
@@ -246,13 +248,19 @@ class FakeDataChannelFactory : public webrtc::DataChannelFactory {
 
   virtual talk_base::scoped_refptr<webrtc::DataChannel> CreateDataChannel(
       const std::string& label,
-      const webrtc::DataChannelInit* config) {
-    return webrtc::DataChannel::Create(provider_, type_, label, config);
+      const webrtc::InternalDataChannelInit* config) {
+    last_init_ = *config;
+    return webrtc::DataChannel::Create(provider_, type_, label, *config);
+  }
+
+  const webrtc::InternalDataChannelInit& last_init() const {
+      return last_init_;
   }
 
  private:
   FakeDataChannelProvider* provider_;
   cricket::DataChannelType type_;
+  webrtc::InternalDataChannelInit last_init_;
 };
 
 class MockSignalingObserver : public webrtc::MediaStreamSignalingObserver {
@@ -290,7 +298,8 @@ class MockSignalingObserver : public webrtc::MediaStreamSignalingObserver {
   }
 
   virtual void OnRemoveLocalAudioTrack(MediaStreamInterface* stream,
-                                       AudioTrackInterface* audio_track) {
+                                       AudioTrackInterface* audio_track,
+                                       uint32 ssrc) {
     RemoveTrack(&local_audio_tracks_, stream, audio_track);
   }
 
@@ -376,31 +385,48 @@ class MockSignalingObserver : public webrtc::MediaStreamSignalingObserver {
     std::string track_id;
     uint32 ssrc;
   };
-  typedef std::map<std::string, TrackInfo> TrackInfos;
+  typedef std::vector<TrackInfo> TrackInfos;
 
   void AddTrack(TrackInfos* track_infos, MediaStreamInterface* stream,
                 MediaStreamTrackInterface* track,
                 uint32 ssrc) {
-    (*track_infos)[track->id()] = TrackInfo(stream->label(), track->id(),
-                                            ssrc);
+    (*track_infos).push_back(TrackInfo(stream->label(), track->id(),
+                                       ssrc));
   }
 
   void RemoveTrack(TrackInfos* track_infos, MediaStreamInterface* stream,
                    MediaStreamTrackInterface* track) {
-    TrackInfos::iterator it = track_infos->find(track->id());
-    ASSERT_TRUE(it != track_infos->end());
-    ASSERT_EQ(it->second.stream_label, stream->label());
-    track_infos->erase(it);
+    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) {
-    TrackInfos::const_iterator it = track_infos.find(track_id);
-    ASSERT_TRUE(it != track_infos.end());
-    EXPECT_EQ(stream_label, it->second.stream_label);
-    EXPECT_EQ(ssrc, it->second.ssrc);
+    const TrackInfo* track_info = FindTrackInfo(track_infos,
+                                                stream_label,
+                                                track_id);
+    ASSERT_TRUE(track_info != NULL);
+    EXPECT_EQ(ssrc, track_info->ssrc);
   }
 
   TrackInfos remote_audio_tracks_;
@@ -528,11 +554,11 @@ class MediaStreamSignalingTest: public testing::Test {
 
   talk_base::scoped_refptr<webrtc::DataChannel> AddDataChannel(
       cricket::DataChannelType type, const std::string& label, int id) {
-    webrtc::DataChannelInit config;
+    webrtc::InternalDataChannelInit config;
     config.id = id;
     talk_base::scoped_refptr<webrtc::DataChannel> data_channel(
         webrtc::DataChannel::Create(
-            data_channel_provider_.get(), type, label, &config));
+            data_channel_provider_.get(), type, label, config));
     EXPECT_TRUE(data_channel.get() != NULL);
     EXPECT_TRUE(signaling_->AddDataChannel(data_channel.get()));
     return data_channel;
@@ -1044,6 +1070,47 @@ TEST_F(MediaStreamSignalingTest, ChangeSsrcOnTrackInLocalSessionDescription) {
   observer_->VerifyLocalVideoTrack(kStreams[0], kVideoTracks[0], 98);
 }
 
+// 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) {
+  talk_base::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);
+
+  // Add a new MediaStream but with the same tracks as in the first stream.
+  std::string stream_label_1 = kStreams[1];
+  talk_base::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);
+  talk_base::replace_substrs(
+      kStreams[0], strlen(kStreams[0]), kStreams[1], strlen(kStreams[1]), &sdp);
+
+  talk_base::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);
+  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) {
@@ -1074,14 +1141,55 @@ TEST_F(MediaStreamSignalingTest, SctpIdAllocationNoReuse) {
   EXPECT_NE(old_id, new_id);
 }
 
+// Verifies that SCTP ids of removed DataChannels can be reused.
+TEST_F(MediaStreamSignalingTest, SctpIdReusedForRemovedDataChannel) {
+  int odd_id = 1;
+  int even_id = 0;
+  AddDataChannel(cricket::DCT_SCTP, "a", odd_id);
+  AddDataChannel(cricket::DCT_SCTP, "a", even_id);
+
+  int allocated_id = -1;
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+                                          &allocated_id));
+  EXPECT_EQ(odd_id + 2, allocated_id);
+  AddDataChannel(cricket::DCT_SCTP, "a", allocated_id);
+
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+                                          &allocated_id));
+  EXPECT_EQ(even_id + 2, allocated_id);
+  AddDataChannel(cricket::DCT_SCTP, "a", allocated_id);
+
+  signaling_->RemoveSctpDataChannel(odd_id);
+  signaling_->RemoveSctpDataChannel(even_id);
+
+  // Verifies that removed DataChannel ids are reused.
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+                                          &allocated_id));
+  EXPECT_EQ(odd_id, allocated_id);
+
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+                                          &allocated_id));
+  EXPECT_EQ(even_id, allocated_id);
+
+  // Verifies that used higher DataChannel ids are not reused.
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_SERVER,
+                                          &allocated_id));
+  EXPECT_NE(odd_id + 2, allocated_id);
+
+  ASSERT_TRUE(signaling_->AllocateSctpSid(talk_base::SSL_CLIENT,
+                                          &allocated_id));
+  EXPECT_NE(even_id + 2, allocated_id);
+
+}
+
 // Verifies that duplicated label is not allowed for RTP data channel.
 TEST_F(MediaStreamSignalingTest, RtpDuplicatedLabelNotAllowed) {
   AddDataChannel(cricket::DCT_RTP, "a", -1);
 
-  webrtc::DataChannelInit config;
+  webrtc::InternalDataChannelInit config;
   talk_base::scoped_refptr<webrtc::DataChannel> data_channel =
       webrtc::DataChannel::Create(
-          data_channel_provider_.get(), cricket::DCT_RTP, "a", &config);
+          data_channel_provider_.get(), cricket::DCT_RTP, "a", config);
   ASSERT_TRUE(data_channel.get() != NULL);
   EXPECT_FALSE(signaling_->AddDataChannel(data_channel.get()));
 }
@@ -1092,6 +1200,25 @@ TEST_F(MediaStreamSignalingTest, SctpDuplicatedLabelAllowed) {
   AddDataChannel(cricket::DCT_SCTP, "a", -1);
 }
 
+// Verifies the correct configuration is used to create DataChannel from an OPEN
+// message.
+TEST_F(MediaStreamSignalingTest, CreateDataChannelFromOpenMessage) {
+  FakeDataChannelFactory fake_factory(data_channel_provider_.get(),
+                                      cricket::DCT_SCTP);
+  signaling_->SetDataChannelFactory(&fake_factory);
+  webrtc::DataChannelInit config;
+  config.id = 1;
+  talk_base::Buffer payload;
+  webrtc::WriteDataChannelOpenMessage("a", config, &payload);
+  cricket::ReceiveDataParams params;
+  params.ssrc = config.id;
+  EXPECT_TRUE(signaling_->AddDataChannelFromOpenMessage(params, payload));
+  EXPECT_EQ(config.id, fake_factory.last_init().id);
+  EXPECT_FALSE(fake_factory.last_init().negotiated);
+  EXPECT_EQ(webrtc::InternalDataChannelInit::kAcker,
+            fake_factory.last_init().open_handshake_role);
+}
+
 // Verifies that duplicated label from OPEN message is allowed.
 TEST_F(MediaStreamSignalingTest, DuplicatedLabelFromOpenMessageAllowed) {
   AddDataChannel(cricket::DCT_SCTP, "a", -1);
@@ -1101,5 +1228,28 @@ TEST_F(MediaStreamSignalingTest, DuplicatedLabelFromOpenMessageAllowed) {
   signaling_->SetDataChannelFactory(&fake_factory);
   webrtc::DataChannelInit config;
   config.id = 0;
-  EXPECT_TRUE(signaling_->AddDataChannelFromOpenMessage("a", config));
+  talk_base::Buffer payload;
+  webrtc::WriteDataChannelOpenMessage("a", config, &payload);
+  cricket::ReceiveDataParams params;
+  params.ssrc = config.id;
+  EXPECT_TRUE(signaling_->AddDataChannelFromOpenMessage(params, payload));
+}
+
+// Verifies that a DataChannel closed remotely is closed locally.
+TEST_F(MediaStreamSignalingTest,
+       SctpDataChannelClosedLocallyWhenClosedRemotely) {
+  webrtc::InternalDataChannelInit config;
+  config.id = 0;
+
+  talk_base::scoped_refptr<webrtc::DataChannel> data_channel =
+      webrtc::DataChannel::Create(
+          data_channel_provider_.get(), cricket::DCT_SCTP, "a", config);
+  ASSERT_TRUE(data_channel.get() != NULL);
+  EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
+            data_channel->state());
+
+  EXPECT_TRUE(signaling_->AddDataChannel(data_channel.get()));
+
+  signaling_->OnRemoteSctpDataChannelClosed(config.id);
+  EXPECT_EQ(webrtc::DataChannelInterface::kClosed, data_channel->state());
 }