Changed defaults for CreateAnswer in non-constraint mode

webrtc/api/peerconnection.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 411 matching lines @@
     }
     return nullptr;
   }
 
   rtc::Thread* signaling_thread_;
   rtc::Thread* worker_thread_;
 };
 
 bool ExtractMediaSessionOptions(
     const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
+    bool is_offer,
     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;
   }
 
+  // If constraints don't prevent us, we always accept video.
   if (rtc_options.offer_to_receive_audio != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_audio = (rtc_options.offer_to_receive_audio > 0);
+  } else {
+    session_options->recv_audio = true;
   }
+  // For offers, we only offer video if we have it or it's forced by options.
+  // For answers, we will always accept video (if offered).
   if (rtc_options.offer_to_receive_video != RTCOfferAnswerOptions::kUndefined) {
     session_options->recv_video = (rtc_options.offer_to_receive_video > 0);
+  } else if (is_offer) {
+    session_options->recv_video = false;
+  } else {
+    session_options->recv_video = true;
   }
 
   session_options->vad_enabled = rtc_options.voice_activity_detection;
   session_options->bundle_enabled = rtc_options.use_rtp_mux;
   for (auto& kv : session_options->transport_options) {
     kv.second.ice_restart = rtc_options.ice_restart;
   }
 
   return true;
 }
@@ skipping 1047 matching lines @@
     cricket::MediaSessionOptions* session_options) {
   // TODO(deadbeef): Once we have transceivers, enumerate them here instead of
   // ContentInfos.
   if (session_->local_description()) {
     for (const cricket::ContentInfo& content :
          session_->local_description()->description()->contents()) {
       session_options->transport_options[content.name] =
           cricket::TransportOptions();
     }
   }
-  if (!ExtractMediaSessionOptions(rtc_options, session_options)) {
+  if (!ExtractMediaSessionOptions(rtc_options, true, session_options)) {
     return false;
   }
 
   AddSendStreams(session_options, senders_, 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();
@@ skipping 50 matching lines @@
   }
   FinishOptionsForAnswer(session_options);
   return true;
 }
 
 bool PeerConnection::GetOptionsForAnswer(
     const RTCOfferAnswerOptions& options,
     cricket::MediaSessionOptions* session_options) {
   session_options->recv_audio = false;
   session_options->recv_video = false;
-  if (!ExtractMediaSessionOptions(options, session_options)) {
+  if (!ExtractMediaSessionOptions(options, false, session_options)) {
     return false;
   }
   FinishOptionsForAnswer(session_options);
   return true;
 }
 
 void PeerConnection::RemoveTracks(cricket::MediaType media_type) {
   UpdateLocalTracks(std::vector<cricket::StreamParams>(), media_type);
   UpdateRemoteStreamsList(std::vector<cricket::StreamParams>(), false,
                           media_type, nullptr);
@@ skipping 519 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