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 <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/test/gtest.h"
 #include "webrtc/test/mock_voe_channel_proxy.h"
@@ skipping 35 matching lines @@
                void(uint32_t min_send_bitrate_bps,
                     uint32_t max_padding_bitrate_bps));
 };
 
 class MockTransmitMixer : public voe::TransmitMixer {
  public:
   MOCK_CONST_METHOD0(AudioLevelFullRange, int16_t());
 };
 
 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_;
-  };
-
   explicit ConfigHelper(bool audio_bwe_enabled)
       : stream_config_(nullptr),
-        fake_transport_(&event_log_),
+        simulated_clock_(123456),
+        send_side_cc_(
+            rtc::MakeUnique<SendSideCongestionController>(&simulated_clock_,
+                                                          &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 139 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_;
+  SimulatedClock simulated_clock_;
+  PacketRouter packet_router_;
+  std::unique_ptr<SendSideCongestionController> send_side_cc_;
   FakeRtpTransportController fake_transport_;
   MockRtcEventLog event_log_;
   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 203 matching lines @@
   internal::AudioSendStream send_stream(
       helper.config(), helper.audio_state(), helper.worker_queue(),
       helper.transport(), helper.bitrate_allocator(), helper.event_log(),
       helper.rtcp_rtt_stats());
   EXPECT_CALL(*helper.channel_proxy(), SetBitrate(_, 5000));
   send_stream.OnBitrateUpdated(50000, 0.0, 50, 5000);
 }
 
 }  // namespace test
 }  // namespace webrtc