WIP: Adding a centralized NetEq Clock

webrtc/modules/audio_coding/neteq/neteq_impl_unittest.cc

 /*
  *  Copyright (c) 2012 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 39 matching lines @@
 int DeletePacketsAndReturnOk(PacketList* packet_list) {
   PacketBuffer::DeleteAllPackets(packet_list);
   return PacketBuffer::kOK;
 }
 
 class NetEqImplTest : public ::testing::Test {
  protected:
   NetEqImplTest()
       : neteq_(NULL),
         config_(),
+        tick_timer_(new TickTimer),
         mock_buffer_level_filter_(NULL),
         buffer_level_filter_(NULL),
         use_mock_buffer_level_filter_(true),
         mock_decoder_database_(NULL),
         decoder_database_(NULL),
         use_mock_decoder_database_(true),
         mock_delay_peak_detector_(NULL),
         delay_peak_detector_(NULL),
         use_mock_delay_peak_detector_(true),
         mock_delay_manager_(NULL),
@@ skipping 24 matching lines @@
     }
     if (use_mock_decoder_database_) {
       mock_decoder_database_ = new MockDecoderDatabase;
       EXPECT_CALL(*mock_decoder_database_, GetActiveCngDecoder())
           .WillOnce(ReturnNull());
       decoder_database_ = mock_decoder_database_;
     } else {
       decoder_database_ = new DecoderDatabase;
     }
     if (use_mock_delay_peak_detector_) {
-      mock_delay_peak_detector_ = new MockDelayPeakDetector;
+      mock_delay_peak_detector_ = new MockDelayPeakDetector(*tick_timer_);
       EXPECT_CALL(*mock_delay_peak_detector_, Reset()).Times(1);
       delay_peak_detector_ = mock_delay_peak_detector_;
     } else {
-      delay_peak_detector_ = new DelayPeakDetector;
+      delay_peak_detector_ = new DelayPeakDetector(*tick_timer_);
     }
     if (use_mock_delay_manager_) {
-      mock_delay_manager_ = new MockDelayManager(config_.max_packets_in_buffer,
-                                                 delay_peak_detector_);
+      mock_delay_manager_ = new MockDelayManager(
+          config_.max_packets_in_buffer, delay_peak_detector_, *tick_timer_);
       EXPECT_CALL(*mock_delay_manager_, set_streaming_mode(false)).Times(1);
       delay_manager_ = mock_delay_manager_;
     } else {
-      delay_manager_ =
-          new DelayManager(config_.max_packets_in_buffer, delay_peak_detector_);
+      delay_manager_ = new DelayManager(config_.max_packets_in_buffer,
+                                        delay_peak_detector_, *tick_timer_);
     }
     if (use_mock_dtmf_buffer_) {
       mock_dtmf_buffer_ = new MockDtmfBuffer(config_.sample_rate_hz);
       dtmf_buffer_ = mock_dtmf_buffer_;
     } else {
       dtmf_buffer_ = new DtmfBuffer(config_.sample_rate_hz);
     }
     if (use_mock_dtmf_tone_generator_) {
       mock_dtmf_tone_generator_ = new MockDtmfToneGenerator;
       dtmf_tone_generator_ = mock_dtmf_tone_generator_;
     } else {
       dtmf_tone_generator_ = new DtmfToneGenerator;
     }
     if (use_mock_packet_buffer_) {
-      mock_packet_buffer_ = new MockPacketBuffer(config_.max_packets_in_buffer);
+      mock_packet_buffer_ =
+          new MockPacketBuffer(config_.max_packets_in_buffer, *tick_timer_);
       packet_buffer_ = mock_packet_buffer_;
     } else {
-      packet_buffer_ = new PacketBuffer(config_.max_packets_in_buffer);
+      packet_buffer_ =
+          new PacketBuffer(config_.max_packets_in_buffer, *tick_timer_);
     }
     if (use_mock_payload_splitter_) {
       mock_payload_splitter_ = new MockPayloadSplitter;
       payload_splitter_ = mock_payload_splitter_;
     } else {
       payload_splitter_ = new PayloadSplitter;
     }
     timestamp_scaler_ = new TimestampScaler(*decoder_database_);
     AccelerateFactory* accelerate_factory = new AccelerateFactory;
     ExpandFactory* expand_factory = new ExpandFactory;
     PreemptiveExpandFactory* preemptive_expand_factory =
         new PreemptiveExpandFactory;
 
-    neteq_ = new NetEqImpl(config_,
-                           buffer_level_filter_,
-                           decoder_database_,
-                           delay_manager_,
-                           delay_peak_detector_,
-                           dtmf_buffer_,
-                           dtmf_tone_generator_,
-                           packet_buffer_,
-                           payload_splitter_,
-                           timestamp_scaler_,
-                           accelerate_factory,
-                           expand_factory,
-                           preemptive_expand_factory);
+    neteq_ =
+        new NetEqImpl(config_, std::move(tick_timer_), buffer_level_filter_,
+                      decoder_database_, delay_manager_, delay_peak_detector_,
+                      dtmf_buffer_, dtmf_tone_generator_, packet_buffer_,
+                      payload_splitter_, timestamp_scaler_, accelerate_factory,
+                      expand_factory, preemptive_expand_factory);
     ASSERT_TRUE(neteq_ != NULL);
   }
 
   void UseNoMocks() {
     ASSERT_TRUE(neteq_ == NULL) << "Must call UseNoMocks before CreateInstance";
     use_mock_buffer_level_filter_ = false;
     use_mock_decoder_database_ = false;
     use_mock_delay_peak_detector_ = false;
     use_mock_delay_manager_ = false;
     use_mock_dtmf_buffer_ = false;
@@ skipping 22 matching lines @@
       EXPECT_CALL(*mock_dtmf_tone_generator_, Die()).Times(1);
     }
     if (use_mock_packet_buffer_) {
       EXPECT_CALL(*mock_packet_buffer_, Die()).Times(1);
     }
     delete neteq_;
   }
 
   NetEqImpl* neteq_;
   NetEq::Config config_;
+  std::unique_ptr<TickTimer> tick_timer_;
   MockBufferLevelFilter* mock_buffer_level_filter_;
   BufferLevelFilter* buffer_level_filter_;
   bool use_mock_buffer_level_filter_;
   MockDecoderDatabase* mock_decoder_database_;
   DecoderDatabase* decoder_database_;
   bool use_mock_decoder_database_;
   MockDelayPeakDetector* mock_delay_peak_detector_;
   DelayPeakDetector* delay_peak_detector_;
   bool use_mock_delay_peak_detector_;
   MockDelayManager* mock_delay_manager_;
@@ skipping 978 matching lines @@
 // Tests that the return value from last_output_sample_rate_hz() is equal to the
 // configured inital sample rate.
 TEST_F(NetEqImplTest, InitialLastOutputSampleRate) {
   UseNoMocks();
   config_.sample_rate_hz = 48000;
   CreateInstance();
   EXPECT_EQ(48000, neteq_->last_output_sample_rate_hz());
 }
 
 }// namespace webrtc