Add AudioSendStream::SetMuted() method and use it in WVoMC::MuteStream().

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 1129 matching lines @@
     RTC_DCHECK(stream_);
     return stream_->SendTelephoneEvent(payload_type, event, duration_ms);
   }
 
   void SetSend(bool send) {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     send_ = send;
     UpdateSendState();
   }
 
+  void SetMuted(bool muted) {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(stream_);
+    stream_->SetMuted(muted);
+    muted_ = muted;
+  }
+
+  bool muted() const {
+    RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
+    return muted_;
+  }
+
   webrtc::AudioSendStream::Stats GetStats() const {
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(stream_);
     return stream_->GetStats();
   }
 
   // Starts the sending by setting ourselves as a sink to the AudioSource to
   // get data callbacks.
   // This method is called on the libjingle worker thread.
   // TODO(xians): Make sure Start() is called only once.
@@ skipping 85 matching lines @@
   webrtc::AudioSendStream::Config config_;
   // The stream is owned by WebRtcAudioSendStream and may be reallocated if
   // configuration changes.
   webrtc::AudioSendStream* stream_ = nullptr;
 
   // Raw pointer to AudioSource owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioSource* source_ = nullptr;
   bool send_ = false;
+  bool muted_ = false;
   webrtc::RtpParameters rtp_parameters_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioSendStream);
 };
 
 class WebRtcVoiceMediaChannel::WebRtcAudioReceiveStream {
  public:
   WebRtcAudioReceiveStream(
       int ch,
       uint32_t remote_ssrc,
@@ skipping 1091 matching lines @@
 }
 
 void WebRtcVoiceMediaChannel::OnNetworkRouteChanged(
     const std::string& transport_name,
     const rtc::NetworkRoute& network_route) {
   call_->OnNetworkRouteChanged(transport_name, network_route);
 }
 
 bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  int channel = GetSendChannelId(ssrc);
-  if (channel == -1) {
+  const auto it = send_streams_.find(ssrc);
+  if (it == send_streams_.end()) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
   }
-  if (engine()->voe()->volume()->SetInputMute(channel, muted) == -1) {
-    LOG_RTCERR2(SetInputMute, channel, muted);
-    return false;
-  }
+  it->second->SetMuted(muted);
+
+  // TODO(solenberg):
   // We set the AGC to mute state only when all the channels are muted.
   // This implementation is not ideal, instead we should signal the AGC when
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
   bool all_muted = muted;
-  for (const auto& ch : send_streams_) {
-    if (!all_muted) {
-      break;
-    }
-    if (engine()->voe()->volume()->GetInputMute(ch.second->channel(),
-                                                all_muted)) {
-      LOG_RTCERR1(GetInputMute, ch.second->channel());
-      return false;
-    }
+  for (const auto& kv : send_streams_) {
+    all_muted = all_muted && kv.second->muted();

[kwiberg-webrtc, 2016/06/16 09:33:45]

This looks like a job for std::all_of.

[the sun, 2016/06/16 12:31:38]

That sounds neat, but it turns out it doesn't help readability a lot:

  bool all_muted =
      std::all_of(send_streams_.cbegin(), send_streams_.cend(),
                  [](const std::pair<uint32_t, WebRtcAudioSendStream*>& kv){
                      return kv.second->muted();
                  });

if all_of() had accepted send_streams_ without giving the iterators, and if we
could use auto in the lambda parameter list, then it would have been better,
though.

[kwiberg-webrtc, 2016/06/16 12:41:40]

Bummer. auto in lambda parameter lists is in C++14, but not even C++17 will let
you mention send_streams_ less than twice.

   }
 
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
   if (ap) {
     ap->set_output_will_be_muted(all_muted);
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(int bps) {
@@ skipping 192 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE