Move ownership of PacketRouter from CongestionController to Call.

webrtc/audio/audio_receive_stream_unittest.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 54 matching lines @@
     123, 456, false, 0, 0, 789, 12, 345, 678, 901, -1, -1, -1, -1, -1, 0};
 const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest();
 
 struct ConfigHelper {
   ConfigHelper()
       : simulated_clock_(123456),
         decoder_factory_(new rtc::RefCountedObject<MockAudioDecoderFactory>),
         congestion_controller_(&simulated_clock_,
                                &bitrate_observer_,
                                &remote_bitrate_observer_,
-                               &event_log_),
+                               &event_log_,
+                               &packet_router_),
         audio_mixer_(new rtc::RefCountedObject<MockAudioMixer>()) {
     using testing::Invoke;
 
     EXPECT_CALL(voice_engine_,
         RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_,
         DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_, audio_processing());
     EXPECT_CALL(voice_engine_, audio_device_module());
     EXPECT_CALL(voice_engine_, audio_transport());
@@ skipping 11 matching lines @@
           EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 15)).Times(1);
           EXPECT_CALL(*channel_proxy_,
               SetReceiveAudioLevelIndicationStatus(true, kAudioLevelId))
                   .Times(1);
           EXPECT_CALL(*channel_proxy_,
               EnableReceiveTransportSequenceNumber(kTransportSequenceNumberId))
                   .Times(1);
           EXPECT_CALL(*channel_proxy_,
               RegisterReceiverCongestionControlObjects(&packet_router_))
                   .Times(1);
-          EXPECT_CALL(congestion_controller_, packet_router())
-              .WillOnce(Return(&packet_router_));
           EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects())
               .Times(1);
           EXPECT_CALL(*channel_proxy_, RegisterExternalTransport(nullptr))
               .Times(1);
           EXPECT_CALL(*channel_proxy_, DeRegisterExternalTransport())
               .Times(1);
           EXPECT_CALL(*channel_proxy_, GetAudioDecoderFactory())
               .WillOnce(ReturnRef(decoder_factory_));
           testing::Expectation expect_set =
               EXPECT_CALL(*channel_proxy_, SetRtcEventLog(&event_log_))
                   .Times(1);
           EXPECT_CALL(*channel_proxy_, SetRtcEventLog(testing::IsNull()))
               .Times(1)
               .After(expect_set);
           EXPECT_CALL(*channel_proxy_, DisassociateSendChannel()).Times(1);
           return channel_proxy_;
         }));
     stream_config_.voe_channel_id = kChannelId;
     stream_config_.rtp.local_ssrc = kLocalSsrc;
     stream_config_.rtp.remote_ssrc = kRemoteSsrc;
     stream_config_.rtp.nack.rtp_history_ms = 300;
     stream_config_.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAudioLevelUri, kAudioLevelId));
     stream_config_.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kTransportSequenceNumberUri, kTransportSequenceNumberId));
     stream_config_.decoder_factory = decoder_factory_;
   }
 
+  PacketRouter* packet_router() { return &packet_router_; }
   MockCongestionController* congestion_controller() {
     return &congestion_controller_;
   }
   MockRemoteBitrateEstimator* remote_bitrate_estimator() {
     return &remote_bitrate_estimator_;
   }
   MockRtcEventLog* event_log() { return &event_log_; }
   AudioReceiveStream::Config& config() { return stream_config_; }
   rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }
   rtc::scoped_refptr<MockAudioMixer> audio_mixer() { return audio_mixer_; }
@@ skipping 107 matching lines @@
       "{rtp: {remote_ssrc: 1234, local_ssrc: 5678, transport_cc: off, nack: "
       "{rtp_history_ms: 0}, extensions: [{uri: "
       "urn:ietf:params:rtp-hdrext:ssrc-audio-level, id: 3}]}, "
       "rtcp_send_transport: nullptr, voe_channel_id: 2}",
       config.ToString());
 }
 
 TEST(AudioReceiveStreamTest, ConstructDestruct) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
 }
 
 MATCHER_P(VerifyHeaderExtension, expected_extension, "") {
   return arg.extension.hasTransportSequenceNumber ==
              expected_extension.hasTransportSequenceNumber &&
          arg.extension.transportSequenceNumber ==
              expected_extension.transportSequenceNumber;
 }
 
 TEST(AudioReceiveStreamTest, ReceiveRtpPacket) {
   ConfigHelper helper;
   helper.config().rtp.transport_cc = true;
   helper.SetupMockForBweFeedback(true);
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
   const int kTransportSequenceNumberValue = 1234;
   std::vector<uint8_t> rtp_packet = CreateRtpHeaderWithOneByteExtension(
       kTransportSequenceNumberId, kTransportSequenceNumberValue, 2);
   PacketTime packet_time(5678000, 0);
   const size_t kExpectedHeaderLength = 20;
   RTPHeaderExtension expected_extension;
   expected_extension.hasTransportSequenceNumber = true;
   expected_extension.transportSequenceNumber = kTransportSequenceNumberValue;
   EXPECT_CALL(*helper.remote_bitrate_estimator(),
               IncomingPacket(packet_time.timestamp / 1000,
                              rtp_packet.size() - kExpectedHeaderLength,
                              VerifyHeaderExtension(expected_extension)))
       .Times(1);
   EXPECT_CALL(*helper.channel_proxy(),
               ReceivedRTPPacket(&rtp_packet[0],
                                 rtp_packet.size(),
                                 _))
       .WillOnce(Return(true));
   EXPECT_TRUE(
       recv_stream.DeliverRtp(&rtp_packet[0], rtp_packet.size(), packet_time));
 }
 
 TEST(AudioReceiveStreamTest, ReceiveRtcpPacket) {
   ConfigHelper helper;
   helper.config().rtp.transport_cc = true;
   helper.SetupMockForBweFeedback(true);
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
 
   std::vector<uint8_t> rtcp_packet = CreateRtcpSenderReport();
   EXPECT_CALL(*helper.channel_proxy(),
               ReceivedRTCPPacket(&rtcp_packet[0], rtcp_packet.size()))
       .WillOnce(Return(true));
   EXPECT_TRUE(recv_stream.DeliverRtcp(&rtcp_packet[0], rtcp_packet.size()));
 }
 
 TEST(AudioReceiveStreamTest, GetStats) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
   helper.SetupMockForGetStats();
   AudioReceiveStream::Stats stats = recv_stream.GetStats();
   EXPECT_EQ(kRemoteSsrc, stats.remote_ssrc);
   EXPECT_EQ(static_cast<int64_t>(kCallStats.bytesReceived), stats.bytes_rcvd);
   EXPECT_EQ(static_cast<uint32_t>(kCallStats.packetsReceived),
             stats.packets_rcvd);
   EXPECT_EQ(kCallStats.cumulativeLost, stats.packets_lost);
   EXPECT_EQ(Q8ToFloat(kCallStats.fractionLost), stats.fraction_lost);
   EXPECT_EQ(std::string(kCodecInst.plname), stats.codec_name);
   EXPECT_EQ(kCallStats.extendedMax, stats.ext_seqnum);
@@ skipping 23 matching lines @@
   EXPECT_EQ(kAudioDecodeStats.decoded_plc_cng, stats.decoding_plc_cng);
   EXPECT_EQ(kAudioDecodeStats.decoded_muted_output,
             stats.decoding_muted_output);
   EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_,
             stats.capture_start_ntp_time_ms);
 }
 
 TEST(AudioReceiveStreamTest, SetGain) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
   EXPECT_CALL(*helper.channel_proxy(),
       SetChannelOutputVolumeScaling(FloatEq(0.765f)));
   recv_stream.SetGain(0.765f);
 }
 
 TEST(AudioReceiveStreamTest, StreamShouldNotBeAddedToMixerWhenVoEReturnsError) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
 
   EXPECT_CALL(helper.voice_engine(), StartPlayout(_)).WillOnce(Return(-1));
   EXPECT_CALL(*helper.audio_mixer(), AddSource(_)).Times(0);
 
   recv_stream.Start();
 }
 
 TEST(AudioReceiveStreamTest, StreamShouldBeAddedToMixerOnStart) {
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
-      helper.congestion_controller(), helper.config(), helper.audio_state(),
-      helper.event_log());
+      helper.packet_router(),
+      helper.congestion_controller()->GetRemoteBitrateEstimator(true),
+      helper.config(), helper.audio_state(), helper.event_log());
 
   EXPECT_CALL(helper.voice_engine(), StartPlayout(_)).WillOnce(Return(0));
   EXPECT_CALL(helper.voice_engine(), StopPlayout(_));
   EXPECT_CALL(*helper.audio_mixer(), AddSource(&recv_stream))
       .WillOnce(Return(true));
 
   recv_stream.Start();
 }
 }  // namespace test
 }  // namespace webrtc