Allow mocking SendSideCongestionController for Call tests.

webrtc/audio/audio_send_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.
  */
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/audio/audio_send_stream.h"
 #include "webrtc/audio/audio_state.h"
 #include "webrtc/audio/conversion.h"
+#include "webrtc/base/ptr_util.h"
 #include "webrtc/base/task_queue.h"
+#include "webrtc/call/fake_rtp_transport_controller_send.h"
 #include "webrtc/call/rtp_transport_controller_send_interface.h"
 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
 #include "webrtc/modules/audio_processing/include/mock_audio_processing.h"
 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_observer.h"
 #include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
+#include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
-#include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_audio_encoder.h"
 #include "webrtc/test/mock_audio_encoder_factory.h"
 #include "webrtc/test/mock_voe_channel_proxy.h"
 #include "webrtc/test/mock_voice_engine.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 
 namespace webrtc {
 namespace test {
 namespace {
@@ skipping 79 matching lines @@
       }));
   ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
       .WillByDefault(Invoke([](int payload_type, const SdpAudioFormat& format,
                                std::unique_ptr<AudioEncoder>* return_value) {
         *return_value = SetupAudioEncoderMock(payload_type, format);
       }));
   return factory;
 }
 
 struct ConfigHelper {
-  class FakeRtpTransportController
-      : public RtpTransportControllerSendInterface {
-   public:
-    explicit FakeRtpTransportController(RtcEventLog* event_log)
-        : simulated_clock_(123456),
-          send_side_cc_(&simulated_clock_,
-                        &bitrate_observer_,
-                        event_log,
-                        &packet_router_) {}
-    PacketRouter* packet_router() override { return &packet_router_; }
-
-    SendSideCongestionController* send_side_cc() override {
-      return &send_side_cc_;
-    }
-    TransportFeedbackObserver* transport_feedback_observer() override {
-      return &send_side_cc_;
-    }
-
-    RtpPacketSender* packet_sender() override { return send_side_cc_.pacer(); }
-
-   private:
-    SimulatedClock simulated_clock_;
-    testing::NiceMock<MockCongestionObserver> bitrate_observer_;
-    PacketRouter packet_router_;
-    SendSideCongestionController send_side_cc_;
-  };
-
   ConfigHelper(bool audio_bwe_enabled, bool expect_set_encoder_call)
       : stream_config_(nullptr),
-        fake_transport_(&event_log_),
+        simulated_clock_(123456),
+        send_side_cc_(rtc::MakeUnique<SendSideCongestionController>(
+            &simulated_clock_,
+            nullptr /* observer */,
+            &event_log_,
+            &packet_router_)),
+        fake_transport_(send_side_cc_.get()),
         bitrate_allocator_(&limit_observer_),
         worker_queue_("ConfigHelper_worker_queue") {
     using testing::Invoke;
 
     EXPECT_CALL(voice_engine_,
         RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_,
         DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_, audio_device_module());
     EXPECT_CALL(voice_engine_, audio_processing());
@@ skipping 148 matching lines @@
 
     EXPECT_CALL(audio_processing_, GetStatistics())
         .WillRepeatedly(Return(audio_processing_stats_));
   }
 
  private:
   testing::StrictMock<MockVoiceEngine> voice_engine_;
   rtc::scoped_refptr<AudioState> audio_state_;
   AudioSendStream::Config stream_config_;
   testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;
-  testing::NiceMock<MockCongestionObserver> bitrate_observer_;
   MockAudioProcessing audio_processing_;
   MockTransmitMixer transmit_mixer_;
   AudioProcessing::AudioProcessingStatistics audio_processing_stats_;
-  FakeRtpTransportController fake_transport_;
+  SimulatedClock simulated_clock_;
+  PacketRouter packet_router_;
+  std::unique_ptr<SendSideCongestionController> send_side_cc_;
+  FakeRtpTransportControllerSend fake_transport_;
   MockRtcEventLog event_log_;
   MockRtpRtcp rtp_rtcp_;
   MockRtcpRttStats rtcp_rtt_stats_;
   testing::NiceMock<MockLimitObserver> limit_observer_;
   BitrateAllocator bitrate_allocator_;
   // |worker_queue| is defined last to ensure all pending tasks are cancelled
   // and deleted before any other members.
   rtc::TaskQueue worker_queue_;
 };
 }  // namespace
@@ skipping 214 matching lines @@
   stream_config.send_codec_spec->cng_payload_type = rtc::Optional<int>(105);
   internal::AudioSendStream send_stream(
       stream_config, helper.audio_state(), helper.worker_queue(),
       helper.transport(), helper.bitrate_allocator(), helper.event_log(),
       helper.rtcp_rtt_stats());
   send_stream.Reconfigure(stream_config);
 }
 
 }  // namespace test
 }  // namespace webrtc