Home | History | Annotate | Download | only in webrtc 
      1 /*
      2  * libjingle
      3  * Copyright 2012, Google Inc.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are met:
      7  *
      8  *  1. Redistributions of source code must retain the above copyright notice,
      9  *     this list of conditions and the following disclaimer.
     10  *  2. Redistributions in binary form must reproduce the above copyright notice,
     11  *     this list of conditions and the following disclaimer in the documentation
     12  *     and/or other materials provided with the distribution.
     13  *  3. The name of the author may not be used to endorse or promote products
     14  *     derived from this software without specific prior written permission.
     15  *
     16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
     17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
     19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
     22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
     24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
     25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26  */
     27 
     28 #include "talk/app/webrtc/mediastreamsignaling.h"
     29 
     30 #include <vector>
     31 
     32 #include "talk/app/webrtc/audiotrack.h"
     33 #include "talk/app/webrtc/mediaconstraintsinterface.h"
     34 #include "talk/app/webrtc/mediastreamproxy.h"
     35 #include "talk/app/webrtc/mediastreamtrackproxy.h"
     36 #include "talk/app/webrtc/remoteaudiosource.h"
     37 #include "talk/app/webrtc/remotevideocapturer.h"
     38 #include "talk/app/webrtc/sctputils.h"
     39 #include "talk/app/webrtc/videosource.h"
     40 #include "talk/app/webrtc/videotrack.h"
     41 #include "talk/media/sctp/sctpdataengine.h"
     42 #include "webrtc/base/bytebuffer.h"
     43 #include "webrtc/base/stringutils.h"
     44 
     45 static const char kDefaultStreamLabel[] = "default";
     46 static const char kDefaultAudioTrackLabel[] = "defaulta0";
     47 static const char kDefaultVideoTrackLabel[] = "defaultv0";
     48 
     49 namespace webrtc {
     50 
     51 using rtc::scoped_ptr;
     52 using rtc::scoped_refptr;
     53 
     54 static bool ParseConstraintsForAnswer(
     55     const MediaConstraintsInterface* constraints,
     56     cricket::MediaSessionOptions* options) {
     57   bool value;
     58   size_t mandatory_constraints_satisfied = 0;
     59 
     60   if (FindConstraint(constraints,
     61                      MediaConstraintsInterface::kOfferToReceiveAudio,
     62                      &value, &mandatory_constraints_satisfied)) {
     63     // |options-|has_audio| can only change from false to
     64     // true, but never change from true to false. This is to make sure
     65     // CreateOffer / CreateAnswer doesn't remove a media content
     66     // description that has been created.
     67     options->has_audio |= value;
     68   } else {
     69     // kOfferToReceiveAudio defaults to true according to spec.
     70     options->has_audio = true;
     71   }
     72 
     73   if (FindConstraint(constraints,
     74                      MediaConstraintsInterface::kOfferToReceiveVideo,
     75                      &value, &mandatory_constraints_satisfied)) {
     76     // |options->has_video| can only change from false to
     77     // true, but never change from true to false. This is to make sure
     78     // CreateOffer / CreateAnswer doesn't remove a media content
     79     // description that has been created.
     80     options->has_video |= value;
     81   } else {
     82     // kOfferToReceiveVideo defaults to false according to spec. But
     83     // if it is an answer and video is offered, we should still accept video
     84     // per default.
     85     options->has_video = true;
     86   }
     87 
     88   if (FindConstraint(constraints,
     89                      MediaConstraintsInterface::kVoiceActivityDetection,
     90                      &value, &mandatory_constraints_satisfied)) {
     91     options->vad_enabled = value;
     92   }
     93 
     94   if (FindConstraint(constraints,
     95                      MediaConstraintsInterface::kUseRtpMux,
     96                      &value, &mandatory_constraints_satisfied)) {
     97     options->bundle_enabled = value;
     98   } else {
     99     // kUseRtpMux defaults to true according to spec.
    100     options->bundle_enabled = true;
    101   }
    102   if (FindConstraint(constraints,
    103                      MediaConstraintsInterface::kIceRestart,
    104                      &value, &mandatory_constraints_satisfied)) {
    105     options->transport_options.ice_restart = value;
    106   } else {
    107     // kIceRestart defaults to false according to spec.
    108     options->transport_options.ice_restart = false;
    109   }
    110 
    111   if (!constraints) {
    112     return true;
    113   }
    114   return mandatory_constraints_satisfied == constraints->GetMandatory().size();
    115 }
    116 
    117 // Returns true if if at least one media content is present and
    118 // |options.bundle_enabled| is true.
    119 // Bundle will be enabled  by default if at least one media content is present
    120 // and the constraint kUseRtpMux has not disabled bundle.
    121 static bool EvaluateNeedForBundle(const cricket::MediaSessionOptions& options) {
    122   return options.bundle_enabled &&
    123       (options.has_audio || options.has_video || options.has_data());
    124 }
    125 
    126 static bool MediaContentDirectionHasSend(cricket::MediaContentDirection dir) {
    127   return dir == cricket::MD_SENDONLY || dir == cricket::MD_SENDRECV;
    128 }
    129 
    130 static bool IsValidOfferToReceiveMedia(int value) {
    131   typedef PeerConnectionInterface::RTCOfferAnswerOptions Options;
    132   return (value >= Options::kUndefined) &&
    133       (value <= Options::kMaxOfferToReceiveMedia);
    134 }
    135 
    136 // Add the stream and RTP data channel info to |session_options|.
    137 static void SetStreams(
    138     cricket::MediaSessionOptions* session_options,
    139     rtc::scoped_refptr<StreamCollection> streams,
    140     const MediaStreamSignaling::RtpDataChannels& rtp_data_channels) {
    141   session_options->streams.clear();
    142   if (streams != NULL) {
    143     for (size_t i = 0; i < streams->count(); ++i) {
    144       MediaStreamInterface* stream = streams->at(i);
    145 
    146       AudioTrackVector audio_tracks(stream->GetAudioTracks());
    147 
    148       // For each audio track in the stream, add it to the MediaSessionOptions.
    149       for (size_t j = 0; j < audio_tracks.size(); ++j) {
    150         scoped_refptr<MediaStreamTrackInterface> track(audio_tracks[j]);
    151         session_options->AddStream(
    152             cricket::MEDIA_TYPE_AUDIO, track->id(), stream->label());
    153       }
    154 
    155       VideoTrackVector video_tracks(stream->GetVideoTracks());
    156 
    157       // For each video track in the stream, add it to the MediaSessionOptions.
    158       for (size_t j = 0; j < video_tracks.size(); ++j) {
    159         scoped_refptr<MediaStreamTrackInterface> track(video_tracks[j]);
    160         session_options->AddStream(
    161             cricket::MEDIA_TYPE_VIDEO, track->id(), stream->label());
    162       }
    163     }
    164   }
    165 
    166   // Check for data channels.
    167   MediaStreamSignaling::RtpDataChannels::const_iterator data_channel_it =
    168       rtp_data_channels.begin();
    169   for (; data_channel_it != rtp_data_channels.end(); ++data_channel_it) {
    170     const DataChannel* channel = data_channel_it->second;
    171     if (channel->state() == DataChannel::kConnecting ||
    172         channel->state() == DataChannel::kOpen) {
    173       // |streamid| and |sync_label| are both set to the DataChannel label
    174       // here so they can be signaled the same way as MediaStreams and Tracks.
    175       // For MediaStreams, the sync_label is the MediaStream label and the
    176       // track label is the same as |streamid|.
    177       const std::string& streamid = channel->label();
    178       const std::string& sync_label = channel->label();
    179       session_options->AddStream(
    180           cricket::MEDIA_TYPE_DATA, streamid, sync_label);
    181     }
    182   }
    183 }
    184 
    185 // Factory class for creating remote MediaStreams and MediaStreamTracks.
    186 class RemoteMediaStreamFactory {
    187  public:
    188   explicit RemoteMediaStreamFactory(rtc::Thread* signaling_thread,
    189                                     cricket::ChannelManager* channel_manager)
    190       : signaling_thread_(signaling_thread),
    191         channel_manager_(channel_manager) {
    192   }
    193 
    194   rtc::scoped_refptr<MediaStreamInterface> CreateMediaStream(
    195       const std::string& stream_label) {
    196     return MediaStreamProxy::Create(
    197         signaling_thread_, MediaStream::Create(stream_label));
    198   }
    199 
    200   AudioTrackInterface* AddAudioTrack(webrtc::MediaStreamInterface* stream,
    201                                      const std::string& track_id) {
    202     return AddTrack<AudioTrackInterface, AudioTrack, AudioTrackProxy>(
    203         stream, track_id, RemoteAudioSource::Create().get());
    204   }
    205 
    206   VideoTrackInterface* AddVideoTrack(webrtc::MediaStreamInterface* stream,
    207                                      const std::string& track_id) {
    208     return AddTrack<VideoTrackInterface, VideoTrack, VideoTrackProxy>(
    209         stream, track_id, VideoSource::Create(channel_manager_,
    210                                               new RemoteVideoCapturer(),
    211                                               NULL).get());
    212   }
    213 
    214  private:
    215   template <typename TI, typename T, typename TP, typename S>
    216   TI* AddTrack(MediaStreamInterface* stream, const std::string& track_id,
    217                S* source) {
    218     rtc::scoped_refptr<TI> track(
    219         TP::Create(signaling_thread_, T::Create(track_id, source)));
    220     track->set_state(webrtc::MediaStreamTrackInterface::kLive);
    221     if (stream->AddTrack(track)) {
    222       return track;
    223     }
    224     return NULL;
    225   }
    226 
    227   rtc::Thread* signaling_thread_;
    228   cricket::ChannelManager* channel_manager_;
    229 };
    230 
    231 MediaStreamSignaling::MediaStreamSignaling(
    232     rtc::Thread* signaling_thread,
    233     MediaStreamSignalingObserver* stream_observer,
    234     cricket::ChannelManager* channel_manager)
    235     : signaling_thread_(signaling_thread),
    236       data_channel_factory_(NULL),
    237       stream_observer_(stream_observer),
    238       local_streams_(StreamCollection::Create()),
    239       remote_streams_(StreamCollection::Create()),
    240       remote_stream_factory_(new RemoteMediaStreamFactory(signaling_thread,
    241                                                           channel_manager)),
    242       last_allocated_sctp_even_sid_(-2),
    243       last_allocated_sctp_odd_sid_(-1) {
    244 }
    245 
    246 MediaStreamSignaling::~MediaStreamSignaling() {
    247 }
    248 
    249 void MediaStreamSignaling::TearDown() {
    250   OnAudioChannelClose();
    251   OnVideoChannelClose();
    252   OnDataChannelClose();
    253 }
    254 
    255 bool MediaStreamSignaling::IsSctpSidAvailable(int sid) const {
    256   if (sid < 0 || sid > static_cast<int>(cricket::kMaxSctpSid))
    257     return false;
    258 
    259   return FindDataChannelBySid(sid) < 0;
    260 }
    261 
    262 // Gets the first unused odd/even id based on the DTLS role. If |role| is
    263 // SSL_CLIENT, the allocated id starts from 0 and takes even numbers; otherwise,
    264 // the id starts from 1 and takes odd numbers. Returns false if no id can be
    265 // allocated.
    266 bool MediaStreamSignaling::AllocateSctpSid(rtc::SSLRole role, int* sid) {
    267   int& last_id = (role == rtc::SSL_CLIENT) ?
    268       last_allocated_sctp_even_sid_ : last_allocated_sctp_odd_sid_;
    269 
    270   do {
    271     last_id += 2;
    272   } while (last_id <= static_cast<int>(cricket::kMaxSctpSid) &&
    273            !IsSctpSidAvailable(last_id));
    274 
    275   if (last_id > static_cast<int>(cricket::kMaxSctpSid)) {
    276     return false;
    277   }
    278 
    279   *sid = last_id;
    280   return true;
    281 }
    282 
    283 bool MediaStreamSignaling::HasDataChannels() const {
    284   return !rtp_data_channels_.empty() || !sctp_data_channels_.empty();
    285 }
    286 
    287 bool MediaStreamSignaling::AddDataChannel(DataChannel* data_channel) {
    288   ASSERT(data_channel != NULL);
    289   if (data_channel->data_channel_type() == cricket::DCT_RTP) {
    290     if (rtp_data_channels_.find(data_channel->label()) !=
    291         rtp_data_channels_.end()) {
    292       LOG(LS_ERROR) << "DataChannel with label " << data_channel->label()
    293                     << " already exists.";
    294       return false;
    295     }
    296     rtp_data_channels_[data_channel->label()] = data_channel;
    297   } else {
    298     ASSERT(data_channel->data_channel_type() == cricket::DCT_SCTP);
    299     sctp_data_channels_.push_back(data_channel);
    300   }
    301   return true;
    302 }
    303 
    304 bool MediaStreamSignaling::AddDataChannelFromOpenMessage(
    305     const cricket::ReceiveDataParams& params,
    306     const rtc::Buffer& payload) {
    307   if (!data_channel_factory_) {
    308     LOG(LS_WARNING) << "Remote peer requested a DataChannel but DataChannels "
    309                     << "are not supported.";
    310     return false;
    311   }
    312 
    313   std::string label;
    314   InternalDataChannelInit config;
    315   config.id = params.ssrc;
    316   if (!ParseDataChannelOpenMessage(payload, &label, &config)) {
    317     LOG(LS_WARNING) << "Failed to parse the OPEN message for sid "
    318                     << params.ssrc;
    319     return false;
    320   }
    321   config.open_handshake_role = InternalDataChannelInit::kAcker;
    322 
    323   scoped_refptr<DataChannel> channel(
    324       data_channel_factory_->CreateDataChannel(label, &config));
    325   if (!channel.get()) {
    326     LOG(LS_ERROR) << "Failed to create DataChannel from the OPEN message.";
    327     return false;
    328   }
    329 
    330   stream_observer_->OnAddDataChannel(channel);
    331   return true;
    332 }
    333 
    334 void MediaStreamSignaling::RemoveSctpDataChannel(int sid) {
    335   ASSERT(sid >= 0);
    336   for (SctpDataChannels::iterator iter = sctp_data_channels_.begin();
    337        iter != sctp_data_channels_.end();
    338        ++iter) {
    339     if ((*iter)->id() == sid) {
    340       sctp_data_channels_.erase(iter);
    341 
    342       if (rtc::IsEven(sid) && sid <= last_allocated_sctp_even_sid_) {
    343         last_allocated_sctp_even_sid_ = sid - 2;
    344       } else if (rtc::IsOdd(sid) && sid <= last_allocated_sctp_odd_sid_) {
    345         last_allocated_sctp_odd_sid_ = sid - 2;
    346       }
    347       return;
    348     }
    349   }
    350 }
    351 
    352 bool MediaStreamSignaling::AddLocalStream(MediaStreamInterface* local_stream) {
    353   if (local_streams_->find(local_stream->label()) != NULL) {
    354     LOG(LS_WARNING) << "MediaStream with label " << local_stream->label()
    355                     << "already exist.";
    356     return false;
    357   }
    358   local_streams_->AddStream(local_stream);
    359 
    360   // Find tracks that has already been configured in SDP. This can occur if a
    361   // local session description that contains the MSID of these tracks is set
    362   // before AddLocalStream is called. It can also occur if the local session
    363   // description is not changed and RemoveLocalStream
    364   // is called and later AddLocalStream is called again with the same stream.
    365   AudioTrackVector audio_tracks = local_stream->GetAudioTracks();
    366   for (AudioTrackVector::const_iterator it = audio_tracks.begin();
    367        it != audio_tracks.end(); ++it) {
    368     const TrackInfo* track_info = FindTrackInfo(local_audio_tracks_,
    369                                                 local_stream->label(),
    370                                                 (*it)->id());
    371     if (track_info) {
    372       OnLocalTrackSeen(track_info->stream_label, track_info->track_id,
    373                        track_info->ssrc, cricket::MEDIA_TYPE_AUDIO);
    374     }
    375   }
    376 
    377   VideoTrackVector video_tracks = local_stream->GetVideoTracks();
    378   for (VideoTrackVector::const_iterator it = video_tracks.begin();
    379        it != video_tracks.end(); ++it) {
    380     const TrackInfo* track_info = FindTrackInfo(local_video_tracks_,
    381                                                 local_stream->label(),
    382                                                 (*it)->id());
    383     if (track_info) {
    384       OnLocalTrackSeen(track_info->stream_label, track_info->track_id,
    385                        track_info->ssrc, cricket::MEDIA_TYPE_VIDEO);
    386     }
    387   }
    388   return true;
    389 }
    390 
    391 void MediaStreamSignaling::RemoveLocalStream(
    392     MediaStreamInterface* local_stream) {
    393   AudioTrackVector audio_tracks = local_stream->GetAudioTracks();
    394   for (AudioTrackVector::const_iterator it = audio_tracks.begin();
    395        it != audio_tracks.end(); ++it) {
    396     const TrackInfo* track_info = FindTrackInfo(local_audio_tracks_,
    397                                                 local_stream->label(),
    398                                                 (*it)->id());
    399     if (track_info) {
    400       stream_observer_->OnRemoveLocalAudioTrack(local_stream, *it,
    401                                                 track_info->ssrc);
    402     }
    403   }
    404   VideoTrackVector video_tracks = local_stream->GetVideoTracks();
    405   for (VideoTrackVector::const_iterator it = video_tracks.begin();
    406        it != video_tracks.end(); ++it) {
    407     const TrackInfo* track_info = FindTrackInfo(local_video_tracks_,
    408                                                 local_stream->label(),
    409                                                 (*it)->id());
    410     if (track_info) {
    411       stream_observer_->OnRemoveLocalVideoTrack(local_stream, *it);
    412     }
    413   }
    414 
    415   local_streams_->RemoveStream(local_stream);
    416   stream_observer_->OnRemoveLocalStream(local_stream);
    417 }
    418 
    419 bool MediaStreamSignaling::GetOptionsForOffer(
    420     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
    421     cricket::MediaSessionOptions* session_options) {
    422   typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
    423   if (!IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_audio) ||
    424       !IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_video)) {
    425     return false;
    426   }
    427 
    428   session_options->has_audio = false;
    429   session_options->has_video = false;
    430   SetStreams(session_options, local_streams_, rtp_data_channels_);
    431 
    432   // If |offer_to_receive_[audio/video]| is undefined, respect the flags set
    433   // from SetStreams. Otherwise, overwrite it based on |rtc_options|.
    434   if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
    435     session_options->has_audio = rtc_options.offer_to_receive_audio > 0;
    436   }
    437   if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
    438     session_options->has_video = rtc_options.offer_to_receive_video > 0;
    439   }
    440 
    441   session_options->vad_enabled = rtc_options.voice_activity_detection;
    442   session_options->transport_options.ice_restart = rtc_options.ice_restart;
    443   session_options->bundle_enabled = rtc_options.use_rtp_mux;
    444 
    445   session_options->bundle_enabled = EvaluateNeedForBundle(*session_options);
    446   return true;
    447 }
    448 
    449 bool MediaStreamSignaling::GetOptionsForAnswer(
    450     const MediaConstraintsInterface* constraints,
    451     cricket::MediaSessionOptions* options) {
    452   options->has_audio = false;
    453   options->has_video = false;
    454   SetStreams(options, local_streams_, rtp_data_channels_);
    455 
    456   if (!ParseConstraintsForAnswer(constraints, options)) {
    457     return false;
    458   }
    459   options->bundle_enabled = EvaluateNeedForBundle(*options);
    460   return true;
    461 }
    462 
    463 // Updates or creates remote MediaStream objects given a
    464 // remote SessionDesription.
    465 // If the remote SessionDesription contains new remote MediaStreams
    466 // the observer OnAddStream method is called. If a remote MediaStream is missing
    467 // from the remote SessionDescription OnRemoveStream is called.
    468 void MediaStreamSignaling::OnRemoteDescriptionChanged(
    469     const SessionDescriptionInterface* desc) {
    470   const cricket::SessionDescription* remote_desc = desc->description();
    471   rtc::scoped_refptr<StreamCollection> new_streams(
    472       StreamCollection::Create());
    473 
    474   // Find all audio rtp streams and create corresponding remote AudioTracks
    475   // and MediaStreams.
    476   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
    477   if (audio_content) {
    478     const cricket::AudioContentDescription* desc =
    479         static_cast<const cricket::AudioContentDescription*>(
    480             audio_content->description);
    481     UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
    482     remote_info_.default_audio_track_needed =
    483         MediaContentDirectionHasSend(desc->direction()) &&
    484             desc->streams().empty();
    485   }
    486 
    487   // Find all video rtp streams and create corresponding remote VideoTracks
    488   // and MediaStreams.
    489   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
    490   if (video_content) {
    491     const cricket::VideoContentDescription* desc =
    492         static_cast<const cricket::VideoContentDescription*>(
    493             video_content->description);
    494     UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
    495     remote_info_.default_video_track_needed =
    496         MediaContentDirectionHasSend(desc->direction()) &&
    497             desc->streams().empty();
    498   }
    499 
    500   // Update the DataChannels with the information from the remote peer.
    501   const cricket::ContentInfo* data_content = GetFirstDataContent(remote_desc);
    502   if (data_content) {
    503     const cricket::DataContentDescription* data_desc =
    504         static_cast<const cricket::DataContentDescription*>(
    505             data_content->description);
    506     if (rtc::starts_with(
    507             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
    508       UpdateRemoteRtpDataChannels(data_desc->streams());
    509     }
    510   }
    511 
    512   // Iterate new_streams and notify the observer about new MediaStreams.
    513   for (size_t i = 0; i < new_streams->count(); ++i) {
    514     MediaStreamInterface* new_stream = new_streams->at(i);
    515     stream_observer_->OnAddRemoteStream(new_stream);
    516   }
    517 
    518   // Find removed MediaStreams.
    519   if (remote_info_.IsDefaultMediaStreamNeeded() &&
    520       remote_streams_->find(kDefaultStreamLabel) != NULL) {
    521     // The default media stream already exists. No need to do anything.
    522   } else {
    523     UpdateEndedRemoteMediaStreams();
    524     remote_info_.msid_supported |= remote_streams_->count() > 0;
    525   }
    526   MaybeCreateDefaultStream();
    527 }
    528 
    529 void MediaStreamSignaling::OnLocalDescriptionChanged(
    530     const SessionDescriptionInterface* desc) {
    531   const cricket::ContentInfo* audio_content =
    532       GetFirstAudioContent(desc->description());
    533   if (audio_content) {
    534     if (audio_content->rejected) {
    535       RejectRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
    536     }
    537     const cricket::AudioContentDescription* audio_desc =
    538         static_cast<const cricket::AudioContentDescription*>(
    539             audio_content->description);
    540     UpdateLocalTracks(audio_desc->streams(), audio_desc->type());
    541   }
    542 
    543   const cricket::ContentInfo* video_content =
    544       GetFirstVideoContent(desc->description());
    545   if (video_content) {
    546     if (video_content->rejected) {
    547       RejectRemoteTracks(cricket::MEDIA_TYPE_VIDEO);
    548     }
    549     const cricket::VideoContentDescription* video_desc =
    550         static_cast<const cricket::VideoContentDescription*>(
    551             video_content->description);
    552     UpdateLocalTracks(video_desc->streams(), video_desc->type());
    553   }
    554 
    555   const cricket::ContentInfo* data_content =
    556       GetFirstDataContent(desc->description());
    557   if (data_content) {
    558     const cricket::DataContentDescription* data_desc =
    559         static_cast<const cricket::DataContentDescription*>(
    560             data_content->description);
    561     if (rtc::starts_with(
    562             data_desc->protocol().data(), cricket::kMediaProtocolRtpPrefix)) {
    563       UpdateLocalRtpDataChannels(data_desc->streams());
    564     }
    565   }
    566 }
    567 
    568 void MediaStreamSignaling::OnAudioChannelClose() {
    569   RejectRemoteTracks(cricket::MEDIA_TYPE_AUDIO);
    570 }
    571 
    572 void MediaStreamSignaling::OnVideoChannelClose() {
    573   RejectRemoteTracks(cricket::MEDIA_TYPE_VIDEO);
    574 }
    575 
    576 void MediaStreamSignaling::OnDataChannelClose() {
    577   // Use a temporary copy of the RTP/SCTP DataChannel list because the
    578   // DataChannel may callback to us and try to modify the list.
    579   RtpDataChannels temp_rtp_dcs;
    580   temp_rtp_dcs.swap(rtp_data_channels_);
    581   RtpDataChannels::iterator it1 = temp_rtp_dcs.begin();
    582   for (; it1 != temp_rtp_dcs.end(); ++it1) {
    583     it1->second->OnDataEngineClose();
    584   }
    585 
    586   SctpDataChannels temp_sctp_dcs;
    587   temp_sctp_dcs.swap(sctp_data_channels_);
    588   SctpDataChannels::iterator it2 = temp_sctp_dcs.begin();
    589   for (; it2 != temp_sctp_dcs.end(); ++it2) {
    590     (*it2)->OnDataEngineClose();
    591   }
    592 }
    593 
    594 void MediaStreamSignaling::UpdateRemoteStreamsList(
    595     const cricket::StreamParamsVec& streams,
    596     cricket::MediaType media_type,
    597     StreamCollection* new_streams) {
    598   TrackInfos* current_tracks = GetRemoteTracks(media_type);
    599 
    600   // Find removed tracks. Ie tracks where the track id or ssrc don't match the
    601   // new StreamParam.
    602   TrackInfos::iterator track_it = current_tracks->begin();
    603   while (track_it != current_tracks->end()) {
    604     const TrackInfo& info = *track_it;
    605     cricket::StreamParams params;
    606     if (!cricket::GetStreamBySsrc(streams, info.ssrc, &params) ||
    607         params.id != info.track_id) {
    608       OnRemoteTrackRemoved(info.stream_label, info.track_id, media_type);
    609       track_it = current_tracks->erase(track_it);
    610     } else {
    611       ++track_it;
    612     }
    613   }
    614 
    615   // Find new and active tracks.
    616   for (cricket::StreamParamsVec::const_iterator it = streams.begin();
    617        it != streams.end(); ++it) {
    618     // The sync_label is the MediaStream label and the |stream.id| is the
    619     // track id.
    620     const std::string& stream_label = it->sync_label;
    621     const std::string& track_id = it->id;
    622     uint32 ssrc = it->first_ssrc();
    623 
    624     rtc::scoped_refptr<MediaStreamInterface> stream =
    625         remote_streams_->find(stream_label);
    626     if (!stream) {
    627       // This is a new MediaStream. Create a new remote MediaStream.
    628       stream = remote_stream_factory_->CreateMediaStream(stream_label);
    629       remote_streams_->AddStream(stream);
    630       new_streams->AddStream(stream);
    631     }
    632 
    633     const TrackInfo* track_info = FindTrackInfo(*current_tracks, stream_label,
    634                                                 track_id);
    635     if (!track_info) {
    636       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
    637       OnRemoteTrackSeen(stream_label, track_id, it->first_ssrc(), media_type);
    638     }
    639   }
    640 }
    641 
    642 void MediaStreamSignaling::OnRemoteTrackSeen(const std::string& stream_label,
    643                                              const std::string& track_id,
    644                                              uint32 ssrc,
    645                                              cricket::MediaType media_type) {
    646   MediaStreamInterface* stream = remote_streams_->find(stream_label);
    647 
    648   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
    649     AudioTrackInterface* audio_track =
    650         remote_stream_factory_->AddAudioTrack(stream, track_id);
    651     stream_observer_->OnAddRemoteAudioTrack(stream, audio_track, ssrc);
    652   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
    653     VideoTrackInterface* video_track =
    654         remote_stream_factory_->AddVideoTrack(stream, track_id);
    655     stream_observer_->OnAddRemoteVideoTrack(stream, video_track, ssrc);
    656   } else {
    657     ASSERT(false && "Invalid media type");
    658   }
    659 }
    660 
    661 void MediaStreamSignaling::OnRemoteTrackRemoved(
    662     const std::string& stream_label,
    663     const std::string& track_id,
    664     cricket::MediaType media_type) {
    665   MediaStreamInterface* stream = remote_streams_->find(stream_label);
    666 
    667   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
    668     rtc::scoped_refptr<AudioTrackInterface> audio_track =
    669         stream->FindAudioTrack(track_id);
    670     if (audio_track) {
    671       audio_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
    672       stream->RemoveTrack(audio_track);
    673       stream_observer_->OnRemoveRemoteAudioTrack(stream, audio_track);
    674     }
    675   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
    676     rtc::scoped_refptr<VideoTrackInterface> video_track =
    677         stream->FindVideoTrack(track_id);
    678     if (video_track) {
    679       video_track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
    680       stream->RemoveTrack(video_track);
    681       stream_observer_->OnRemoveRemoteVideoTrack(stream, video_track);
    682     }
    683   } else {
    684     ASSERT(false && "Invalid media type");
    685   }
    686 }
    687 
    688 void MediaStreamSignaling::RejectRemoteTracks(cricket::MediaType media_type) {
    689   TrackInfos* current_tracks = GetRemoteTracks(media_type);
    690   for (TrackInfos::iterator track_it = current_tracks->begin();
    691        track_it != current_tracks->end(); ++track_it) {
    692     const TrackInfo& info = *track_it;
    693     MediaStreamInterface* stream = remote_streams_->find(info.stream_label);
    694     if (media_type == cricket::MEDIA_TYPE_AUDIO) {
    695       AudioTrackInterface* track = stream->FindAudioTrack(info.track_id);
    696       // There's no guarantee the track is still available, e.g. the track may
    697       // have been removed from the stream by javascript.
    698       if (track) {
    699         track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
    700       }
    701     }
    702     if (media_type == cricket::MEDIA_TYPE_VIDEO) {
    703       VideoTrackInterface* track = stream->FindVideoTrack(info.track_id);
    704       // There's no guarantee the track is still available, e.g. the track may
    705       // have been removed from the stream by javascript.
    706       if (track) {
    707         track->set_state(webrtc::MediaStreamTrackInterface::kEnded);
    708       }
    709     }
    710   }
    711 }
    712 
    713 void MediaStreamSignaling::UpdateEndedRemoteMediaStreams() {
    714   std::vector<scoped_refptr<MediaStreamInterface> > streams_to_remove;
    715   for (size_t i = 0; i < remote_streams_->count(); ++i) {
    716     MediaStreamInterface*stream = remote_streams_->at(i);
    717     if (stream->GetAudioTracks().empty() && stream->GetVideoTracks().empty()) {
    718       streams_to_remove.push_back(stream);
    719     }
    720   }
    721 
    722   std::vector<scoped_refptr<MediaStreamInterface> >::const_iterator it;
    723   for (it = streams_to_remove.begin(); it != streams_to_remove.end(); ++it) {
    724     remote_streams_->RemoveStream(*it);
    725     stream_observer_->OnRemoveRemoteStream(*it);
    726   }
    727 }
    728 
    729 void MediaStreamSignaling::MaybeCreateDefaultStream() {
    730   if (!remote_info_.IsDefaultMediaStreamNeeded())
    731     return;
    732 
    733   bool default_created = false;
    734 
    735   scoped_refptr<MediaStreamInterface> default_remote_stream =
    736       remote_streams_->find(kDefaultStreamLabel);
    737   if (default_remote_stream == NULL) {
    738     default_created = true;
    739     default_remote_stream =
    740         remote_stream_factory_->CreateMediaStream(kDefaultStreamLabel);
    741     remote_streams_->AddStream(default_remote_stream);
    742   }
    743   if (remote_info_.default_audio_track_needed &&
    744       default_remote_stream->GetAudioTracks().size() == 0) {
    745     remote_audio_tracks_.push_back(TrackInfo(kDefaultStreamLabel,
    746                                              kDefaultAudioTrackLabel, 0));
    747 
    748     OnRemoteTrackSeen(kDefaultStreamLabel, kDefaultAudioTrackLabel, 0,
    749                        cricket::MEDIA_TYPE_AUDIO);
    750   }
    751   if (remote_info_.default_video_track_needed &&
    752       default_remote_stream->GetVideoTracks().size() == 0) {
    753     remote_video_tracks_.push_back(TrackInfo(kDefaultStreamLabel,
    754                                              kDefaultVideoTrackLabel, 0));
    755     OnRemoteTrackSeen(kDefaultStreamLabel, kDefaultVideoTrackLabel, 0,
    756                        cricket::MEDIA_TYPE_VIDEO);
    757   }
    758   if (default_created) {
    759     stream_observer_->OnAddRemoteStream(default_remote_stream);
    760   }
    761 }
    762 
    763 MediaStreamSignaling::TrackInfos* MediaStreamSignaling::GetRemoteTracks(
    764     cricket::MediaType type) {
    765   if (type == cricket::MEDIA_TYPE_AUDIO)
    766     return &remote_audio_tracks_;
    767   else if (type == cricket::MEDIA_TYPE_VIDEO)
    768     return &remote_video_tracks_;
    769   ASSERT(false && "Unknown MediaType");
    770   return NULL;
    771 }
    772 
    773 MediaStreamSignaling::TrackInfos* MediaStreamSignaling::GetLocalTracks(
    774     cricket::MediaType media_type) {
    775   ASSERT(media_type == cricket::MEDIA_TYPE_AUDIO ||
    776          media_type == cricket::MEDIA_TYPE_VIDEO);
    777 
    778   return (media_type == cricket::MEDIA_TYPE_AUDIO) ?
    779       &local_audio_tracks_ : &local_video_tracks_;
    780 }
    781 
    782 void MediaStreamSignaling::UpdateLocalTracks(
    783     const std::vector<cricket::StreamParams>& streams,
    784     cricket::MediaType media_type) {
    785   TrackInfos* current_tracks = GetLocalTracks(media_type);
    786 
    787   // Find removed tracks. Ie tracks where the track id, stream label or ssrc
    788   // don't match the new StreamParam.
    789   TrackInfos::iterator track_it = current_tracks->begin();
    790   while (track_it != current_tracks->end()) {
    791     const TrackInfo& info = *track_it;
    792     cricket::StreamParams params;
    793     if (!cricket::GetStreamBySsrc(streams, info.ssrc, &params) ||
    794         params.id != info.track_id || params.sync_label != info.stream_label) {
    795       OnLocalTrackRemoved(info.stream_label, info.track_id, info.ssrc,
    796                           media_type);
    797       track_it = current_tracks->erase(track_it);
    798     } else {
    799       ++track_it;
    800     }
    801   }
    802 
    803   // Find new and active tracks.
    804   for (cricket::StreamParamsVec::const_iterator it = streams.begin();
    805        it != streams.end(); ++it) {
    806     // The sync_label is the MediaStream label and the |stream.id| is the
    807     // track id.
    808     const std::string& stream_label = it->sync_label;
    809     const std::string& track_id = it->id;
    810     uint32 ssrc = it->first_ssrc();
    811     const TrackInfo* track_info = FindTrackInfo(*current_tracks,
    812                                                 stream_label,
    813                                                 track_id);
    814     if (!track_info) {
    815       current_tracks->push_back(TrackInfo(stream_label, track_id, ssrc));
    816       OnLocalTrackSeen(stream_label, track_id, it->first_ssrc(),
    817                        media_type);
    818     }
    819   }
    820 }
    821 
    822 void MediaStreamSignaling::OnLocalTrackSeen(
    823     const std::string& stream_label,
    824     const std::string& track_id,
    825     uint32 ssrc,
    826     cricket::MediaType media_type) {
    827   MediaStreamInterface* stream = local_streams_->find(stream_label);
    828   if (!stream) {
    829     LOG(LS_WARNING) << "An unknown local MediaStream with label "
    830                     << stream_label <<  " has been configured.";
    831     return;
    832   }
    833 
    834   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
    835     AudioTrackInterface* audio_track = stream->FindAudioTrack(track_id);
    836     if (!audio_track) {
    837       LOG(LS_WARNING) << "An unknown local AudioTrack with id , "
    838                       << track_id <<  " has been configured.";
    839       return;
    840     }
    841     stream_observer_->OnAddLocalAudioTrack(stream, audio_track, ssrc);
    842   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
    843     VideoTrackInterface* video_track = stream->FindVideoTrack(track_id);
    844     if (!video_track) {
    845       LOG(LS_WARNING) << "An unknown local VideoTrack with id , "
    846                       << track_id <<  " has been configured.";
    847       return;
    848     }
    849     stream_observer_->OnAddLocalVideoTrack(stream, video_track, ssrc);
    850   } else {
    851     ASSERT(false && "Invalid media type");
    852   }
    853 }
    854 
    855 void MediaStreamSignaling::OnLocalTrackRemoved(
    856     const std::string& stream_label,
    857     const std::string& track_id,
    858     uint32 ssrc,
    859     cricket::MediaType media_type) {
    860   MediaStreamInterface* stream = local_streams_->find(stream_label);
    861   if (!stream) {
    862     // This is the normal case. Ie RemoveLocalStream has been called and the
    863     // SessionDescriptions has been renegotiated.
    864     return;
    865   }
    866   // A track has been removed from the SessionDescription but the MediaStream
    867   // is still associated with MediaStreamSignaling. This only occurs if the SDP
    868   // doesn't match with the calls to AddLocalStream and RemoveLocalStream.
    869 
    870   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
    871     AudioTrackInterface* audio_track = stream->FindAudioTrack(track_id);
    872     if (!audio_track) {
    873       return;
    874     }
    875     stream_observer_->OnRemoveLocalAudioTrack(stream, audio_track, ssrc);
    876   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
    877     VideoTrackInterface* video_track = stream->FindVideoTrack(track_id);
    878     if (!video_track) {
    879       return;
    880     }
    881     stream_observer_->OnRemoveLocalVideoTrack(stream, video_track);
    882   } else {
    883     ASSERT(false && "Invalid media type.");
    884   }
    885 }
    886 
    887 void MediaStreamSignaling::UpdateLocalRtpDataChannels(
    888     const cricket::StreamParamsVec& streams) {
    889   std::vector<std::string> existing_channels;
    890 
    891   // Find new and active data channels.
    892   for (cricket::StreamParamsVec::const_iterator it =streams.begin();
    893        it != streams.end(); ++it) {
    894     // |it->sync_label| is actually the data channel label. The reason is that
    895     // we use the same naming of data channels as we do for
    896     // MediaStreams and Tracks.
    897     // For MediaStreams, the sync_label is the MediaStream label and the
    898     // track label is the same as |streamid|.
    899     const std::string& channel_label = it->sync_label;
    900     RtpDataChannels::iterator data_channel_it =
    901         rtp_data_channels_.find(channel_label);
    902     if (!VERIFY(data_channel_it != rtp_data_channels_.end())) {
    903       continue;
    904     }
    905     // Set the SSRC the data channel should use for sending.
    906     data_channel_it->second->SetSendSsrc(it->first_ssrc());
    907     existing_channels.push_back(data_channel_it->first);
    908   }
    909 
    910   UpdateClosingDataChannels(existing_channels, true);
    911 }
    912 
    913 void MediaStreamSignaling::UpdateRemoteRtpDataChannels(
    914     const cricket::StreamParamsVec& streams) {
    915   std::vector<std::string> existing_channels;
    916 
    917   // Find new and active data channels.
    918   for (cricket::StreamParamsVec::const_iterator it = streams.begin();
    919        it != streams.end(); ++it) {
    920     // The data channel label is either the mslabel or the SSRC if the mslabel
    921     // does not exist. Ex a=ssrc:444330170 mslabel:test1.
    922     std::string label = it->sync_label.empty() ?
    923         rtc::ToString(it->first_ssrc()) : it->sync_label;
    924     RtpDataChannels::iterator data_channel_it =
    925         rtp_data_channels_.find(label);
    926     if (data_channel_it == rtp_data_channels_.end()) {
    927       // This is a new data channel.
    928       CreateRemoteDataChannel(label, it->first_ssrc());
    929     } else {
    930       data_channel_it->second->SetReceiveSsrc(it->first_ssrc());
    931     }
    932     existing_channels.push_back(label);
    933   }
    934 
    935   UpdateClosingDataChannels(existing_channels, false);
    936 }
    937 
    938 void MediaStreamSignaling::UpdateClosingDataChannels(
    939     const std::vector<std::string>& active_channels, bool is_local_update) {
    940   RtpDataChannels::iterator it = rtp_data_channels_.begin();
    941   while (it != rtp_data_channels_.end()) {
    942     DataChannel* data_channel = it->second;
    943     if (std::find(active_channels.begin(), active_channels.end(),
    944                   data_channel->label()) != active_channels.end()) {
    945       ++it;
    946       continue;
    947     }
    948 
    949     if (is_local_update)
    950       data_channel->SetSendSsrc(0);
    951     else
    952       data_channel->RemotePeerRequestClose();
    953 
    954     if (data_channel->state() == DataChannel::kClosed) {
    955       rtp_data_channels_.erase(it);
    956       it = rtp_data_channels_.begin();
    957     } else {
    958       ++it;
    959     }
    960   }
    961 }
    962 
    963 void MediaStreamSignaling::CreateRemoteDataChannel(const std::string& label,
    964                                                    uint32 remote_ssrc) {
    965   if (!data_channel_factory_) {
    966     LOG(LS_WARNING) << "Remote peer requested a DataChannel but DataChannels "
    967                     << "are not supported.";
    968     return;
    969   }
    970   scoped_refptr<DataChannel> channel(
    971       data_channel_factory_->CreateDataChannel(label, NULL));
    972   if (!channel.get()) {
    973     LOG(LS_WARNING) << "Remote peer requested a DataChannel but"
    974                     << "CreateDataChannel failed.";
    975     return;
    976   }
    977   channel->SetReceiveSsrc(remote_ssrc);
    978   stream_observer_->OnAddDataChannel(channel);
    979 }
    980 
    981 void MediaStreamSignaling::OnDataTransportCreatedForSctp() {
    982   SctpDataChannels::iterator it = sctp_data_channels_.begin();
    983   for (; it != sctp_data_channels_.end(); ++it) {
    984     (*it)->OnTransportChannelCreated();
    985   }
    986 }
    987 
    988 void MediaStreamSignaling::OnDtlsRoleReadyForSctp(rtc::SSLRole role) {
    989   SctpDataChannels::iterator it = sctp_data_channels_.begin();
    990   for (; it != sctp_data_channels_.end(); ++it) {
    991     if ((*it)->id() < 0) {
    992       int sid;
    993       if (!AllocateSctpSid(role, &sid)) {
    994         LOG(LS_ERROR) << "Failed to allocate SCTP sid.";
    995         continue;
    996       }
    997       (*it)->SetSctpSid(sid);
    998     }
    999   }
   1000 }
   1001 
   1002 
   1003 void MediaStreamSignaling::OnRemoteSctpDataChannelClosed(uint32 sid) {
   1004   int index = FindDataChannelBySid(sid);
   1005   if (index < 0) {
   1006     LOG(LS_WARNING) << "Unexpected sid " << sid
   1007                     << " of the remotely closed DataChannel.";
   1008     return;
   1009   }
   1010   sctp_data_channels_[index]->Close();
   1011 }
   1012 
   1013 const MediaStreamSignaling::TrackInfo*
   1014 MediaStreamSignaling::FindTrackInfo(
   1015     const MediaStreamSignaling::TrackInfos& infos,
   1016     const std::string& stream_label,
   1017     const std::string track_id) const {
   1018 
   1019   for (TrackInfos::const_iterator it = infos.begin();
   1020       it != infos.end(); ++it) {
   1021     if (it->stream_label == stream_label && it->track_id == track_id)
   1022       return &*it;
   1023   }
   1024   return NULL;
   1025 }
   1026 
   1027 int MediaStreamSignaling::FindDataChannelBySid(int sid) const {
   1028   for (size_t i = 0; i < sctp_data_channels_.size(); ++i) {
   1029     if (sctp_data_channels_[i]->id() == sid) {
   1030       return static_cast<int>(i);
   1031     }
   1032   }
   1033   return -1;
   1034 }
   1035 
   1036 }  // namespace webrtc
   1037