Remove conference_mode flag from AudioOptions and VideoOptions.

webrtc/media/base/mediachannel.h

 /*
  *  Copyright (c) 2004 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 111 matching lines @@
     SetFrom(&auto_gain_control, change.auto_gain_control);
     SetFrom(&noise_suppression, change.noise_suppression);
     SetFrom(&highpass_filter, change.highpass_filter);
     SetFrom(&stereo_swapping, change.stereo_swapping);
     SetFrom(&audio_jitter_buffer_max_packets,
             change.audio_jitter_buffer_max_packets);
     SetFrom(&audio_jitter_buffer_fast_accelerate,
             change.audio_jitter_buffer_fast_accelerate);
     SetFrom(&typing_detection, change.typing_detection);
     SetFrom(&aecm_generate_comfort_noise, change.aecm_generate_comfort_noise);
-    SetFrom(&conference_mode, change.conference_mode);
     SetFrom(&adjust_agc_delta, change.adjust_agc_delta);
     SetFrom(&experimental_agc, change.experimental_agc);
     SetFrom(&extended_filter_aec, change.extended_filter_aec);
     SetFrom(&delay_agnostic_aec, change.delay_agnostic_aec);
     SetFrom(&experimental_ns, change.experimental_ns);
     SetFrom(&aec_dump, change.aec_dump);
     SetFrom(&tx_agc_target_dbov, change.tx_agc_target_dbov);
     SetFrom(&tx_agc_digital_compression_gain,
             change.tx_agc_digital_compression_gain);
     SetFrom(&tx_agc_limiter, change.tx_agc_limiter);
     SetFrom(&recording_sample_rate, change.recording_sample_rate);
     SetFrom(&playout_sample_rate, change.playout_sample_rate);
     SetFrom(&combined_audio_video_bwe, change.combined_audio_video_bwe);
   }
 
   bool operator==(const AudioOptions& o) const {
     return echo_cancellation == o.echo_cancellation &&
         auto_gain_control == o.auto_gain_control &&
         noise_suppression == o.noise_suppression &&
         highpass_filter == o.highpass_filter &&
         stereo_swapping == o.stereo_swapping &&
         audio_jitter_buffer_max_packets == o.audio_jitter_buffer_max_packets &&
         audio_jitter_buffer_fast_accelerate ==
             o.audio_jitter_buffer_fast_accelerate &&
         typing_detection == o.typing_detection &&
         aecm_generate_comfort_noise == o.aecm_generate_comfort_noise &&
-        conference_mode == o.conference_mode &&
         experimental_agc == o.experimental_agc &&
         extended_filter_aec == o.extended_filter_aec &&
         delay_agnostic_aec == o.delay_agnostic_aec &&
         experimental_ns == o.experimental_ns &&
         adjust_agc_delta == o.adjust_agc_delta &&
         aec_dump == o.aec_dump &&
         tx_agc_target_dbov == o.tx_agc_target_dbov &&
         tx_agc_digital_compression_gain == o.tx_agc_digital_compression_gain &&
         tx_agc_limiter == o.tx_agc_limiter &&
         recording_sample_rate == o.recording_sample_rate &&
         playout_sample_rate == o.playout_sample_rate &&
         combined_audio_video_bwe == o.combined_audio_video_bwe;
   }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "AudioOptions {";
     ost << ToStringIfSet("aec", echo_cancellation);
     ost << ToStringIfSet("agc", auto_gain_control);
     ost << ToStringIfSet("ns", noise_suppression);
     ost << ToStringIfSet("hf", highpass_filter);
     ost << ToStringIfSet("swap", stereo_swapping);
     ost << ToStringIfSet("audio_jitter_buffer_max_packets",
                          audio_jitter_buffer_max_packets);
     ost << ToStringIfSet("audio_jitter_buffer_fast_accelerate",
                          audio_jitter_buffer_fast_accelerate);
     ost << ToStringIfSet("typing", typing_detection);
     ost << ToStringIfSet("comfort_noise", aecm_generate_comfort_noise);
-    ost << ToStringIfSet("conference", conference_mode);
     ost << ToStringIfSet("agc_delta", adjust_agc_delta);
     ost << ToStringIfSet("experimental_agc", experimental_agc);
     ost << ToStringIfSet("extended_filter_aec", extended_filter_aec);
     ost << ToStringIfSet("delay_agnostic_aec", delay_agnostic_aec);
     ost << ToStringIfSet("experimental_ns", experimental_ns);
     ost << ToStringIfSet("aec_dump", aec_dump);
     ost << ToStringIfSet("tx_agc_target_dbov", tx_agc_target_dbov);
     ost << ToStringIfSet("tx_agc_digital_compression_gain",
         tx_agc_digital_compression_gain);
     ost << ToStringIfSet("tx_agc_limiter", tx_agc_limiter);
@@ skipping 15 matching lines @@
   rtc::Optional<bool> highpass_filter;
   // Audio processing to swap the left and right channels.
   rtc::Optional<bool> stereo_swapping;
   // Audio receiver jitter buffer (NetEq) max capacity in number of packets.
   rtc::Optional<int> audio_jitter_buffer_max_packets;
   // Audio receiver jitter buffer (NetEq) fast accelerate mode.
   rtc::Optional<bool> audio_jitter_buffer_fast_accelerate;
   // Audio processing to detect typing.
   rtc::Optional<bool> typing_detection;
   rtc::Optional<bool> aecm_generate_comfort_noise;
-  rtc::Optional<bool> conference_mode;
   rtc::Optional<int> adjust_agc_delta;
   rtc::Optional<bool> experimental_agc;
   rtc::Optional<bool> extended_filter_aec;
   rtc::Optional<bool> delay_agnostic_aec;
   rtc::Optional<bool> experimental_ns;
   rtc::Optional<bool> aec_dump;
   // Note that tx_agc_* only applies to non-experimental AGC.
   rtc::Optional<uint16_t> tx_agc_target_dbov;
   rtc::Optional<uint16_t> tx_agc_digital_compression_gain;
   rtc::Optional<bool> tx_agc_limiter;
@@ skipping 14 matching lines @@
   }
 };
 
 // Options that can be applied to a VideoMediaChannel or a VideoMediaEngine.
 // Used to be flags, but that makes it hard to selectively apply options.
 // We are moving all of the setting of options to structs like this,
 // but some things currently still use flags.
 struct VideoOptions {
   void SetAll(const VideoOptions& change) {
     SetFrom(&video_noise_reduction, change.video_noise_reduction);
-    SetFrom(&conference_mode, change.conference_mode);
     SetFrom(&suspend_below_min_bitrate, change.suspend_below_min_bitrate);
     SetFrom(&screencast_min_bitrate_kbps, change.screencast_min_bitrate_kbps);
   }
 
   bool operator==(const VideoOptions& o) const {
     return video_noise_reduction == o.video_noise_reduction &&
-           conference_mode == o.conference_mode &&
            suspend_below_min_bitrate == o.suspend_below_min_bitrate &&
            screencast_min_bitrate_kbps == o.screencast_min_bitrate_kbps;
   }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "VideoOptions {";
     ost << ToStringIfSet("noise reduction", video_noise_reduction);
-    ost << ToStringIfSet("conference mode", conference_mode);
     ost << ToStringIfSet("suspend below min bitrate",
                          suspend_below_min_bitrate);
     ost << ToStringIfSet("screencast min bitrate kbps",
                          screencast_min_bitrate_kbps);
     ost << "}";
     return ost.str();
   }
 
   // Enable denoising? This flag comes from the getUserMedia
   // constraint 'googNoiseReduction', and WebRtcVideoEngine2 passes it
   // on to the codec options. Disabled by default.
   rtc::Optional<bool> video_noise_reduction;
-  // Use conference mode? This flag comes from the remote
-  // description's SDP line 'a=x-google-flag:conference', copied over
-  // by VideoChannel::SetRemoteContent_w, and ultimately used by
-  // conference mode screencast logic in
-  // WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig.
-  // The special screencast behaviour is disabled by default.
-  rtc::Optional<bool> conference_mode;
   // Enable WebRTC suspension of video. No video frames will be sent
   // when the bitrate is below the configured minimum bitrate. This
   // flag comes from the PeerConnection constraint
   // 'googSuspendBelowMinBitrate', and WebRtcVideoChannel2 copies it
   // to VideoSendStream::Config::suspend_below_min_bitrate.
   rtc::Optional<bool> suspend_below_min_bitrate;
   // Force screencast to use a minimum bitrate. This flag comes from
   // the PeerConnection constraint 'googScreencastMinBitrate'. It is
   // copied to the encoder config by WebRtcVideoChannel2.
   rtc::Optional<int> screencast_min_bitrate_kbps;
@@ skipping 634 matching lines @@
   virtual bool InsertDtmf(uint32_t ssrc, int event, int duration) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VoiceMediaInfo* info) = 0;
 
   virtual void SetRawAudioSink(
       uint32_t ssrc,
       rtc::scoped_ptr<webrtc::AudioSinkInterface> sink) = 0;
 };
 
 struct VideoSendParameters : RtpSendParameters<VideoCodec, VideoOptions> {
+  // Use conference mode? This flag comes from the remote
+  // description's SDP line 'a=x-google-flag:conference', copied over
+  // by VideoChannel::SetRemoteContent_w, and ultimately used by
+  // conference mode screencast logic in
+  // WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig.
+  // The special screencast behaviour is disabled by default.
+  bool conference_mode = false;
 };
 
 struct VideoRecvParameters : RtpParameters<VideoCodec> {
 };
 
 class VideoMediaChannel : public MediaChannel {
  public:
   enum Error {
     ERROR_NONE = 0,                       // No error.
     ERROR_OTHER,                          // Other errors.
@@ skipping 155 matching lines @@
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
   sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_MEDIACHANNEL_H_