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

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>
@@ skipping 3202 matching lines @@
       send_config->encoder_settings.encoder = this;
     }
 
     void PerformTest() override {
       EXPECT_TRUE(encoded_frames_.Wait(kDefaultTimeoutMs))
           << "No frames received by the encoder.";
       // Wait for packets from both sender/receiver.
       WaitForPacketsOrSilence(false, false);
 
       // Sender-side network down.
-      sender_call_->SignalNetworkState(kNetworkDown);
+      sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown);

[stefan-webrtc, 2016/03/11 08:29:41]

Maybe we should add a test which verifies the expected behavior for audio too?

[skvlad, 2016/03/11 23:59:08]

I've added tests that verify that video streams are not affected by audio
network state changes. Until the workaround in paced_sender is removed, audio
packets won't be stopped by network state changes so there are no tests for
that.

       {
         rtc::CritScope lock(&test_crit_);
         // After network goes down we shouldn't be encoding more frames.
         sender_state_ = kNetworkDown;
       }
       // Wait for receiver-packets and no sender packets.
       WaitForPacketsOrSilence(true, false);
 
       // Receiver-side network down.
-      receiver_call_->SignalNetworkState(kNetworkDown);
+      receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown);
       WaitForPacketsOrSilence(true, true);
 
       // Network back up again for both.
       {
         rtc::CritScope lock(&test_crit_);
         // It's OK to encode frames again, as we're about to bring up the
         // network.
         sender_state_ = kNetworkUp;
       }
-      sender_call_->SignalNetworkState(kNetworkUp);
-      receiver_call_->SignalNetworkState(kNetworkUp);
+      sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
+      receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
       WaitForPacketsOrSilence(false, false);
     }
 
     int32_t Encode(const VideoFrame& input_image,
                    const CodecSpecificInfo* codec_specific_info,
                    const std::vector<FrameType>* frame_types) override {
       {
         rtc::CritScope lock(&test_crit_);
         if (sender_state_ == kNetworkDown) {
           ++down_frames_;
@@ skipping 116 matching lines @@
      int32_t Encode(const VideoFrame& input_image,
                     const CodecSpecificInfo* codec_specific_info,
                     const std::vector<FrameType>* frame_types) override {
       ADD_FAILURE() << "Unexpected frame encode.";
       return test::FakeEncoder::Encode(
           input_image, codec_specific_info, frame_types);
     }
   };
 
   CreateSenderCall(Call::Config());
-  sender_call_->SignalNetworkState(kNetworkDown);
+  sender_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown);
 
   UnusedTransport transport;
   CreateSendConfig(1, 0, &transport);
   UnusedEncoder unused_encoder;
   video_send_config_.encoder_settings.encoder = &unused_encoder;
   CreateVideoStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
   SleepMs(kSilenceTimeoutMs);
   Stop();
 
   DestroyStreams();
 }
 
 TEST_F(EndToEndTest, NewReceiveStreamsRespectNetworkDown) {
   CreateCalls(Call::Config(), Call::Config());
-  receiver_call_->SignalNetworkState(kNetworkDown);
+  receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkDown);
 
   test::DirectTransport sender_transport(sender_call_.get());
   sender_transport.SetReceiver(receiver_call_->Receiver());
   CreateSendConfig(1, 0, &sender_transport);
   UnusedTransport transport;
   CreateMatchingReceiveConfigs(&transport);
   CreateVideoStreams();
   CreateFrameGeneratorCapturer();
 
   Start();
@@ skipping 116 matching lines @@
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc