Make the audio channel communicate network state changes to the call.

webrtc/media/engine/fakewebrtccall.cc

 /*
  *  Copyright (c) 2015 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 209 matching lines @@
   receiving_ = false;
 }
 
 void FakeVideoReceiveStream::SetStats(
     const webrtc::VideoReceiveStream::Stats& stats) {
   stats_ = stats;
 }
 
 FakeCall::FakeCall(const webrtc::Call::Config& config)
     : config_(config),
-      network_state_(webrtc::kNetworkUp),
+      audio_network_state_(webrtc::kNetworkUp),
+      video_network_state_(webrtc::kNetworkUp),
       num_created_send_streams_(0),
       num_created_receive_streams_(0) {}
 
 FakeCall::~FakeCall() {
   EXPECT_EQ(0u, video_send_streams_.size());
   EXPECT_EQ(0u, audio_send_streams_.size());
   EXPECT_EQ(0u, video_receive_streams_.size());
   EXPECT_EQ(0u, audio_receive_streams_.size());
 }
 
@@ skipping 28 matching lines @@
 
 const FakeAudioReceiveStream* FakeCall::GetAudioReceiveStream(uint32_t ssrc) {
   for (const auto* p : GetAudioReceiveStreams()) {
     if (p->GetConfig().rtp.remote_ssrc == ssrc) {
       return p;
     }
   }
   return nullptr;
 }
 
-webrtc::NetworkState FakeCall::GetNetworkState() const {
-  return network_state_;
+webrtc::NetworkState FakeCall::GetNetworkState(webrtc::MediaType media) const {
+  switch (media) {
+    case webrtc::MediaType::AUDIO:
+      return audio_network_state_;
+    case webrtc::MediaType::VIDEO:
+      return video_network_state_;
+    default:
+      ADD_FAILURE() << "GetNetworkState called with unknown parameter.";
+      return webrtc::kNetworkDown;
+  }
 }
 
 webrtc::AudioSendStream* FakeCall::CreateAudioSendStream(
     const webrtc::AudioSendStream::Config& config) {
   FakeAudioSendStream* fake_stream = new FakeAudioSendStream(config);
   audio_send_streams_.push_back(fake_stream);
   ++num_created_send_streams_;
   return fake_stream;
 }
 
 void FakeCall::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) {
   auto it = std::find(audio_send_streams_.begin(),
                       audio_send_streams_.end(),
                       static_cast<FakeAudioSendStream*>(send_stream));
   if (it == audio_send_streams_.end()) {
-    ADD_FAILURE() << "DestroyAudioSendStream called with unknown paramter.";
+    ADD_FAILURE() << "DestroyAudioSendStream called with unknown parameter.";
   } else {
     delete *it;
     audio_send_streams_.erase(it);
   }
 }
 
 webrtc::AudioReceiveStream* FakeCall::CreateAudioReceiveStream(
     const webrtc::AudioReceiveStream::Config& config) {
   audio_receive_streams_.push_back(new FakeAudioReceiveStream(config));
   ++num_created_receive_streams_;
   return audio_receive_streams_.back();
 }
 
 void FakeCall::DestroyAudioReceiveStream(
     webrtc::AudioReceiveStream* receive_stream) {
   auto it = std::find(audio_receive_streams_.begin(),
                       audio_receive_streams_.end(),
                       static_cast<FakeAudioReceiveStream*>(receive_stream));
   if (it == audio_receive_streams_.end()) {
-    ADD_FAILURE() << "DestroyAudioReceiveStream called with unknown paramter.";
+    ADD_FAILURE() << "DestroyAudioReceiveStream called with unknown parameter.";
   } else {
     delete *it;
     audio_receive_streams_.erase(it);
   }
 }
 
 webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
     const webrtc::VideoSendStream::Config& config,
     const webrtc::VideoEncoderConfig& encoder_config) {
   FakeVideoSendStream* fake_stream =
       new FakeVideoSendStream(config, encoder_config);
   video_send_streams_.push_back(fake_stream);
   ++num_created_send_streams_;
   return fake_stream;
 }
 
 void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
   auto it = std::find(video_send_streams_.begin(),
                       video_send_streams_.end(),
                       static_cast<FakeVideoSendStream*>(send_stream));
   if (it == video_send_streams_.end()) {
-    ADD_FAILURE() << "DestroyVideoSendStream called with unknown paramter.";
+    ADD_FAILURE() << "DestroyVideoSendStream called with unknown parameter.";
   } else {
     delete *it;
     video_send_streams_.erase(it);
   }
 }
 
 webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
     const webrtc::VideoReceiveStream::Config& config) {
   video_receive_streams_.push_back(new FakeVideoReceiveStream(config));
   ++num_created_receive_streams_;
   return video_receive_streams_.back();
 }
 
 void FakeCall::DestroyVideoReceiveStream(
     webrtc::VideoReceiveStream* receive_stream) {
   auto it = std::find(video_receive_streams_.begin(),
                       video_receive_streams_.end(),
                       static_cast<FakeVideoReceiveStream*>(receive_stream));
   if (it == video_receive_streams_.end()) {
-    ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown paramter.";
+    ADD_FAILURE() << "DestroyVideoReceiveStream called with unknown parameter.";
   } else {
     delete *it;
     video_receive_streams_.erase(it);
   }
 }
 
 webrtc::PacketReceiver* FakeCall::Receiver() {
   return this;
 }
 
@@ skipping 40 matching lines @@
 
 webrtc::Call::Stats FakeCall::GetStats() const {
   return stats_;
 }
 
 void FakeCall::SetBitrateConfig(
     const webrtc::Call::Config::BitrateConfig& bitrate_config) {
   config_.bitrate_config = bitrate_config;
 }
 
-void FakeCall::SignalNetworkState(webrtc::NetworkState state) {
-  network_state_ = state;
+void FakeCall::SignalChannelNetworkState(webrtc::MediaType media,
+                                         webrtc::NetworkState state) {
+  switch (media) {
+    case webrtc::MediaType::AUDIO:
+      audio_network_state_ = state;
+      break;
+    case webrtc::MediaType::VIDEO:
+      video_network_state_ = state;
+      break;
+    default:
+      ADD_FAILURE()
+          << "SignalChannelNetworkState called with unknown parameter.";
+  }
 }
 
 void FakeCall::OnSentPacket(const rtc::SentPacket& sent_packet) {
   last_sent_packet_ = sent_packet;
 }
 }  // namespace cricket