Removed calls to VoE::SetPlayout() from WebRTCVoiceEngine.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  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 1345 matching lines @@
   void SetRawAudioSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     stream_->SetSink(std::move(sink));
   }
 
   void SetOutputVolume(double volume) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     stream_->SetGain(volume);
   }
 
+  void SetPlayout(bool playout) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(stream_);
+    if (playout) {
+      LOG(LS_INFO) << "Starting playout for channel #" << channel();
+      stream_->Start();
+    } else {
+      LOG(LS_INFO) << "Stopping playout for channel #" << channel();
+      stream_->Stop();
+    }
+  }
+
  private:
   void RecreateAudioReceiveStream(
       uint32_t local_ssrc,
       bool use_transport_cc,
       bool use_nack,
       const std::vector<webrtc::RtpExtension>& extensions) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioReceiveStream(stream_);
       stream_ = nullptr;
@@ skipping 259 matching lines @@
   }
   if (new_codecs.empty()) {
     // There are no new codecs to configure. Already configured codecs are
     // never removed.
     return true;
   }
 
   if (playout_) {
     // Receive codecs can not be changed while playing. So we temporarily
     // pause playout.
-    PausePlayout();
+    ChangePlayout(false);
   }
 
   bool result = true;
   for (const AudioCodec& codec : new_codecs) {
     webrtc::CodecInst voe_codec = {0};
     if (WebRtcVoiceEngine::ToCodecInst(codec, &voe_codec)) {
       LOG(LS_INFO) << ToString(codec);
       voe_codec.pltype = codec.id;
       for (const auto& ch : recv_streams_) {
         if (engine()->voe()->codec()->SetRecPayloadType(
                 ch.second->channel(), voe_codec) == -1) {
           LOG_RTCERR2(SetRecPayloadType, ch.second->channel(),
                       ToString(voe_codec));
           result = false;
         }
       }
     } else {
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       result = false;
       break;
     }
   }
   if (result) {
     recv_codecs_ = codecs;
   }
 
   if (desired_playout_ && !playout_) {
-    ResumePlayout();
+    ChangePlayout(desired_playout_);
   }
   return result;
 }
 
 // Utility function called from SetSendParameters() to extract current send
 // codec settings from the given list of codecs (originally from SDP). Both send
 // and receive streams may be reconfigured based on the new settings.
 bool WebRtcVoiceMediaChannel::SetSendCodecs(
     const std::vector<AudioCodec>& codecs) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
@@ skipping 234 matching lines @@
     return true;
   }
 
   if (engine()->voe()->codec()->SetSendCodec(channel, send_codec) == -1) {
     LOG_RTCERR2(SetSendCodec, channel, ToString(send_codec));
     return false;
   }
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetPlayout(bool playout) {
+void WebRtcVoiceMediaChannel::SetPlayout(bool playout) {
   desired_playout_ = playout;
   return ChangePlayout(desired_playout_);
 }
 
-bool WebRtcVoiceMediaChannel::PausePlayout() {
-  return ChangePlayout(false);
-}
-
-bool WebRtcVoiceMediaChannel::ResumePlayout() {
-  return ChangePlayout(desired_playout_);
-}
-
-bool WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
+void WebRtcVoiceMediaChannel::ChangePlayout(bool playout) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::ChangePlayout");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   if (playout_ == playout) {
-    return true;
+    return;
   }
 
-  for (const auto& ch : recv_streams_) {
-    if (!SetPlayout(ch.second->channel(), playout)) {
-      LOG(LS_ERROR) << "SetPlayout " << playout << " on channel "
-                    << ch.second->channel() << " failed";
-      return false;
-    }
+  for (const auto& kv : recv_streams_) {
+    kv.second->SetPlayout(playout);
   }
   playout_ = playout;
-  return true;
 }
 
 void WebRtcVoiceMediaChannel::SetSend(bool send) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetSend");
   if (send_ == send) {
     return;
   }
 
   // Apply channel specific options, and initialize the ADM for recording (this
   // may take time on some platforms, e.g. Android).
@@ skipping 206 matching lines @@
                  << " is associated with channel #" << send_channel << ".";
   }
 
   recv_streams_.insert(std::make_pair(
       ssrc, new WebRtcAudioReceiveStream(channel, ssrc, receiver_reports_ssrc_,
                                          recv_transport_cc_enabled_,
                                          recv_nack_enabled_,
                                          sp.sync_label, recv_rtp_extensions_,
                                          call_, this,
                                          engine()->decoder_factory_)));
-  SetPlayout(channel, playout_);
+  recv_streams_[ssrc]->SetPlayout(playout_);
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::RemoveRecvStream");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "RemoveRecvStream: " << ssrc;
 
   const auto it = recv_streams_.find(ssrc);
@@ skipping 413 matching lines @@
 }
 
 int WebRtcVoiceMediaChannel::GetSendChannelId(uint32_t ssrc) const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
-
-bool WebRtcVoiceMediaChannel::SetPlayout(int channel, bool playout) {
-  if (playout) {
-    LOG(LS_INFO) << "Starting playout for channel #" << channel;
-    if (engine()->voe()->base()->StartPlayout(channel) == -1) {
-      LOG_RTCERR1(StartPlayout, channel);
-      return false;
-    }
-  } else {
-    LOG(LS_INFO) << "Stopping playout for channel #" << channel;
-    engine()->voe()->base()->StopPlayout(channel);
-  }
-  return true;
-}
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE