Refactor the relationship between BaseChannel and MediaChannel so that we send over all the paramet…

talk/media/base/mediachannel.h

 /*
  * libjingle
  * Copyright 2004 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 120 matching lines @@
   std::string str;
   if (val.IsSet()) {
     str = key;
     str += ": ";
     str += val.ToString();
     str += ", ";
   }
   return str;
 }
 
+template <class T>
+static std::string VectorToString(const std::vector<T>& vals) {
+    std::ostringstream ost;
+    ost << "[";
+    for (const T& val : vals) {
+      ost << val.ToString() << ",";

[pbos-webrtc, 2015/07/16 14:46:47]

Don't add "," to end of string. Also should this be declared more locally
(further down) ?

[pthatcher1, 2015/07/16 22:48:00]

Done.

+    }
+    ost << "]";
+    return ost.str();
+}
+
 // Options that can be applied to a VoiceMediaChannel or a VoiceMediaEngine.
 // 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 AudioOptions {
   void SetAll(const AudioOptions& change) {
     echo_cancellation.SetFrom(change.echo_cancellation);
     auto_gain_control.SetFrom(change.auto_gain_control);
     rx_auto_gain_control.SetFrom(change.rx_auto_gain_control);
     noise_suppression.SetFrom(change.noise_suppression);
@@ skipping 169 matching lines @@
         change.cpu_underuse_encode_rsd_threshold);
     cpu_overuse_encode_rsd_threshold.SetFrom(
         change.cpu_overuse_encode_rsd_threshold);
     cpu_overuse_encode_usage.SetFrom(change.cpu_overuse_encode_usage);
     conference_mode.SetFrom(change.conference_mode);
     process_adaptation_threshhold.SetFrom(change.process_adaptation_threshhold);
     system_low_adaptation_threshhold.SetFrom(
         change.system_low_adaptation_threshhold);
     system_high_adaptation_threshhold.SetFrom(
         change.system_high_adaptation_threshhold);
-    buffered_mode_latency.SetFrom(change.buffered_mode_latency);
     dscp.SetFrom(change.dscp);
     suspend_below_min_bitrate.SetFrom(change.suspend_below_min_bitrate);
     unsignalled_recv_stream_limit.SetFrom(change.unsignalled_recv_stream_limit);
     use_simulcast_adapter.SetFrom(change.use_simulcast_adapter);
     screencast_min_bitrate.SetFrom(change.screencast_min_bitrate);
   }
 
   bool operator==(const VideoOptions& o) const {
     return adapt_input_to_cpu_usage == o.adapt_input_to_cpu_usage &&
            adapt_cpu_with_smoothing == o.adapt_cpu_with_smoothing &&
            video_adapt_third == o.video_adapt_third &&
            video_noise_reduction == o.video_noise_reduction &&
            video_start_bitrate == o.video_start_bitrate &&
            video_highest_bitrate == o.video_highest_bitrate &&
            cpu_overuse_detection == o.cpu_overuse_detection &&
            cpu_underuse_threshold == o.cpu_underuse_threshold &&
            cpu_overuse_threshold == o.cpu_overuse_threshold &&
            cpu_underuse_encode_rsd_threshold ==
                o.cpu_underuse_encode_rsd_threshold &&
            cpu_overuse_encode_rsd_threshold ==
                o.cpu_overuse_encode_rsd_threshold &&
            cpu_overuse_encode_usage == o.cpu_overuse_encode_usage &&
            conference_mode == o.conference_mode &&
            process_adaptation_threshhold == o.process_adaptation_threshhold &&
            system_low_adaptation_threshhold ==
                o.system_low_adaptation_threshhold &&
            system_high_adaptation_threshhold ==
                o.system_high_adaptation_threshhold &&
-           buffered_mode_latency == o.buffered_mode_latency && dscp == o.dscp &&
+           dscp == o.dscp &&
            suspend_below_min_bitrate == o.suspend_below_min_bitrate &&
            unsignalled_recv_stream_limit == o.unsignalled_recv_stream_limit &&
            use_simulcast_adapter == o.use_simulcast_adapter &&
            screencast_min_bitrate == o.screencast_min_bitrate;
   }
 
   std::string ToString() const {
     std::ostringstream ost;
     ost << "VideoOptions {";
     ost << ToStringIfSet("cpu adaption", adapt_input_to_cpu_usage);
     ost << ToStringIfSet("cpu adaptation smoothing", adapt_cpu_with_smoothing);
     ost << ToStringIfSet("video adapt third", video_adapt_third);
     ost << ToStringIfSet("noise reduction", video_noise_reduction);
     ost << ToStringIfSet("start bitrate", video_start_bitrate);
     ost << ToStringIfSet("highest video bitrate", video_highest_bitrate);
     ost << ToStringIfSet("cpu overuse detection", cpu_overuse_detection);
     ost << ToStringIfSet("cpu underuse threshold", cpu_underuse_threshold);
     ost << ToStringIfSet("cpu overuse threshold", cpu_overuse_threshold);
     ost << ToStringIfSet("cpu underuse encode rsd threshold",
                          cpu_underuse_encode_rsd_threshold);
     ost << ToStringIfSet("cpu overuse encode rsd threshold",
                          cpu_overuse_encode_rsd_threshold);
     ost << ToStringIfSet("cpu overuse encode usage",
                          cpu_overuse_encode_usage);
     ost << ToStringIfSet("conference mode", conference_mode);
     ost << ToStringIfSet("process", process_adaptation_threshhold);
     ost << ToStringIfSet("low", system_low_adaptation_threshhold);
     ost << ToStringIfSet("high", system_high_adaptation_threshhold);
-    ost << ToStringIfSet("buffered mode latency", buffered_mode_latency);
     ost << ToStringIfSet("dscp", dscp);
     ost << ToStringIfSet("suspend below min bitrate",
                          suspend_below_min_bitrate);
     ost << ToStringIfSet("num channels for early receive",
                          unsignalled_recv_stream_limit);
     ost << ToStringIfSet("use simulcast adapter", use_simulcast_adapter);
     ost << ToStringIfSet("screencast min bitrate", screencast_min_bitrate);
     ost << "}";
     return ost.str();
   }
@@ skipping 33 matching lines @@
   // Use encode usage for cpu detection.
   Settable<bool> cpu_overuse_encode_usage;
   // Use conference mode?
   Settable<bool> conference_mode;
   // Threshhold for process cpu adaptation.  (Process limit)
   Settable<float> process_adaptation_threshhold;
   // Low threshhold for cpu adaptation.  (Adapt up)
   Settable<float> system_low_adaptation_threshhold;
   // High threshhold for cpu adaptation.  (Adapt down)
   Settable<float> system_high_adaptation_threshhold;
-  // Specify buffered mode latency in milliseconds.
-  Settable<int> buffered_mode_latency;
   // Set DSCP value for packet sent from video channel.
   Settable<bool> dscp;
   // Enable WebRTC suspension of video. No video frames will be sent when the
   // bitrate is below the configured minimum bitrate.
   Settable<bool> suspend_below_min_bitrate;
   // Limit on the number of early receive channels that can be created.
   Settable<int> unsignalled_recv_stream_limit;
   // Enable use of simulcast adapter.
   Settable<bool> use_simulcast_adapter;
   // Force screencast to use a minimum bitrate
   Settable<int> screencast_min_bitrate;
 };
 
 struct RtpHeaderExtension {
   RtpHeaderExtension() : id(0) {}
   RtpHeaderExtension(const std::string& u, int i) : uri(u), id(i) {}
-  std::string uri;
-  int id;
-  // TODO(juberti): SendRecv direction;
 
   bool operator==(const RtpHeaderExtension& ext) const {
     // id is a reserved word in objective-c. Therefore the id attribute has to
     // be a fully qualified name in order to compile on IOS.
     return this->id == ext.id &&
         uri == ext.uri;
   }
+
+  std::string ToString() const {
+    std::ostringstream ost;
+    ost << "{";
+    ost << "id: , " << id;
+    ost << "uri: " << uri;
+    ost << "}";
+    return ost.str();
+  }
+
+  std::string uri;
+  int id;
+  // TODO(juberti): SendRecv direction;
 };
 
 // Returns the named header extension if found among all extensions, NULL
 // otherwise.
 inline const RtpHeaderExtension* FindHeaderExtension(
     const std::vector<RtpHeaderExtension>& extensions,
     const std::string& name) {
   for (std::vector<RtpHeaderExtension>::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     if (it->uri == name)
@@ skipping 502 matching lines @@
 
 struct DataMediaInfo {
   void Clear() {
     senders.clear();
     receivers.clear();
   }
   std::vector<DataSenderInfo> senders;
   std::vector<DataReceiverInfo> receivers;
 };
 
+template <class Codec>
+struct RtpParameters {

[pbos-webrtc, 2015/07/16 14:39:17]

This is part of another CL and shouldn't be landed with this CL, correct? Can
you rebase?

[pthatcher1, 2015/07/16 22:48:00]

Acknowledged.

+  virtual std::string ToString() {
+    std::ostringstream ost;
+    ost << "{";
+    ost << "codecs: " << VectorToString(codecs) << ", ";
+    ost << "extensions: " << VectorToString(extensions);
+    ost << "}";
+    return ost.str();
+  }
+
+  std::vector<Codec> codecs;
+  std::vector<RtpHeaderExtension> extensions;
+  // TODO(pthatcher): Add streams.
+};
+
+template <class Codec, class Options>
+struct RtpSendParameters : RtpParameters<Codec> {
+  std::string ToString() override {
+    std::ostringstream ost;
+    ost << "{";
+    ost << "codecs: " << VectorToString(this->codecs) << ", ";
+    ost << "extensions: " << VectorToString(this->extensions) << ", ";
+    ost << "max_bandiwidth_bps: " << max_bandwidth_bps << ", ";
+    ost << "options: " << options.ToString();
+    ost << "}";
+    return ost.str();
+  }
+
+  int max_bandwidth_bps = -1;
+  Options options;
+};
+
+struct AudioSendParameters : RtpSendParameters<AudioCodec, AudioOptions> {
+};
+
+struct AudioRecvParameters : RtpParameters<AudioCodec> {
+};
+
 class VoiceMediaChannel : public MediaChannel {
  public:
   enum Error {
     ERROR_NONE = 0,                       // No error.
     ERROR_OTHER,                          // Other errors.
     ERROR_REC_DEVICE_OPEN_FAILED = 100,   // Could not open mic.
     ERROR_REC_DEVICE_MUTED,               // Mic was muted by OS.
     ERROR_REC_DEVICE_SILENT,              // No background noise picked up.
     ERROR_REC_DEVICE_SATURATION,          // Mic input is clipping.
     ERROR_REC_DEVICE_REMOVED,             // Mic was removed while active.
     ERROR_REC_RUNTIME_ERROR,              // Processing is encountering errors.
     ERROR_REC_SRTP_ERROR,                 // Generic SRTP failure.
     ERROR_REC_SRTP_AUTH_FAILED,           // Failed to authenticate packets.
     ERROR_REC_TYPING_NOISE_DETECTED,      // Typing noise is detected.
     ERROR_PLAY_DEVICE_OPEN_FAILED = 200,  // Could not open playout.
     ERROR_PLAY_DEVICE_MUTED,              // Playout muted by OS.
     ERROR_PLAY_DEVICE_REMOVED,            // Playout removed while active.
     ERROR_PLAY_RUNTIME_ERROR,             // Errors in voice processing.
     ERROR_PLAY_SRTP_ERROR,                // Generic SRTP failure.
     ERROR_PLAY_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_PLAY_SRTP_REPLAY,               // Packet replay detected.
   };
 
   VoiceMediaChannel() {}
   virtual ~VoiceMediaChannel() {}
+  // TODO(pthatcher): Remove SetSendCodecs,
+  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
+  // once all implementations implement SetSendParameters.
+  virtual bool SetSendParameters(const AudioSendParameters& params) {
+    return (SetSendCodecs(params.codecs) &&
+            SetSendRtpHeaderExtensions(params.extensions) &&
+            SetMaxSendBandwidth(params.max_bandwidth_bps) &&
+            SetOptions(params.options));
+  }
+  // TODO(pthatcher): Remove SetRecvCodecs and
+  // SetRecvRtpHeaderExtensions once all implementations implement
+  // SetRecvParameters.
+  virtual bool SetRecvParameters(const AudioRecvParameters& params) {
+    return (SetRecvCodecs(params.codecs) &&
+            SetRecvRtpHeaderExtensions(params.extensions));
+  }
   // Sets the codecs/payload types to be used for incoming media.
   virtual bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) = 0;
   // Sets the codecs/payload types to be used for outgoing media.
   virtual bool SetSendCodecs(const std::vector<AudioCodec>& codecs) = 0;
   // Starts or stops playout of received audio.
   virtual bool SetPlayout(bool playout) = 0;
   // Starts or stops sending (and potentially capture) of local audio.
   virtual bool SetSend(SendFlags flag) = 0;
   // Sets the renderer object to be used for the specified remote audio stream.
   virtual bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) = 0;
@@ skipping 35 matching lines @@
   }
   // Sets the media options to use.
   virtual bool SetOptions(const AudioOptions& options) = 0;
   virtual bool GetOptions(AudioOptions* options) const = 0;
 
   // Signal errors from MediaChannel.  Arguments are:
   //     ssrc(uint32), and error(VoiceMediaChannel::Error).
   sigslot::signal2<uint32, VoiceMediaChannel::Error> SignalMediaError;
 };
 
+struct VideoSendParameters : RtpSendParameters<VideoCodec, VideoOptions> {
+};
+
+struct VideoRecvParameters : RtpParameters<VideoCodec> {
+};
+
 class VideoMediaChannel : public MediaChannel {
  public:
   enum Error {
     ERROR_NONE = 0,                       // No error.
     ERROR_OTHER,                          // Other errors.
     ERROR_REC_DEVICE_OPEN_FAILED = 100,   // Could not open camera.
     ERROR_REC_DEVICE_NO_DEVICE,           // No camera.
     ERROR_REC_DEVICE_IN_USE,              // Device is in already use.
     ERROR_REC_DEVICE_REMOVED,             // Device is removed.
     ERROR_REC_SRTP_ERROR,                 // Generic sender SRTP failure.
     ERROR_REC_SRTP_AUTH_FAILED,           // Failed to authenticate packets.
     ERROR_REC_CPU_MAX_CANT_DOWNGRADE,     // Can't downgrade capture anymore.
     ERROR_PLAY_SRTP_ERROR = 200,          // Generic receiver SRTP failure.
     ERROR_PLAY_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_PLAY_SRTP_REPLAY,               // Packet replay detected.
   };
 
   VideoMediaChannel() : renderer_(NULL) {}
   virtual ~VideoMediaChannel() {}
   // Allow video channel to unhook itself from an associated voice channel.
   virtual void DetachVoiceChannel() = 0;
+  // TODO(pthatcher): Remove SetSendCodecs,
+  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
+  // once all implementations implement SetSendParameters.
+  virtual bool SetSendParameters(const VideoSendParameters& params) {
+    return (SetSendCodecs(params.codecs) &&
+            SetSendRtpHeaderExtensions(params.extensions) &&
+            SetMaxSendBandwidth(params.max_bandwidth_bps) &&
+            SetOptions(params.options));
+  }
+  // TODO(pthatcher): Remove SetRecvCodecs and
+  // SetRecvRtpHeaderExtensions once all implementations implement
+  // SetRecvParameters.
+  virtual bool SetRecvParameters(const VideoRecvParameters& params) {
+    return (SetRecvCodecs(params.codecs) &&
+            SetRecvRtpHeaderExtensions(params.extensions));
+  }
   // Sets the codecs/payload types to be used for incoming media.
   virtual bool SetRecvCodecs(const std::vector<VideoCodec>& codecs) = 0;
   // Sets the codecs/payload types to be used for outgoing media.
   virtual bool SetSendCodecs(const std::vector<VideoCodec>& codecs) = 0;
   // Gets the currently set codecs/payload types to be used for outgoing media.
   virtual bool GetSendCodec(VideoCodec* send_codec) = 0;
   // Sets the format of a specified outgoing stream.
   virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) = 0;
   // Starts or stops playout of received video.
   virtual bool SetRender(bool render) = 0;
@@ skipping 83 matching lines @@
       // TODO(pthatcher): Make these true by default?
       ordered(false),
       reliable(false),
       max_rtx_count(0),
       max_rtx_ms(0) {
   }
 };
 
 enum SendDataResult { SDR_SUCCESS, SDR_ERROR, SDR_BLOCK };
 
+struct DataOptions {
+  std::string ToString() {
+    return "{}";
+  }
+};
+
+struct DataSendParameters : RtpSendParameters<DataCodec, DataOptions> {
+  std::string ToString() {
+    std::ostringstream ost;
+    // Options and extensions aren't used.
+    ost << "{";
+    ost << "codecs: " << VectorToString(codecs) << ", ";
+    ost << "max_bandiwidth_bps: " << max_bandwidth_bps;
+    ost << "}";
+    return ost.str();
+  }
+};
+
+struct DataRecvParameters : RtpParameters<DataCodec> {
+};
+
 class DataMediaChannel : public MediaChannel {
  public:
   enum Error {
     ERROR_NONE = 0,                       // No error.
     ERROR_OTHER,                          // Other errors.
     ERROR_SEND_SRTP_ERROR = 200,          // Generic SRTP failure.
     ERROR_SEND_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_RECV_SRTP_ERROR,                // Generic SRTP failure.
     ERROR_RECV_SRTP_AUTH_FAILED,          // Failed to authenticate packets.
     ERROR_RECV_SRTP_REPLAY,               // Packet replay detected.
   };
 
   virtual ~DataMediaChannel() {}
 
+  // TODO(pthatcher): Remove SetSendCodecs,
+  // SetSendRtpHeaderExtensions, SetMaxSendBandwidth, and SetOptions
+  // once all implementations implement SetSendParameters.
+  virtual bool SetSendParameters(const DataSendParameters& params) {
+    return (SetSendCodecs(params.codecs) &&
+            SetMaxSendBandwidth(params.max_bandwidth_bps));
+  }
+  // TODO(pthatcher): Remove SetRecvCodecs and
+  // SetRecvRtpHeaderExtensions once all implementations implement
+  // SetRecvParameters.
+  virtual bool SetRecvParameters(const DataRecvParameters& params) {
+    return SetRecvCodecs(params.codecs);
+  }
   virtual bool SetSendCodecs(const std::vector<DataCodec>& codecs) = 0;
   virtual bool SetRecvCodecs(const std::vector<DataCodec>& codecs) = 0;
 
   virtual bool MuteStream(uint32 ssrc, bool on) { return false; }
   // TODO(pthatcher): Implement this.
   virtual bool GetStats(DataMediaInfo* info) { return true; }
 
   virtual bool SetSend(bool send) = 0;
   virtual bool SetReceive(bool receive) = 0;
 
@@ skipping 11 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> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_