Injectable audio encoders: WebRtcVoiceEngine and company

These are the changes made to WebRtcVoiceEngine and surrounding
code. It still contains some things that are inelegant, like how
AudioCodecSpec and AudioFormatInfo is ferried around in
SendCodecSpec. This should probably be resolved before landing.

There are also a few test still that are disabled. They should be
removed or fixed, as the case may be.

I've put this CL up to get a better overview of the changes made and
how reviewable they are.

BUG=webrtc:5806

Review-Url: https://codereview.webrtc.org/2705093002
Cr-Commit-Position: refs/heads/master@{#17904}

webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h

@@ -47,6 +47,10 @@ class MockAudioEncoder : public AudioEncoder {
   MOCK_METHOD1(OnReceivedUplinkPacketLossFraction,
                void(float uplink_packet_loss_fraction));
 
+  MOCK_METHOD2(EnableAudioNetworkAdaptor,
+               bool(const std::string& config_string,
+                    RtcEventLog* event_log));
+
   // Note, we explicitly chose not to create a mock for the Encode method.
   MOCK_METHOD3(EncodeImpl,
                EncodedInfo(uint32_t timestamp,

webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder_factory.h

@@ -0,0 +1,91 @@
+/*
+ *  Copyright (c) 2017 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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_MOCK_MOCK_AUDIO_ENCODER_FACTORY_H_
+#define WEBRTC_MODULES_AUDIO_CODING_CODECS_MOCK_MOCK_AUDIO_ENCODER_FACTORY_H_
+
+#include <memory>
+#include <vector>
+
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/modules/audio_coding/codecs/audio_encoder_factory.h"
+#include "webrtc/test/gmock.h"
+
+namespace webrtc {
+
+class MockAudioEncoderFactory : public AudioEncoderFactory {
+ public:
+  MOCK_METHOD0(GetSupportedEncoders, std::vector<AudioCodecSpec>());
+  MOCK_METHOD1(QueryAudioEncoder,
+               rtc::Optional<AudioCodecInfo>(const SdpAudioFormat& format));
+
+  std::unique_ptr<AudioEncoder> MakeAudioEncoder(int payload_type,
+                                                 const SdpAudioFormat& format) {
+    std::unique_ptr<AudioEncoder> return_value;
+    MakeAudioEncoderMock(payload_type, format, &return_value);
+    return return_value;
+  }
+  MOCK_METHOD3(MakeAudioEncoderMock,
+               void(int payload_type,
+                    const SdpAudioFormat& format,
+                    std::unique_ptr<AudioEncoder>* return_value));
+
+  // Creates a MockAudioEncoderFactory with no formats and that may not be
+  // invoked to create a codec - useful for initializing a voice engine, for
+  // example.
+  static rtc::scoped_refptr<webrtc::MockAudioEncoderFactory>
+  CreateUnusedFactory() {
+    using testing::_;
+    using testing::AnyNumber;
+    using testing::Return;
+
+    rtc::scoped_refptr<webrtc::MockAudioEncoderFactory> factory =
+        new rtc::RefCountedObject<webrtc::MockAudioEncoderFactory>;
+    ON_CALL(*factory.get(), GetSupportedEncoders())
+        .WillByDefault(Return(std::vector<webrtc::AudioCodecSpec>()));
+    ON_CALL(*factory.get(), QueryAudioEncoder(_))
+        .WillByDefault(Return(rtc::Optional<AudioCodecInfo>()));
+
+    EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
+    EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
+    EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _)).Times(0);
+    return factory;
+  }
+
+  // Creates a MockAudioEncoderFactory with no formats that may be invoked to
+  // create a codec any number of times. It will, though, return nullptr on each
+  // call, since it supports no codecs.
+  static rtc::scoped_refptr<webrtc::MockAudioEncoderFactory>
+  CreateEmptyFactory() {
+    using testing::_;
+    using testing::AnyNumber;
+    using testing::Return;
+    using testing::SetArgPointee;
+
+    rtc::scoped_refptr<webrtc::MockAudioEncoderFactory> factory =
+        new rtc::RefCountedObject<webrtc::MockAudioEncoderFactory>;
+    ON_CALL(*factory.get(), GetSupportedEncoders())
+        .WillByDefault(Return(std::vector<webrtc::AudioCodecSpec>()));
+    ON_CALL(*factory.get(), QueryAudioEncoder(_))
+        .WillByDefault(Return(rtc::Optional<AudioCodecInfo>()));
+    ON_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
+        .WillByDefault(SetArgPointee<2>(nullptr));
+
+    EXPECT_CALL(*factory.get(), GetSupportedEncoders()).Times(AnyNumber());
+    EXPECT_CALL(*factory.get(), QueryAudioEncoder(_)).Times(AnyNumber());
+    EXPECT_CALL(*factory.get(), MakeAudioEncoderMock(_, _, _))
+        .Times(AnyNumber());
+    return factory;
+  }
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_MOCK_MOCK_AUDIO_ENCODER_FACTORY_H_