Move some send stream configuration into webrtc::AudioSendStream.

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.
  */
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/audio/audio_receive_stream.h"
 #include "webrtc/audio/conversion.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/test/mock_voice_engine.h"
 
 namespace webrtc {
 namespace test {
 namespace {
 
+using testing::_;
+using testing::Return;
+
 AudioDecodingCallStats MakeAudioDecodeStatsForTest() {
   AudioDecodingCallStats audio_decode_stats;
   audio_decode_stats.calls_to_silence_generator = 234;
   audio_decode_stats.calls_to_neteq = 567;
   audio_decode_stats.decoded_normal = 890;
   audio_decode_stats.decoded_plc = 123;
   audio_decode_stats.decoded_cng = 456;
   audio_decode_stats.decoded_plc_cng = 789;
   return audio_decode_stats;
 }
@@ skipping 10 matching lines @@
     345,  678,  901, 234, -12, 3456, 7890, 567, 890, 123};
 const CodecInst kCodecInst = {
     123, "codec_name_recv", 96000, -187, -198, -103};
 const NetworkStatistics kNetworkStats = {
     123, 456, false, 0, 0, 789, 12, 345, 678, 901, -1, -1, -1, -1, -1, 0};
 const AudioDecodingCallStats kAudioDecodeStats = MakeAudioDecodeStatsForTest();
 
 struct ConfigHelper {
   ConfigHelper() {
     EXPECT_CALL(voice_engine_,
-        RegisterVoiceEngineObserver(testing::_)).WillOnce(testing::Return(0));
+        RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
     EXPECT_CALL(voice_engine_,
-        DeRegisterVoiceEngineObserver()).WillOnce(testing::Return(0));
+        DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
     AudioState::Config config;
     config.voice_engine = &voice_engine_;
     audio_state_ = AudioState::Create(config);
     stream_config_.voe_channel_id = kChannelId;
     stream_config_.rtp.local_ssrc = kLocalSsrc;
     stream_config_.rtp.remote_ssrc = kRemoteSsrc;
   }
 
   MockRemoteBitrateEstimator* remote_bitrate_estimator() {
     return &remote_bitrate_estimator_;
   }
   AudioReceiveStream::Config& config() { return stream_config_; }
   rtc::scoped_refptr<AudioState> audio_state() { return audio_state_; }
   MockVoiceEngine& voice_engine() { return voice_engine_; }
 
   void SetupMockForGetStats() {
-    using testing::_;
     using testing::DoAll;
-    using testing::Return;
     using testing::SetArgPointee;
     using testing::SetArgReferee;
     EXPECT_CALL(voice_engine_, GetRemoteSSRC(kChannelId, _))
         .WillOnce(DoAll(SetArgReferee<1>(0), Return(0)));
     EXPECT_CALL(voice_engine_, GetRTCPStatistics(kChannelId, _))
         .WillOnce(DoAll(SetArgReferee<1>(kCallStats), Return(0)));
     EXPECT_CALL(voice_engine_, GetRecCodec(kChannelId, _))
         .WillOnce(DoAll(SetArgReferee<1>(kCodecInst), Return(0)));
     EXPECT_CALL(voice_engine_, GetDelayEstimate(kChannelId, _, _))
         .WillOnce(DoAll(SetArgPointee<1>(kJitterBufferDelay),
                         SetArgPointee<2>(kPlayoutBufferDelay), Return(0)));
     EXPECT_CALL(voice_engine_,
         GetSpeechOutputLevelFullRange(kChannelId, _)).WillOnce(
             DoAll(SetArgReferee<1>(kSpeechOutputLevel), Return(0)));
     EXPECT_CALL(voice_engine_, GetNetworkStatistics(kChannelId, _))
         .WillOnce(DoAll(SetArgReferee<1>(kNetworkStats), Return(0)));
     EXPECT_CALL(voice_engine_, GetDecodingCallStatistics(kChannelId, _))
         .WillOnce(DoAll(SetArgPointee<1>(kAudioDecodeStats), Return(0)));
   }
 
  private:
   MockRemoteBitrateEstimator remote_bitrate_estimator_;
-  MockVoiceEngine voice_engine_;
+  testing::StrictMock<MockVoiceEngine> voice_engine_;
   rtc::scoped_refptr<AudioState> audio_state_;
   AudioReceiveStream::Config stream_config_;
 };
 
 void BuildAbsoluteSendTimeExtension(uint8_t* buffer,
                                     int id,
                                     uint32_t abs_send_time) {
   const size_t kRtpOneByteHeaderLength = 4;
   const uint16_t kRtpOneByteHeaderExtensionId = 0xBEDE;
   ByteWriter<uint16_t>::WriteBigEndian(buffer, kRtpOneByteHeaderExtensionId);
@@ skipping 106 matching lines @@
   EXPECT_EQ(kAudioDecodeStats.calls_to_neteq, stats.decoding_calls_to_neteq);
   EXPECT_EQ(kAudioDecodeStats.decoded_normal, stats.decoding_normal);
   EXPECT_EQ(kAudioDecodeStats.decoded_plc, stats.decoding_plc);
   EXPECT_EQ(kAudioDecodeStats.decoded_cng, stats.decoding_cng);
   EXPECT_EQ(kAudioDecodeStats.decoded_plc_cng, stats.decoding_plc_cng);
   EXPECT_EQ(kCallStats.capture_start_ntp_time_ms_,
             stats.capture_start_ntp_time_ms);
 }
 }  // namespace test
 }  // namespace webrtc