- Rename VoiceChannel::MuteStream() -> SetAudioSend() (incl. media channel)

talk/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 119 matching lines @@
     if (std::find(receive_streams_.begin(), receive_streams_.end(), sp) !=
         receive_streams_.end()) {
       return false;
     }
     receive_streams_.push_back(sp);
     return true;
   }
   virtual bool RemoveRecvStream(uint32 ssrc) {
     return RemoveStreamBySsrc(&receive_streams_, ssrc);
   }
-  virtual bool MuteStream(uint32 ssrc, bool on) {
-    if (!HasSendStream(ssrc) && ssrc != 0)
-      return false;
-    if (on)
-      muted_streams_.insert(ssrc);
-    else
-      muted_streams_.erase(ssrc);
-    return true;
-  }
   bool IsStreamMuted(uint32 ssrc) const {
     bool ret = muted_streams_.find(ssrc) != muted_streams_.end();
     // If |ssrc = 0| check if the first send stream is muted.
     if (!ret && ssrc == 0 && !send_streams_.empty()) {
       return muted_streams_.find(send_streams_[0].first_ssrc()) !=
              muted_streams_.end();
     }
     return ret;
   }
   const std::vector<StreamParams>& send_streams() const {
@@ skipping 22 matching lines @@
     if (send_streams_.empty())
       return "";
     return send_streams_[0].cname;
   }
 
   bool ready_to_send() const {
     return ready_to_send_;
   }
 
  protected:
+  bool MuteStream(uint32 ssrc, bool mute) {
+    if (!HasSendStream(ssrc) && ssrc != 0)
+      return false;
+    if (mute)
+      muted_streams_.insert(ssrc);
+    else
+      muted_streams_.erase(ssrc);
+    return true;
+  }
   bool set_sending(bool send) {
     sending_ = send;
     return true;
   }
   void set_playout(bool playout) { playout_ = playout; }
   virtual void OnPacketReceived(rtc::Buffer* packet,
                                 const rtc::PacketTime& packet_time) {
     rtp_packets_.push_back(std::string(packet->data<char>(), packet->size()));
   }
   virtual void OnRtcpReceived(rtc::Buffer* packet,
@@ skipping 75 matching lines @@
   virtual bool SetPlayout(bool playout) {
     set_playout(playout);
     return true;
   }
   virtual bool SetSend(SendFlags flag) {
     if (fail_set_send_) {
       return false;
     }
     return set_sending(flag != SEND_NOTHING);
   }
+  virtual bool SetAudioSend(uint32 ssrc, bool mute,
+                            const AudioOptions* options,
+                            AudioRenderer* renderer) {
+    if (!SetLocalRenderer(ssrc, renderer)) {
+      return false;
+    }
+    if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, mute)) {
+      return false;
+    }
+    if (!mute && options) {
+      return SetOptions(*options);
+    }
+    return true;
+  }
   virtual bool SetMaxSendBandwidth(int bps) { return true; }
   virtual bool AddRecvStream(const StreamParams& sp) {
     if (!RtpHelper<VoiceMediaChannel>::AddRecvStream(sp))
       return false;
     output_scalings_[sp.first_ssrc()] = OutputScaling();
     return true;
   }
   virtual bool RemoveRecvStream(uint32 ssrc) {
     if (!RtpHelper<VoiceMediaChannel>::RemoveRecvStream(ssrc))
       return false;
@@ skipping 13 matching lines @@
     } else {
       if (it != remote_renderers_.end()) {
         it->second->RemoveChannel(0);
         remote_renderers_.erase(it);
       } else {
         return false;
       }
     }
     return true;
   }
-  virtual bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) {
-    std::map<uint32, VoiceChannelAudioSink*>::iterator it =
-        local_renderers_.find(ssrc);
-    if (renderer) {
-      if (it != local_renderers_.end()) {
-        ASSERT(it->second->renderer() == renderer);
-      } else {
-        local_renderers_.insert(std::make_pair(
-            ssrc, new VoiceChannelAudioSink(renderer)));
-      }
-    } else {
-      if (it != local_renderers_.end()) {
-        delete it->second;
-        local_renderers_.erase(it);
-      } else {
-        return false;
-      }
-    }
-    return true;
-  }
 
   virtual bool GetActiveStreams(AudioInfo::StreamList* streams) { return true; }
   virtual int GetOutputLevel() { return 0; }
   void set_time_since_last_typing(int ms) { time_since_last_typing_ = ms; }
   virtual int GetTimeSinceLastTyping() { return time_since_last_typing_; }
   virtual void SetTypingDetectionParameters(
       int time_window, int cost_per_typing, int reporting_threshold,
       int penalty_decay, int type_event_delay) {}
 
   virtual bool SetRingbackTone(const char* buf, int len) { return true; }
@@ skipping 86 matching lines @@
                 int sample_rate,
                 int number_of_channels,
                 size_t number_of_frames) override {}
     void OnClose() override { renderer_ = NULL; }
     AudioRenderer* renderer() const { return renderer_; }
 
    private:
     AudioRenderer* renderer_;
   };
 
+  bool SetLocalRenderer(uint32 ssrc, AudioRenderer* renderer) {
+    auto it = local_renderers_.find(ssrc);
+    if (renderer) {
+      if (it != local_renderers_.end()) {
+        ASSERT(it->second->renderer() == renderer);
+      } else {
+        local_renderers_.insert(std::make_pair(
+            ssrc, new VoiceChannelAudioSink(renderer)));
+      }
+    } else {
+      if (it != local_renderers_.end()) {
+        delete it->second;
+        local_renderers_.erase(it);
+      }
+    }
+    return true;
+  }
 
   FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
   std::map<uint32, OutputScaling> output_scalings_;
   std::vector<DtmfInfo> dtmf_info_queue_;
   bool fail_set_send_;
   uint32 ringback_tone_ssrc_;
   bool ringback_tone_play_;
   bool ringback_tone_loop_;
@@ skipping 94 matching lines @@
     if (ssrc != 0 && renderers_.find(ssrc) == renderers_.end()) {
       return false;
     }
     if (ssrc != 0) {
       renderers_[ssrc] = r;
     }
     return true;
   }
 
   virtual bool SetSend(bool send) { return set_sending(send); }
+  virtual bool SetVideoSend(uint32 ssrc, bool mute,
+                            const VideoOptions* options) {
+    if (!RtpHelper<VideoMediaChannel>::MuteStream(ssrc, mute)) {
+      return false;
+    }
+    if (!mute && options) {
+      return SetOptions(*options);
+    } else {
+      return true;
+    }
+  }
   virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) {
     capturers_[ssrc] = capturer;
     return true;
   }
   bool HasCapturer(uint32 ssrc) const {
     return capturers_.find(ssrc) != capturers_.end();
   }
   virtual bool SetMaxSendBandwidth(int bps) {
     max_bps_ = bps;
     return true;
@@ skipping 468 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_FAKEMEDIAENGINE_H_