Added an empty AudioTransportProxy to AudioState.

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 <string>
 #include <vector>
 
 #include "webrtc/audio/audio_receive_stream.h"
 #include "webrtc/audio/conversion.h"
 #include "webrtc/logging/rtc_event_log/mock/mock_rtc_event_log.h"
 #include "webrtc/modules/audio_coding/codecs/mock/mock_audio_decoder_factory.h"
+#include "webrtc/modules/audio_device/include/mock_audio_device.h"
 #include "webrtc/modules/bitrate_controller/include/mock/mock_bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/mock/mock_congestion_controller.h"
 #include "webrtc/modules/pacing/packet_router.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/system_wrappers/include/clock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/mock_voe_channel_proxy.h"
 #include "webrtc/test/mock_voice_engine.h"
 
@@ skipping 39 matching lines @@
 struct ConfigHelper {
   ConfigHelper()
       : simulated_clock_(123456),
         decoder_factory_(new rtc::RefCountedObject<MockAudioDecoderFactory>),
         congestion_controller_(&simulated_clock_,
                                &bitrate_observer_,
                                &remote_bitrate_observer_,
                                &event_log_) {
     using testing::Invoke;
 
-    EXPECT_CALL(voice_engine_,
-        RegisterVoiceEngineObserver(_)).WillOnce(Return(0));
-    EXPECT_CALL(voice_engine_,
-        DeRegisterVoiceEngineObserver()).WillOnce(Return(0));
+    EXPECT_CALL(voice_engine_, RegisterVoiceEngineObserver(_))
+        .WillOnce(Return(0));
+    EXPECT_CALL(voice_engine_, DeRegisterVoiceEngineObserver())
+        .WillOnce(Return(0));
+    EXPECT_CALL(voice_engine_, audio_transport());

[ossu, 2016/11/03 14:02:04]

Don't these require actions, i.e. WillOnce(Return(nullptr)) or something?

[aleloi, 2016/11/08 11:46:41]

I think the default action (which is Return(nullptr)) runs if you don't specify
anything.

I replaced the ON_CALL below with WillOnce for audio_device_module to make it
shorter and more consistent.

+    EXPECT_CALL(voice_engine_, audio_processing());
+    EXPECT_CALL(voice_engine_, audio_device_module());
+    ON_CALL(voice_engine_, audio_device_module())
+        .WillByDefault(Return(&mock_audio_device_));
     AudioState::Config config;
     config.voice_engine = &voice_engine_;
     audio_state_ = AudioState::Create(config);
 
     EXPECT_CALL(voice_engine_, ChannelProxyFactory(kChannelId))
         .WillOnce(Invoke([this](int channel_id) {
           EXPECT_FALSE(channel_proxy_);
           channel_proxy_ = new testing::StrictMock<MockVoEChannelProxy>();
           EXPECT_CALL(*channel_proxy_, SetLocalSSRC(kLocalSsrc)).Times(1);
           EXPECT_CALL(*channel_proxy_, SetNACKStatus(true, 15)).Times(1);
@@ skipping 79 matching lines @@
  private:
   SimulatedClock simulated_clock_;
   PacketRouter packet_router_;
   testing::NiceMock<MockCongestionObserver> bitrate_observer_;
   testing::NiceMock<MockRemoteBitrateObserver> remote_bitrate_observer_;
   rtc::scoped_refptr<AudioDecoderFactory> decoder_factory_;
   MockCongestionController congestion_controller_;
   MockRemoteBitrateEstimator remote_bitrate_estimator_;
   MockRtcEventLog event_log_;
   testing::StrictMock<MockVoiceEngine> voice_engine_;
+  testing::NiceMock<webrtc::test::MockAudioDeviceModule> mock_audio_device_;

[ossu, 2016/11/03 14:02:04]

What's so nice about it!? :)
Why not just use an unadorned MockAudioDeviceModule? Are there millions of calls
you don't want to implement actions for?

[aleloi, 2016/11/08 11:46:41]

Probably an ordinary mock make sense here, because of the way |audio_device| is
used in AudioState (only one method is called). I read this quote from the mock
cook book:

    Finally, you should be very cautious about when to use naggy or strict
mocks, as they tend to make tests more brittle and harder to maintain. When you
refactor your code without changing its externally visible behavior, ideally you
should't need to update any tests.

   rtc::scoped_refptr<AudioState> audio_state_;
   AudioReceiveStream::Config stream_config_;
   testing::StrictMock<MockVoEChannelProxy>* channel_proxy_ = nullptr;
 };
 
 void BuildOneByteExtension(std::vector<uint8_t>::iterator it,
                            int id,
                            uint32_t extension_value,
                            size_t value_length) {
   const uint16_t kRtpOneByteHeaderExtensionId = 0xBEDE;
@@ skipping 166 matching lines @@
   ConfigHelper helper;
   internal::AudioReceiveStream recv_stream(
       helper.congestion_controller(), helper.config(), helper.audio_state(),
       helper.event_log());
   EXPECT_CALL(*helper.channel_proxy(),
       SetChannelOutputVolumeScaling(FloatEq(0.765f)));
   recv_stream.SetGain(0.765f);
 }
 }  // namespace test
 }  // namespace webrtc