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

talk/app/webrtc/peerconnection.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 435 matching lines @@
 
 bool ConvertRtcOptionsForOffer(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     cricket::MediaSessionOptions* session_options) {
   typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
   if (!IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_audio) ||
       !IsValidOfferToReceiveMedia(rtc_options.offer_to_receive_video)) {
     return false;
   }
 
-  // According to the spec, offer to receive audio/video if the constraint is
-  // not set and there are send streams.
-  if (rtc_options.offer_to_receive_audio == RTCOfferAnswerOptions::kUndefined) {
-    session_options->recv_audio =
-        session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO);
-  } else {
+  if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio = (rtc_options.offer_to_receive_audio > 0);
   }
-  if (rtc_options.offer_to_receive_video == RTCOfferAnswerOptions::kUndefined) {
-    session_options->recv_video =
-        session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO);
-  } else {
+  if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video = (rtc_options.offer_to_receive_video > 0);
   }
 
   session_options->vad_enabled = rtc_options.voice_activity_detection;
   session_options->transport_options.ice_restart = rtc_options.ice_restart;
-  session_options->bundle_enabled =
-      rtc_options.use_rtp_mux &&
-      (session_options->has_audio() || session_options->has_video() ||
-       session_options->has_data());
+  session_options->bundle_enabled = rtc_options.use_rtp_mux;
 
   return true;
 }
 
 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints,
                                cricket::MediaSessionOptions* session_options) {
   bool value = false;
   size_t mandatory_constraints_satisfied = 0;
 
   // kOfferToReceiveAudio defaults to true according to spec.
@@ skipping 21 matching lines @@
     session_options->vad_enabled = value;
   }
 
   if (FindConstraint(constraints, MediaConstraintsInterface::kUseRtpMux, &value,
                      &mandatory_constraints_satisfied)) {
     session_options->bundle_enabled = value;
   } else {
     // kUseRtpMux defaults to true according to spec.
     session_options->bundle_enabled = true;
   }
-  session_options->bundle_enabled =
-      session_options->bundle_enabled &&
-      (session_options->has_audio() || session_options->has_video() ||
-       session_options->has_data());
 
   if (FindConstraint(constraints, MediaConstraintsInterface::kIceRestart,
                      &value, &mandatory_constraints_satisfied)) {
     session_options->transport_options.ice_restart = value;
   } else {
     // kIceRestart defaults to false according to spec.
     session_options->transport_options.ice_restart = false;
   }
 
   if (!constraints) {
@@ skipping 494 matching lines @@
 
   // Find all audio rtp streams and create corresponding remote AudioTracks
   // and MediaStreams.
   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
   if (audio_content) {
     const cricket::AudioContentDescription* desc =
         static_cast<const cricket::AudioContentDescription*>(
             audio_content->description);
     UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
     remote_info_.default_audio_track_needed =
-        MediaContentDirectionHasSend(desc->direction()) &&
-        desc->streams().empty();
+        !remote_desc->msid_supported() && desc->streams().empty() &&
+        MediaContentDirectionHasSend(desc->direction());
   }
 
   // Find all video rtp streams and create corresponding remote VideoTracks
   // and MediaStreams.
   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
   if (video_content) {
     const cricket::VideoContentDescription* desc =
         static_cast<const cricket::VideoContentDescription*>(
             video_content->description);
     UpdateRemoteStreamsList(desc->streams(), desc->type(), new_streams);
     remote_info_.default_video_track_needed =
-        MediaContentDirectionHasSend(desc->direction()) &&
-        desc->streams().empty();
+        !remote_desc->msid_supported() && desc->streams().empty() &&
+        MediaContentDirectionHasSend(desc->direction());
   }
 
   // Update the DataChannels with the information from the remote peer.
   const cricket::ContentInfo* data_content = GetFirstDataContent(remote_desc);
   if (data_content) {
     const cricket::DataContentDescription* data_desc =
         static_cast<const cricket::DataContentDescription*>(
             data_content->description);
     if (rtc::starts_with(data_desc->protocol().data(),
                          cricket::kMediaProtocolRtpPrefix)) {
@@ skipping 318 matching lines @@
     CreateSessionDescriptionObserver* observer,
     const std::string& error) {
   CreateSessionDescriptionMsg* msg = new CreateSessionDescriptionMsg(observer);
   msg->error = error;
   signaling_thread()->Post(this, MSG_CREATE_SESSIONDESCRIPTION_FAILED, msg);
 }
 
 bool PeerConnection::GetOptionsForOffer(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
     cricket::MediaSessionOptions* session_options) {
-  SetStreams(session_options, local_streams_, rtp_data_channels_);
-
   if (!ConvertRtcOptionsForOffer(rtc_options, session_options)) {
     return false;
   }
 
+  SetStreams(session_options, local_streams_, rtp_data_channels_);
+  // Offer to receive audio/video if the constraint is not set and there are
+  // send streams, or we're currently receiving.
+  if (rtc_options.offer_to_receive_audio == RTCOfferAnswerOptions::kUndefined) {
+    session_options->recv_audio =
+        session_options->HasSendMediaStream(cricket::MEDIA_TYPE_AUDIO) ||
+        !remote_audio_tracks_.empty();
+  }
+  if (rtc_options.offer_to_receive_video == RTCOfferAnswerOptions::kUndefined) {
+    session_options->recv_video =
+        session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO) ||
+        !remote_video_tracks_.empty();
+  }
+  session_options->bundle_enabled =
+      session_options->bundle_enabled &&
+      (session_options->has_audio() || session_options->has_video() ||
+       session_options->has_data());
+
   if (session_->data_channel_type() == cricket::DCT_SCTP && HasDataChannels()) {
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
   return true;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const MediaConstraintsInterface* constraints,
     cricket::MediaSessionOptions* session_options) {
-  SetStreams(session_options, local_streams_, rtp_data_channels_);
   session_options->recv_audio = false;
   session_options->recv_video = false;
-
   if (!ParseConstraintsForAnswer(constraints, session_options)) {
     return false;
   }
 
+  SetStreams(session_options, local_streams_, rtp_data_channels_);
+  session_options->bundle_enabled =
+      session_options->bundle_enabled &&
+      (session_options->has_audio() || session_options->has_video() ||
+       session_options->has_data());
+
   // RTP data channel is handled in MediaSessionOptions::AddStream. SCTP streams
   // are not signaled in the SDP so does not go through that path and must be
   // handled here.
   if (session_->data_channel_type() == cricket::DCT_SCTP) {
     session_options->data_channel_type = cricket::DCT_SCTP;
   }
   return true;
 }
 
 void PeerConnection::UpdateRemoteStreamsList(
@@ skipping 529 matching lines @@
 DataChannel* PeerConnection::FindDataChannelBySid(int sid) const {
   for (const auto& channel : sctp_data_channels_) {
     if (channel->id() == sid) {
       return channel;
     }
   }
   return nullptr;
 }
 
 }  // namespace webrtc