MockAecDump and integration tests between AecDump and AudioProcessing

This CL adds a MockAecDump and integration tests that inject the mock
into AudioProcessingImpl. The tests check the call pattern between
AudioProcessingImpl and AecDump. The existing tests ApmTest.* and
DebugDumpTest.* (not touched by this CL) check that the data written
by AecDumpImpl is valid.

The tests check that the protobuf-writing methods for the different
protobuf message types in audio_processing/debug.proto are indeed
called for the different modes of AudioProcessingImpl operation.

BUG=webrtc:7404

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

webrtc/modules/audio_processing/BUILD.gn

@@ -559,6 +559,7 @@ if (rtc_include_tests) {
       "../../system_wrappers:system_wrappers",
       "../../test:test_support",
       "../audio_coding:neteq_tools",
+      "aec_dump:mock_aec_dump_unittests",
       "test/conversational_speech:unittest",
       "//testing/gmock",
       "//testing/gtest",

webrtc/modules/audio_processing/aec_dump/BUILD.gn

@@ -1,3 +1,11 @@
+# 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.
+
 import("../../../webrtc.gni")  # This contains def of 'rtc_enable_protobuf'
 
 rtc_source_set("aec_dump") {
@@ -14,6 +22,38 @@ rtc_source_set("aec_dump") {
   ]
 }
 
+rtc_source_set("mock_aec_dump") {
+  testonly = true
+  sources = [
+    "mock_aec_dump.cc",
+    "mock_aec_dump.h",
+  ]
+
+  deps = [
+    "..:aec_dump_interface",
+  ]
+  public_deps = [
+    "../..:module_api",
+    "../../../test:test_support",
+    "//testing/gmock",
+  ]
+}
+
+rtc_source_set("mock_aec_dump_unittests") {
+  testonly = true
+
+  sources = [
+    "aec_dump_integration_test.cc",
+  ]
+
+  deps = [
+    ":mock_aec_dump",
+    "..:audio_processing",
+    "../../../base:rtc_base_approved",
+    "//testing/gtest",
+  ]
+}
+
 if (rtc_enable_protobuf) {
   rtc_source_set("aec_dump_impl") {
     sources = [

webrtc/modules/audio_processing/aec_dump/aec_dump_integration_test.cc

@@ -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.
+ */
+
+#include <utility>
+
+#include "webrtc/base/ptr_util.h"
+#include "webrtc/modules/audio_processing/aec_dump/mock_aec_dump.h"
+#include "webrtc/modules/audio_processing/include/audio_processing.h"
+
+using testing::_;
+using testing::AtLeast;
+using testing::Exactly;
+using testing::Matcher;
+using testing::StrictMock;
+
+namespace {
+std::unique_ptr<webrtc::AudioProcessing> CreateAudioProcessing() {
+  webrtc::Config config;
+  std::unique_ptr<webrtc::AudioProcessing> apm(
+      webrtc::AudioProcessing::Create(config));
+  RTC_DCHECK(apm);
+  return apm;
+}
+
+std::unique_ptr<webrtc::test::MockAecDump> CreateMockAecDump() {
+  auto mock_aec_dump =
+      rtc::MakeUnique<testing::StrictMock<webrtc::test::MockAecDump>>();
+  EXPECT_CALL(*mock_aec_dump.get(), WriteConfig(_)).Times(AtLeast(1));
+  EXPECT_CALL(*mock_aec_dump.get(), WriteInitMessage(_)).Times(AtLeast(1));
+  return std::unique_ptr<webrtc::test::MockAecDump>(std::move(mock_aec_dump));
+}
+
+std::unique_ptr<webrtc::AudioFrame> CreateFakeFrame() {
+  auto fake_frame = rtc::MakeUnique<webrtc::AudioFrame>();
+  fake_frame->num_channels_ = 1;
+  fake_frame->sample_rate_hz_ = 48000;
+  fake_frame->samples_per_channel_ = 480;
+  return fake_frame;
+}
+
+}  // namespace
+
+TEST(AecDumpIntegration, ConfigurationAndInitShouldBeLogged) {
+  auto apm = CreateAudioProcessing();
+
+  apm->AttachAecDump(CreateMockAecDump());
+}
+
+TEST(AecDumpIntegration,
+     RenderStreamShouldBeLoggedOnceEveryProcessReverseStream) {
+  auto apm = CreateAudioProcessing();
+  auto mock_aec_dump = CreateMockAecDump();
+  auto fake_frame = CreateFakeFrame();
+
+  EXPECT_CALL(*mock_aec_dump.get(),
+              WriteRenderStreamMessage(Matcher<const webrtc::AudioFrame&>(_)))
+      .Times(Exactly(1));
+
+  apm->AttachAecDump(std::move(mock_aec_dump));
+  apm->ProcessReverseStream(fake_frame.get());
+}
+
+TEST(AecDumpIntegration, CaptureStreamShouldBeLoggedOnceEveryProcessStream) {
+  auto apm = CreateAudioProcessing();
+  auto mock_aec_dump = CreateMockAecDump();
+  auto fake_frame = CreateFakeFrame();
+
+  EXPECT_CALL(*mock_aec_dump.get(),
+              AddCaptureStreamInput(Matcher<const webrtc::AudioFrame&>(_)))
+      .Times(AtLeast(1));
+
+  EXPECT_CALL(*mock_aec_dump.get(),
+              AddCaptureStreamOutput(Matcher<const webrtc::AudioFrame&>(_)))
+      .Times(Exactly(1));
+
+  EXPECT_CALL(*mock_aec_dump.get(), AddAudioProcessingState(_))
+      .Times(Exactly(1));
+
+  EXPECT_CALL(*mock_aec_dump.get(), WriteCaptureStreamMessage())
+      .Times(Exactly(1));
+
+  apm->AttachAecDump(std::move(mock_aec_dump));
+  apm->ProcessStream(fake_frame.get());
+}

webrtc/modules/audio_processing/aec_dump/mock_aec_dump.cc

@@ -0,0 +1,19 @@
+/*
+ *  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.
+ */
+#include "webrtc/modules/audio_processing/aec_dump/mock_aec_dump.h"
+
+namespace webrtc {
+
+namespace test {
+
+MockAecDump::MockAecDump() = default;
+MockAecDump::~MockAecDump() = default;
+}
+}

webrtc/modules/audio_processing/aec_dump/mock_aec_dump.h

@@ -0,0 +1,50 @@
+/*
+ *  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_PROCESSING_AEC_DUMP_MOCK_AEC_DUMP_H_
+#define WEBRTC_MODULES_AUDIO_PROCESSING_AEC_DUMP_MOCK_AEC_DUMP_H_
+
+#include <memory>
+
+#include "webrtc/modules/audio_processing/include/aec_dump.h"
+#include "webrtc/modules/include/module_common_types.h"
+#include "webrtc/test/gmock.h"
+
+namespace webrtc {
+
+namespace test {
+
+class MockAecDump : public AecDump {
+ public:
+  MockAecDump();
+  virtual ~MockAecDump();
+
+  MOCK_METHOD1(WriteInitMessage,
+               void(const InternalAPMStreamsConfig& streams_config));
+
+  MOCK_METHOD1(AddCaptureStreamInput, void(const FloatAudioFrame& src));
+  MOCK_METHOD1(AddCaptureStreamOutput, void(const FloatAudioFrame& src));
+  MOCK_METHOD1(AddCaptureStreamInput, void(const AudioFrame& frame));
+  MOCK_METHOD1(AddCaptureStreamOutput, void(const AudioFrame& frame));
+  MOCK_METHOD1(AddAudioProcessingState,
+               void(const AudioProcessingState& state));
+  MOCK_METHOD0(WriteCaptureStreamMessage, void());
+
+  MOCK_METHOD1(WriteRenderStreamMessage, void(const AudioFrame& frame));
+  MOCK_METHOD1(WriteRenderStreamMessage, void(const FloatAudioFrame& src));
+
+  MOCK_METHOD1(WriteConfig, void(const InternalAPMConfig& config));
+};
+
+}  // namespace test
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AEC_DUMP_MOCK_AEC_DUMP_H_