Split out dscp option from VideoOptions to new struct MediaChannelOptions.

webrtc/media/base/fakemediaengine.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 34 matching lines @@
 
 namespace cricket {
 
 class FakeMediaEngine;
 class FakeVideoEngine;
 class FakeVoiceEngine;
 
 // A common helper class that handles sending and receiving RTP/RTCP packets.
 template <class Base> class RtpHelper : public Base {
  public:
-  RtpHelper()
-      : sending_(false),
+  RtpHelper(const MediaChannelOptions& options)
+      : Base(options),
+        sending_(false),
         playout_(false),
         fail_set_send_codecs_(false),
         fail_set_recv_codecs_(false),
         send_ssrc_(0),
         ready_to_send_(false) {}
   const std::vector<RtpHeaderExtension>& recv_extensions() {
     return recv_extensions_;
   }
   const std::vector<RtpHeaderExtension>& send_extensions() {
     return send_extensions_;
@@ skipping 165 matching lines @@
   struct DtmfInfo {
     DtmfInfo(uint32_t ssrc, int event_code, int duration)
         : ssrc(ssrc),
           event_code(event_code),
           duration(duration) {}
     uint32_t ssrc;
     int event_code;
     int duration;
   };
   explicit FakeVoiceMediaChannel(FakeVoiceEngine* engine,
-                                 const AudioOptions& options)
-      : engine_(engine),
+                                 const MediaChannelOptions& options,
+                                 const AudioOptions& audio_options)
+      : RtpHelper<VoiceMediaChannel>(options),
+        engine_(engine),
         time_since_last_typing_(-1) {
     output_scalings_[0] = 1.0;  // For default channel.
-    SetOptions(options);
+    SetOptions(audio_options);
   }
   ~FakeVoiceMediaChannel();
+  // TODO(nisse): Move to the VoiceMediaChannel base class? Currently
+  // duplicated in WebRtcVoiceMediaChannel.
+  rtc::DiffServCodePoint MediaTypeDscpValue() const override {
+    return rtc::DSCP_EF;
+  }
+
   const std::vector<AudioCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<AudioCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<AudioCodec>& codecs() const { return send_codecs(); }
   const std::vector<DtmfInfo>& dtmf_info_queue() const {
     return dtmf_info_queue_;
   }
   const AudioOptions& options() const { return options_; }
 
   virtual bool SetSendParameters(const AudioSendParameters& params) {
     return (SetSendCodecs(params.codecs) &&
@@ skipping 174 matching lines @@
                             uint32_t ssrc,
                             int event_code,
                             int duration) {
   return (info.duration == duration && info.event_code == event_code &&
           info.ssrc == ssrc);
 }
 
 class FakeVideoMediaChannel : public RtpHelper<VideoMediaChannel> {
  public:
   explicit FakeVideoMediaChannel(FakeVideoEngine* engine,
-                                 const VideoOptions& options)
-      : engine_(engine), max_bps_(-1) {
-    SetOptions(options);
+                                 const MediaChannelOptions& options,
+                                 const VideoOptions& video_options)
+      : RtpHelper<VideoMediaChannel>(options),
+        engine_(engine),
+        max_bps_(-1) {
+    SetOptions(video_options);
   }
 
   ~FakeVideoMediaChannel();
-
+  // TODO(nisse): Move to the VideoMediaChannel base class? Currently
+  // duplicated in WebRtcVideoChannel2.
+  rtc::DiffServCodePoint MediaTypeDscpValue() const override {
+    return rtc::DSCP_AF41;
+  }
   const std::vector<VideoCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<VideoCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<VideoCodec>& codecs() const { return send_codecs(); }
   bool rendering() const { return playout(); }
   const VideoOptions& options() const { return options_; }
   const std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*>& sinks()
       const {
     return sinks_;
   }
   int max_bps() const { return max_bps_; }
@@ skipping 97 matching lines @@
   std::vector<VideoCodec> recv_codecs_;
   std::vector<VideoCodec> send_codecs_;
   std::map<uint32_t, rtc::VideoSinkInterface<VideoFrame>*> sinks_;
   std::map<uint32_t, VideoCapturer*> capturers_;
   VideoOptions options_;
   int max_bps_;
 };
 
 class FakeDataMediaChannel : public RtpHelper<DataMediaChannel> {
  public:
-  explicit FakeDataMediaChannel(void* unused, const DataOptions& options)
-      : send_blocked_(false), max_bps_(-1) {}
+  explicit FakeDataMediaChannel(void* unused,
+                                const MediaChannelOptions& options,
+                                const DataOptions& data_options)
+      : RtpHelper<DataMediaChannel>(options),
+        send_blocked_(false), max_bps_(-1) {}
   ~FakeDataMediaChannel() {}
   const std::vector<DataCodec>& recv_codecs() const { return recv_codecs_; }
   const std::vector<DataCodec>& send_codecs() const { return send_codecs_; }
   const std::vector<DataCodec>& codecs() const { return send_codecs(); }
   int max_bps() const { return max_bps_; }
 
   virtual bool SetSendParameters(const DataSendParameters& params) {
     return (SetSendCodecs(params.codecs) &&
             SetMaxSendBandwidth(params.max_bandwidth_bps));
   }
@@ skipping 96 matching lines @@
     // sanity checks against that.
     codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1, 0));
   }
   bool Init(rtc::Thread* worker_thread) { return true; }
   void Terminate() {}
   rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const {
     return rtc::scoped_refptr<webrtc::AudioState>();
   }
 
   VoiceMediaChannel* CreateChannel(webrtc::Call* call,
-                                   const AudioOptions& options) {
+                                   const MediaChannelOptions& options,
+                                   const AudioOptions& audio_options) {
     if (fail_create_channel_) {
       return nullptr;
     }
 
-    FakeVoiceMediaChannel* ch = new FakeVoiceMediaChannel(this, options);
+    FakeVoiceMediaChannel* ch =
+        new FakeVoiceMediaChannel(this, options, audio_options);
     channels_.push_back(ch);
     return ch;
   }
   FakeVoiceMediaChannel* GetChannel(size_t index) {
     return (channels_.size() > index) ? channels_[index] : NULL;
   }
   void UnregisterChannel(VoiceMediaChannel* channel) {
     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
   }
 
@@ skipping 37 matching lines @@
     codecs_.push_back(VideoCodec(0, "fake_video_codec", 0, 0, 0, 0));
   }
   void Init() {}
   bool SetOptions(const VideoOptions& options) {
     options_ = options;
     options_changed_ = true;
     return true;
   }
 
   VideoMediaChannel* CreateChannel(webrtc::Call* call,
-                                   const VideoOptions& options) {
+                                   const MediaChannelOptions& options,
+                                   const VideoOptions& video_options) {
     if (fail_create_channel_) {
       return NULL;
     }
 
-    FakeVideoMediaChannel* ch = new FakeVideoMediaChannel(this, options);
+    FakeVideoMediaChannel* ch =
+        new FakeVideoMediaChannel(this, options, video_options);
     channels_.push_back(ch);
     return ch;
   }
   FakeVideoMediaChannel* GetChannel(size_t index) {
     return (channels_.size() > index) ? channels_[index] : NULL;
   }
   void UnregisterChannel(VideoMediaChannel* channel) {
     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
   }
 
@@ skipping 89 matching lines @@
     engine_->UnregisterChannel(this);
   }
 }
 
 class FakeDataEngine : public DataEngineInterface {
  public:
   FakeDataEngine() : last_channel_type_(DCT_NONE) {}
 
   virtual DataMediaChannel* CreateChannel(DataChannelType data_channel_type) {
     last_channel_type_ = data_channel_type;
-    FakeDataMediaChannel* ch = new FakeDataMediaChannel(this, DataOptions());
+    FakeDataMediaChannel* ch =
+        new FakeDataMediaChannel(this, MediaChannelOptions(), DataOptions());
     channels_.push_back(ch);
     return ch;
   }
 
   FakeDataMediaChannel* GetChannel(size_t index) {
     return (channels_.size() > index) ? channels_[index] : NULL;
   }
 
   void UnregisterChannel(DataMediaChannel* channel) {
     channels_.erase(std::find(channels_.begin(), channels_.end(), channel));
   }
 
   virtual void SetDataCodecs(const std::vector<DataCodec>& data_codecs) {
     data_codecs_ = data_codecs;
   }
 
   virtual const std::vector<DataCodec>& data_codecs() { return data_codecs_; }
 
   DataChannelType last_channel_type() const { return last_channel_type_; }
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_