Prevent a voice channel from sending data before a renderer is set.

webrtc/media/base/fakemediaengine.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.
  */
 
 #ifndef WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_
 #define WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_
 
 #include <list>
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "webrtc/audio_sink.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/stringutils.h"
-#include "webrtc/media/base/audiorenderer.h"
+#include "webrtc/media/base/audiosource.h"
 #include "webrtc/media/base/mediaengine.h"
 #include "webrtc/media/base/rtputils.h"
 #include "webrtc/media/base/streamparams.h"
 #include "webrtc/p2p/base/sessiondescription.h"
 
 namespace cricket {
 
 class FakeMediaEngine;
 class FakeVideoEngine;
 class FakeVoiceEngine;
@@ skipping 217 matching lines @@
   virtual bool SetPlayout(bool playout) {
     set_playout(playout);
     return true;
   }
   virtual bool SetSend(SendFlags flag) {
     return set_sending(flag != SEND_NOTHING);
   }
   virtual bool SetAudioSend(uint32_t ssrc,
                             bool enable,
                             const AudioOptions* options,
-                            AudioRenderer* renderer) {
-    if (!SetLocalRenderer(ssrc, renderer)) {
+                            AudioSource* source) {
+    if (!SetLocalSource(ssrc, source)) {
       return false;
     }
     if (!RtpHelper<VoiceMediaChannel>::MuteStream(ssrc, !enable)) {
       return false;
     }
     if (enable && options) {
       return SetOptions(*options);
     }
     return true;
   }
@@ skipping 57 matching lines @@
 
   virtual bool GetStats(VoiceMediaInfo* info) { return false; }
 
   virtual void SetRawAudioSink(
       uint32_t ssrc,
       std::unique_ptr<webrtc::AudioSinkInterface> sink) {
     sink_ = std::move(sink);
   }
 
  private:
-  class VoiceChannelAudioSink : public AudioRenderer::Sink {
+  class VoiceChannelAudioSink : public AudioSource::Sink {
    public:
-    explicit VoiceChannelAudioSink(AudioRenderer* renderer)
-        : renderer_(renderer) {
-      renderer_->SetSink(this);
+    explicit VoiceChannelAudioSink(AudioSource* source) : source_(source) {
+      source_->SetSink(this);
     }
     virtual ~VoiceChannelAudioSink() {
-      if (renderer_) {
-        renderer_->SetSink(NULL);
+      if (source_) {
+        source_->SetSink(nullptr);
       }
     }
     void OnData(const void* audio_data,
                 int bits_per_sample,
                 int sample_rate,
                 size_t number_of_channels,
                 size_t number_of_frames) override {}
-    void OnClose() override { renderer_ = NULL; }
-    AudioRenderer* renderer() const { return renderer_; }
+    void OnClose() override { source_ = nullptr; }
+    AudioSource* source() const { return source_; }
 
    private:
-    AudioRenderer* renderer_;
+    AudioSource* source_;
   };
 
   bool SetRecvCodecs(const std::vector<AudioCodec>& codecs) {
     if (fail_set_recv_codecs()) {
       // Fake the failure in SetRecvCodecs.
       return false;
     }
     recv_codecs_ = codecs;
     return true;
   }
   bool SetSendCodecs(const std::vector<AudioCodec>& codecs) {
     if (fail_set_send_codecs()) {
       // Fake the failure in SetSendCodecs.
       return false;
     }
     send_codecs_ = codecs;
     return true;
   }
   bool SetMaxSendBandwidth(int bps) { return true; }
   bool SetOptions(const AudioOptions& options) {
     // Does a "merge" of current options and set options.
     options_.SetAll(options);
     return true;
   }
-  bool SetLocalRenderer(uint32_t ssrc, AudioRenderer* renderer) {
-    auto it = local_renderers_.find(ssrc);
-    if (renderer) {
-      if (it != local_renderers_.end()) {
-        ASSERT(it->second->renderer() == renderer);
+  bool SetLocalSource(uint32_t ssrc, AudioSource* source) {
+    auto it = local_sinks_.find(ssrc);
+    if (source) {
+      if (it != local_sinks_.end()) {
+        ASSERT(it->second->source() == source);
       } else {
-        local_renderers_.insert(std::make_pair(
-            ssrc, new VoiceChannelAudioSink(renderer)));
+        local_sinks_.insert(
+            std::make_pair(ssrc, new VoiceChannelAudioSink(source)));
       }
     } else {
-      if (it != local_renderers_.end()) {
+      if (it != local_sinks_.end()) {
         delete it->second;
-        local_renderers_.erase(it);
+        local_sinks_.erase(it);
       }
     }
     return true;
   }
 
   FakeVoiceEngine* engine_;
   std::vector<AudioCodec> recv_codecs_;
   std::vector<AudioCodec> send_codecs_;
   std::map<uint32_t, double> output_scalings_;
   std::vector<DtmfInfo> dtmf_info_queue_;
   int time_since_last_typing_;
   AudioOptions options_;
-  std::map<uint32_t, VoiceChannelAudioSink*> local_renderers_;
+  std::map<uint32_t, VoiceChannelAudioSink*> local_sinks_;
   std::unique_ptr<webrtc::AudioSinkInterface> sink_;
 };
 
 // A helper function to compare the FakeVoiceMediaChannel::DtmfInfo.
 inline bool CompareDtmfInfo(const FakeVoiceMediaChannel::DtmfInfo& info,
                             uint32_t ssrc,
                             int event_code,
                             int duration) {
   return (info.duration == duration && info.event_code == event_code &&
           info.ssrc == ssrc);
@@ skipping 447 matching lines @@
 
  private:
   std::vector<FakeDataMediaChannel*> channels_;
   std::vector<DataCodec> data_codecs_;
   DataChannelType last_channel_type_;
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_BASE_FAKEMEDIAENGINE_H_