Unittest for the locking in APM

webrtc/modules/audio_processing/audio_processing_impl_locking_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 "webrtc/modules/audio_processing/audio_processing_impl.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/config.h"
+#include "webrtc/modules/audio_processing/test/test_utils.h"
+#include "webrtc/modules/interface/module_common_types.h"
+#include "webrtc/system_wrappers/interface/event_wrapper.h"
+#include "webrtc/system_wrappers/interface/sleep.h"
+#include "webrtc/system_wrappers/interface/thread_wrapper.h"
+
+namespace webrtc {
+
+namespace {
+
+// Type of the render thread APM API call to use in the test.
+enum class RenderApiFunctionImplementation {
+  ProcessReverseStreamImplementation1,
+  ProcessReverseStreamImplementation2,
+  AnalyzeReverseStreamImplementation1,
+  AnalyzeReverseStreamImplementation2
+};
+// Type of the capture thread APM API call to use in the test.
+enum class CaptureApiFunctionImplementation {
+  ProcessStreamImplementation1,
+  ProcessStreamImplementation2,
+  ProcessStreamImplementation3
+};
+// The runtime parameter setting scheme to use in the test.
+enum class RuntimeParameterSettingScheme {
+  SparseStreamMetadataChangeScheme,
+  ExtremeStreamMetadataChangeScheme,
+  FixedMonoStreamMetadataScheme,
+  FixedStereoStreamMetadataScheme
+};
+enum class AecType {
+  BasicWebRtcAecSettings,
+  AecTurnedOff,
+  BasicWebRtcAecSettingsWithExtentedFilter,

[hlundin-webrtc, 2015/10/27 10:54:24]

I gather that BasicWebRtcAecSettingsWith* alters the configuration from the
default one received from BasicWebRtcAecSettings. That is, the default setting
does not enable extended filter mode, for instance, but the extra test case does
test with that. What if the default config is changed? Can you somehow detect
that and throw and error, so that the one doing that change can also flip those
tests?

[peah-webrtc, 2015/10/29 09:00:09]

Great point! Unfortunately the APM api does not allow for that to be checked. I
instead revised the code to avoid relying on the default values for those.


Done.

+  BasicWebRtcAecSettingsWithDelayAgnosticAec,
+  BasicWebRtcAecSettingsWithAecMobile
+};
+
+// The configuration for the test to use.
+struct TestConfig {
+  RenderApiFunctionImplementation render_api_function;
+  CaptureApiFunctionImplementation capture_api_function;
+  RuntimeParameterSettingScheme runtime_parameter_setting_scheme;
+  int initial_sample_rate;

[hlundin-webrtc, 2015/10/27 10:54:25]

Unit should be included in variable name, e.g., initial_sample_rate_hz.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+  AecType aec_type;
+  int min_number_of_calls;
+};
+
+// Provides thread_safe random numbers.

[hlundin-webrtc, 2015/10/27 10:54:25]

thread_safe -> thread-safe

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+class ThreadSafeRandomNumberGenerator {

[the sun, 2015/10/27 11:02:15]

Please use webrtc/test/random.h instead.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+ public:
+  ThreadSafeRandomNumberGenerator() : ThreadSafeRandomNumberGenerator(42) {}
+
+  explicit ThreadSafeRandomNumberGenerator(int seed) { srand(seed); }

[kwiberg-webrtc, 2015/10/26 14:43:14]

Since the sequence of random numbers observed by a given thread will depend on
the thread scheduling and thus be unpredictable anyway, providing a constructor
with a seed argument is probably just misleading.

[hlundin-webrtc, 2015/10/27 10:54:25]

Agree. But if you do keep this constructor, the argument should be an unsigned,
not an int, to match the argument type of srand(unsigned).

[peah-webrtc, 2015/10/29 09:00:08]

Good point. This is now changed to use the random number generator in random.h
instead.

[peah-webrtc, 2015/10/29 09:00:09]

Another good point! This is now, however changed to use the random number
generator in random.h instead.

+
+  int operator()() {
+    rtc::CritScope cs(&crit_);
+    return rand();
+  }
+
+ private:
+  rtc::CriticalSection crit_;
+};
+
+// Class for implementing the tests of the locks in the audio processing module.
+class AudioProcessingImpLockTest : public ::testing::TestWithParam<TestConfig> {

[the sun, 2015/10/27 11:02:15]

nit: final

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+ public:
+  AudioProcessingImpLockTest()
+      : test_complete_(EventWrapper::Create()),
+        render_thread_(
+            ThreadWrapper::CreateThread(CbRenderThread, this, "render")),
+        capture_thread_(
+            ThreadWrapper::CreateThread(CbCaptureThread, this, "capture")),
+        stats_thread_(
+            ThreadWrapper::CreateThread(CbStatsThread, this, "stats")) {
+    // Setup the two-dimensional arrays needed for the APM API calls.

[hlundin-webrtc, 2015/10/27 10:54:25]

Nit: Setup -> Set up
The former is a noun or adjective, the latter is the verb you are looking for.

[peah-webrtc, 2015/10/29 09:00:08]

Great catch!

Done.

+    capture_thread_only_state_.capture_input_framechannels_.resize(2 * 480);
+    capture_thread_only_state_.capture_input_frame.resize(2);
+    capture_thread_only_state_.capture_input_frame[0] =
+        &capture_thread_only_state_.capture_input_framechannels_[0];
+    capture_thread_only_state_.capture_input_frame[1] =
+        &capture_thread_only_state_.capture_input_framechannels_[480];
+
+    capture_thread_only_state_.capture_output_frame_channels.resize(2 * 480);
+    capture_thread_only_state_.capture_output_frame.resize(2);
+    capture_thread_only_state_.capture_output_frame[0] =
+        &capture_thread_only_state_.capture_output_frame_channels[0];
+    capture_thread_only_state_.capture_output_frame[1] =
+        &capture_thread_only_state_.capture_output_frame_channels[480];
+
+    render_thread_only_state_.render_input_frame_channels.resize(2 * 480);
+    render_thread_only_state_.render_input_frame.resize(2);
+    render_thread_only_state_.render_input_frame[0] =
+        &render_thread_only_state_.render_input_frame_channels[0];
+    render_thread_only_state_.render_input_frame[1] =
+        &render_thread_only_state_.render_input_frame_channels[480];
+
+    render_thread_only_state_.render_output_frame_channels.resize(2 * 480);
+    render_thread_only_state_.render_output_frame.resize(2);
+    render_thread_only_state_.render_output_frame[0] =
+        &render_thread_only_state_.render_output_frame_channels[0];
+    render_thread_only_state_.render_output_frame[1] =
+        &render_thread_only_state_.render_output_frame_channels[480];
+  }
+
+  // Run the test with a timeout.
+  EventTypeWrapper RunTest() {
+    StartThreads();
+    return test_complete_->Wait(kTestTimeOutLimit);
+  }
+
+  virtual void SetUp() {

[hlundin-webrtc, 2015/10/27 10:54:25]

override, and not virtual.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    apm_.reset(AudioProcessingImpl::Create());
+    test_config_ = static_cast<TestConfig>(GetParam());
+
+    EXPECT_EQ(apm_->kNoError, apm_->level_estimator()->Enable(true));

[hlundin-webrtc, 2015/10/27 10:54:25]

Does it make sense to continue with the test if any of the EXPECT_EQs in this
method fails? If not, change them to ASSERT_EQ instead.

[peah-webrtc, 2015/10/29 09:00:08]

Good point!

Done.

+    EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
+
+    EXPECT_EQ(apm_->kNoError,
+              apm_->gain_control()->set_mode(GainControl::kAdaptiveAnalog));
+    EXPECT_EQ(apm_->kNoError, apm_->gain_control()->Enable(true));
+    EXPECT_EQ(apm_->kNoError,
+              apm_->gain_control()->set_mode(GainControl::kFixedDigital));
+
+    EXPECT_EQ(apm_->kNoError, apm_->noise_suppression()->Enable(true));
+    EXPECT_EQ(apm_->kNoError, apm_->voice_detection()->Enable(true));
+
+    Config config;
+    bool use_config = false;
+    if (test_config_.aec_type == AecType::AecTurnedOff) {
+      EXPECT_EQ(apm_->kNoError, apm_->echo_control_mobile()->Enable(false));
+      EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(false));
+    } else {
+      if (test_config_.aec_type ==
+          AecType::BasicWebRtcAecSettingsWithAecMobile) {
+        EXPECT_EQ(apm_->kNoError, apm_->echo_control_mobile()->Enable(true));
+      } else {
+        EXPECT_EQ(apm_->kNoError, apm_->echo_cancellation()->Enable(true));
+        EXPECT_EQ(apm_->kNoError,
+                  apm_->echo_cancellation()->enable_metrics(true));
+        EXPECT_EQ(apm_->kNoError,
+                  apm_->echo_cancellation()->enable_delay_logging(true));
+
+        if (test_config_.aec_type ==
+            AecType::BasicWebRtcAecSettingsWithExtentedFilter) {
+          config.Set<ExtendedFilter>(new ExtendedFilter(true));
+          use_config = true;
+        }
+
+        if (test_config_.aec_type ==
+            AecType::BasicWebRtcAecSettingsWithDelayAgnosticAec) {
+          config.Set<DelayAgnostic>(new DelayAgnostic(true));
+          use_config = true;
+        }
+
+        if (use_config)
+          apm_->SetExtraOptions(config);
+      }
+    }
+  }
+
+  virtual void TearDown() {

[hlundin-webrtc, 2015/10/27 10:54:25]

override, and not virtual.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    render_thread_->Stop();
+    capture_thread_->Stop();
+    stats_thread_->Stop();
+  }
+
+  // Function for generating the test configurations to use in the brief tests.
+  static std::vector<TestConfig> GenerateBriefTestConfigs() {
+    std::vector<TestConfig> test_configs;
+    for (int aec = static_cast<int>(
+             AecType::BasicWebRtcAecSettingsWithDelayAgnosticAec);
+         aec <= static_cast<int>(AecType::BasicWebRtcAecSettingsWithAecMobile);
+         aec++) {
+      TestConfig test_config;
+
+      test_config.min_number_of_calls = 300;
+
+      // Perform tests only with the extreme runtime parameter setting scheme.
+      test_config.runtime_parameter_setting_scheme =
+          RuntimeParameterSettingScheme::ExtremeStreamMetadataChangeScheme;
+
+      // Only test 16 kHz for this test suite.
+      test_config.initial_sample_rate = 16000;
+
+      // Create test config for the second processing API function set.
+      test_config.render_api_function =
+          RenderApiFunctionImplementation::ProcessReverseStreamImplementation2;
+      test_config.capture_api_function =
+          CaptureApiFunctionImplementation::ProcessStreamImplementation2;
+
+      // Create test config for the first processing API function set.
+      test_configs.push_back(test_config);
+      test_config.render_api_function =
+          RenderApiFunctionImplementation::AnalyzeReverseStreamImplementation2;
+      test_config.capture_api_function =
+          CaptureApiFunctionImplementation::ProcessStreamImplementation3;
+      test_configs.push_back(test_config);
+    }
+
+    // Return the created test configurations

[hlundin-webrtc, 2015/10/27 10:54:25]

End with .

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    return test_configs;
+  }
+
+  // Function for generating the test configurations to use in the extensive
+  // tests

[hlundin-webrtc, 2015/10/27 10:54:25]

End with .

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+  static std::vector<TestConfig> GenerateExtensiveTestConfigs() {
+    std::vector<TestConfig> test_configs;
+    // Loop over all possible test configurations

[hlundin-webrtc, 2015/10/27 10:54:24]

End with .

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    for (int render = static_cast<int>(RenderApiFunctionImplementation::
+                                           ProcessReverseStreamImplementation1);
+         render <= static_cast<int>(RenderApiFunctionImplementation::
+                                        AnalyzeReverseStreamImplementation2);
+         render++)
+      for (int capture = static_cast<int>(
+               CaptureApiFunctionImplementation::ProcessStreamImplementation1);
+           capture <=
+           static_cast<int>(
+               CaptureApiFunctionImplementation::ProcessStreamImplementation3);
+           capture++)
+        for (int aec = static_cast<int>(AecType::BasicWebRtcAecSettings);
+             aec <=
+             static_cast<int>(AecType::BasicWebRtcAecSettingsWithAecMobile);
+             aec++)
+          for (int scheme =
+                   static_cast<int>(RuntimeParameterSettingScheme::
+                                        SparseStreamMetadataChangeScheme);
+               scheme <= static_cast<int>(RuntimeParameterSettingScheme::
+                                              FixedStereoStreamMetadataScheme);
+               scheme++) {
+            TestConfig test_config;
+            test_config.min_number_of_calls = 10000;
+
+            test_config.render_api_function =
+                static_cast<RenderApiFunctionImplementation>(render);
+            test_config.capture_api_function =
+                static_cast<CaptureApiFunctionImplementation>(capture);
+            test_config.aec_type = static_cast<AecType>(aec);
+
+            // Check that the selected render and capture API calls are
+            // compatible
+            if ((((test_config.render_api_function ==
+                   RenderApiFunctionImplementation::
+                       ProcessReverseStreamImplementation1) ||
+                  (test_config.render_api_function ==
+                   RenderApiFunctionImplementation::
+                       AnalyzeReverseStreamImplementation1)) &&
+                 (test_config.capture_api_function ==
+                  CaptureApiFunctionImplementation::
+                      ProcessStreamImplementation1)) ||
+                (((test_config.render_api_function !=
+                   RenderApiFunctionImplementation::
+                       ProcessReverseStreamImplementation1) &&
+                  (test_config.render_api_function !=
+                   RenderApiFunctionImplementation::
+                       AnalyzeReverseStreamImplementation1)) &&
+                 (test_config.capture_api_function !=
+                  CaptureApiFunctionImplementation::
+                      ProcessStreamImplementation1))) {
+              // For the compatible render and capture function combinations
+              // add test configs with different initial sample rates and
+              // parameter setting schemes

[hlundin-webrtc, 2015/10/27 10:54:25]

End with .

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+              test_config.runtime_parameter_setting_scheme =
+                  static_cast<RuntimeParameterSettingScheme>(scheme);
+
+              test_config.initial_sample_rate = 8000;
+              test_configs.push_back(test_config);
+
+              test_config.initial_sample_rate = 16000;
+              test_configs.push_back(test_config);
+
+              if (test_config.aec_type !=
+                  AecType::BasicWebRtcAecSettingsWithAecMobile) {
+                test_config.initial_sample_rate = 32000;
+                test_configs.push_back(test_config);
+
+                test_config.initial_sample_rate = 48000;
+                test_configs.push_back(test_config);
+              }
+            }
+          }
+    // Return the created test configurations

[hlundin-webrtc, 2015/10/27 10:54:25]

End with .

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    return test_configs;
+  }
+
+ private:
+  static const int kTestTimeOutLimit = 10 * 60 * 1000;
+  static const int kMaxCallDifference = 10;
+  static constexpr float kRenderInputFloatLevel = 0.5f;

[hlundin-webrtc, 2015/10/27 10:54:24]

constexpr is still banned in Chromium. See https://chromium-cpp.appspot.com/.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+  static constexpr float kCaptureInputFloatLevel = 0.03125f;

[hlundin-webrtc, 2015/10/27 10:54:25]

And here.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+  static const int kRenderInputFixLevel = 16384;
+  static const int kCaptureInputFixLevel = 1024;
+
+  // Generates random number between -(amplitude+1) and amplitude
+  int16_t GenerateRandomInt16(int16_t amplitude) const {
+    return ((rand_gen() % (amplitude + amplitude + 1)) - (amplitude + 1));
+  }
+
+  // Populates a float audio frame with random data.
+  void PopulateAudioFrame(float** frame,
+                          float amplitude,
+                          int num_channels,
+                          int samples_per_channel) const {
+    for (int ch = 0; ch < num_channels; ch++) {

[hlundin-webrtc, 2015/10/27 10:54:25]

Nit: ch and k should probably both be size_t, being indices into an array.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+      for (int k = 0; k < samples_per_channel; k++) {
+        // Store random 16 bit quantized float number between the specified
+        // limits.
+        frame[ch][k] = amplitude *
+                       static_cast<float>(GenerateRandomInt16(32767)) /
+                       32768.0f;
+      }
+    }
+  }
+
+  // Populates an audioframe frame of AudioFrame type with random data.
+  void PopulateAudioFrame(AudioFrame* frame, int16_t amplitude) const {
+    assert(amplitude > 0);

[kwiberg-webrtc, 2015/10/26 14:43:14]

ASSERT_GT, or maybe EXPECT_GT

[hlundin-webrtc, 2015/10/27 10:54:24]

Agree. Never use assert, CHECK or DCHECK in unit test code. If they trigger,
they'll bring the whole test binary down; hundreds of test targets will die in
vain.

On the other hand, it is good to know that ASSERT_* doesn't necessarily stop
that test target. It only aborts the current function. See
https://code.google.com/p/googletest/wiki/AdvancedGuide#Propagating_Fatal_Fai....

[peah-webrtc, 2015/10/29 09:00:08]

Done.

[peah-webrtc, 2015/10/29 09:00:09]

Thanks for the explanation! That is a great point and I guess that ASSERT_*
should always be the desired behavior!

Done.

+    assert(amplitude <= 32767);

[kwiberg-webrtc, 2015/10/26 14:43:14]

Same, if you want to keep this no-op check.

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    for (int ch = 0; ch < frame->num_channels_; ch++) {
+      for (int k = 0; k < static_cast<int>(frame->samples_per_channel_); k++) {
+        // Store random 16 bit quantized float number between -1 and 1.
+        frame->data_[k * ch] = GenerateRandomInt16(amplitude);
+      }
+    }
+  }
+
+  // Thread callback for the render thread
+  static bool CbRenderThread(void* context) {

[the sun, 2015/10/27 11:02:15]

Drop the "Cb", here and below. I think it is confusing to call a thread function
a callback.

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    return reinterpret_cast<AudioProcessingImpLockTest*>(context)
+        ->CbRenderImpl();

[the sun, 2015/10/27 11:02:15]

CbRenderImpl -> RenderThreadImpl or simply RenderThread. And below.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+  }
+
+  // Thread callback for the capture thread
+  static bool CbCaptureThread(void* context) {
+    return reinterpret_cast<AudioProcessingImpLockTest*>(context)
+        ->CbCaptureImpl();
+  }
+
+  // Thread callback for the stats thread
+  static bool CbStatsThread(void* context) {
+    return reinterpret_cast<AudioProcessingImpLockTest*>(context)
+        ->CbStatsImpl();
+  }
+
+  // Tests whether all the required render and capture side calls have been
+  // done.
+  bool TestDone() {
+    rtc::CritScope cs(&crit_);
+    return ((shared_thread_counter_state_.render_count >
+             test_config_.min_number_of_calls) &&
+            (shared_thread_counter_state_.capture_count >
+             test_config_.min_number_of_calls));
+  }
+
+  // Sleeps a random time between 0 and max_sleep milliseconds.
+  void SleepRandomTime(int max_sleep) const {

[kwiberg-webrtc, 2015/10/26 14:43:14]

SleepRandomMs?

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    int sleeptime = rand_gen() % (max_sleep + 1);
+    SleepMs(sleeptime);
+  }
+
+  // Implements the callback functionality for the statistics
+  // collection thread.
+  bool CbStatsImpl() {
+    SleepRandomTime(100);
+
+    (void)apm_->echo_cancellation()->is_enabled();

[hlundin-webrtc, 2015/10/27 10:54:24]

Why do you need the C-style (void) cast?

[the sun, 2015/10/27 11:02:15]

Why do you need to call these at all? If you do, don't you want to EXPECT_EQ()
the results?

[peah-webrtc, 2015/10/29 09:00:08]

I'm interested in catching any side-effects present in the functions. Some are
for sure at the moment trivial getters but for instance the
speech_probablitity() getter is more advanced.

It is not that easy to sanity check the outputs of these properly in all cases
but I tried to add some basic checks now where it is possible. 

[peah-webrtc, 2015/10/29 09:00:09]

Ouch! Old habit! I'm used to having build errors when not catching function
outputs.

Done.

+    (void)apm_->echo_cancellation()->stream_drift_samples();
+    (void)apm_->echo_control_mobile()->is_enabled();
+    (void)apm_->gain_control()->is_enabled();
+    (void)apm_->gain_control()->stream_analog_level();
+    (void)apm_->noise_suppression()->is_enabled();
+    (void)apm_->noise_suppression()->speech_probability();
+    (void)apm_->voice_detection()->is_enabled();
+
+    return true;
+  }
+
+  // Implements the callback functionality for the render thread.
+  bool CbRenderImpl() {
+    // Conditional wait to ensure that a capture call has been done
+    // before the first render call is performed (implicitly
+    // required by the APM API).
+    if (render_thread_only_state_.first_render_side_call_) {
+      bool capture_side_called_local;
+      do {
+        {
+          rtc::CritScope cs(&crit_initial_sync_);
+          capture_side_called_local =
+              shared_thread_init_state_.capture_side_called;
+        }
+        SleepRandomTime(3);
+      } while (!capture_side_called_local);
+
+      render_thread_only_state_.first_render_side_call_ = false;
+    }
+
+    // Sleep a random time to simulate thread jitter.
+    SleepRandomTime(3);
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.
+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Ensure that the number of render and capture calls do not
+    // differ too much.
+    int frame_counter_difference;
+    do {
+      {
+        rtc::CritScope cs(&crit_);
+        frame_counter_difference =
+            (shared_thread_counter_state_.render_count -
+             (shared_thread_counter_state_.capture_count + kMaxCallDifference));
+      }
+      if (frame_counter_difference > 0)
+        SleepMs(1);
+    } while (frame_counter_difference > 0);
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.

[hlundin-webrtc, 2015/10/27 10:54:25]

Do you have to test this twice in the same function?

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Apply any specified render side APM non-processing runtime calls.
+    ApplyRenderRuntimeSettingScheme();
+
+    // Apply the render side processing call.
+    CallRenderSide();
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.

[hlundin-webrtc, 2015/10/27 10:54:25]

Thrice...?!

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Increase the number of render-side calls.
+    rtc::CritScope cs(&crit_);
+    shared_thread_counter_state_.render_count++;
+
+    return true;
+  }
+
+  // Makes the capture side processing API call.
+  void CallCaptureSide() {
+    // Prepare a proper capture side processing API call input.
+    PrepareCaptureFrame();
+
+    // Set the stream delay
+    (void)apm_->set_stream_delay_ms(30);
+
+    // Call the specified capture side API processing method.
+    int result = AudioProcessing::kNoError;
+    switch (test_config_.capture_api_function) {
+      case CaptureApiFunctionImplementation::ProcessStreamImplementation1:
+        result = apm_->ProcessStream(&capture_thread_only_state_.capture_frame);
+        break;
+      case CaptureApiFunctionImplementation::ProcessStreamImplementation2:
+        result = apm_->ProcessStream(
+            &capture_thread_only_state_.capture_input_frame[0],
+            capture_thread_only_state_.capture_input_samples_per_channel,
+            capture_thread_only_state_.capture_input_sample_rate_hz,
+            capture_thread_only_state_.capture_input_channel_layout,
+            capture_thread_only_state_.capture_output_sample_rate_hz,
+            capture_thread_only_state_.capture_output_channel_layout,
+            &capture_thread_only_state_.capture_output_frame[0]);
+        break;
+      case CaptureApiFunctionImplementation::ProcessStreamImplementation3:
+        result = apm_->ProcessStream(
+            &capture_thread_only_state_.capture_input_frame[0],
+            capture_thread_only_state_.capture_input_stream_config,
+            capture_thread_only_state_.capture_output_stream_config,
+            &capture_thread_only_state_.capture_output_frame[0]);
+        break;
+      default:
+        assert(false);
+    }
+
+    // Check the return code for error.
+    EXPECT_EQ(AudioProcessing::kNoError, result);
+  }
+
+  // Prepares the render side frame and the accompanying metadata
+  // with the appropriate information.
+  void PrepareRenderFrame() {
+    // Restrict to a common fixed sample rate if the AudioFrame interface is
+    // used.
+    if ((test_config_.render_api_function ==
+         RenderApiFunctionImplementation::
+             AnalyzeReverseStreamImplementation1) ||
+        (test_config_.render_api_function ==
+         RenderApiFunctionImplementation::
+             ProcessReverseStreamImplementation1) ||
+        (test_config_.aec_type !=
+         AecType::BasicWebRtcAecSettingsWithAecMobile)) {
+      render_thread_only_state_.render_input_sample_rate_hz =
+          test_config_.initial_sample_rate;
+      render_thread_only_state_.render_output_sample_rate_hz =
+          test_config_.initial_sample_rate;
+    }
+
+    // Prepare the audioframe data and metadata
+    render_thread_only_state_.render_input_samples_per_channel =
+        render_thread_only_state_.render_input_sample_rate_hz *
+        AudioProcessing::kChunkSizeMs / 1000;
+    render_thread_only_state_.render_frame.sample_rate_hz_ =
+        render_thread_only_state_.render_input_sample_rate_hz;
+    render_thread_only_state_.render_frame.num_channels_ =
+        render_thread_only_state_.render_input_number_of_channels;
+    render_thread_only_state_.render_frame.samples_per_channel_ =
+        render_thread_only_state_.render_input_samples_per_channel;
+    memset(render_thread_only_state_.render_frame.data_, 0,
+           render_thread_only_state_.render_input_samples_per_channel *
+               sizeof(render_thread_only_state_.render_frame.data_[0]));
+    PopulateAudioFrame(&render_thread_only_state_.render_frame,
+                       kRenderInputFixLevel);
+
+    // Prepare the float audio input data and metadata.
+    render_thread_only_state_.render_input_stream_config.set_sample_rate_hz(
+        render_thread_only_state_.render_input_sample_rate_hz);
+    render_thread_only_state_.render_input_stream_config.set_num_channels(
+        render_thread_only_state_.render_input_number_of_channels);
+    render_thread_only_state_.render_input_stream_config.set_has_keyboard(
+        false);
+    PopulateAudioFrame(
+        &render_thread_only_state_.render_input_frame[0],
+        kRenderInputFloatLevel,
+        render_thread_only_state_.render_input_number_of_channels,
+        render_thread_only_state_.render_input_samples_per_channel);
+    render_thread_only_state_.render_input_channel_layout =
+        (render_thread_only_state_.render_input_number_of_channels == 1
+             ? AudioProcessing::ChannelLayout::kMono
+             : AudioProcessing::ChannelLayout::kStereo);
+
+    // Prepare the float audio output data and metadata.
+    render_thread_only_state_.render_output_samples_per_channel =
+        render_thread_only_state_.render_output_sample_rate_hz *
+        AudioProcessing::kChunkSizeMs / 1000;
+    render_thread_only_state_.render_output_stream_config.set_sample_rate_hz(
+        render_thread_only_state_.render_output_sample_rate_hz);
+    render_thread_only_state_.render_output_stream_config.set_num_channels(
+        render_thread_only_state_.render_output_number_of_channels);
+    render_thread_only_state_.render_output_stream_config.set_has_keyboard(
+        false);
+    render_thread_only_state_.render_output_channel_layout =
+        (render_thread_only_state_.render_output_number_of_channels == 1
+             ? AudioProcessing::ChannelLayout::kMono
+             : AudioProcessing::ChannelLayout::kStereo);
+  }
+
+  void PrepareCaptureFrame() {
+    // Restrict to a common fixed sample rate if the AudioFrame
+    // interface is used.
+    if (test_config_.capture_api_function ==
+        CaptureApiFunctionImplementation::ProcessStreamImplementation1) {
+      capture_thread_only_state_.capture_input_sample_rate_hz =
+          test_config_.initial_sample_rate;
+      capture_thread_only_state_.capture_output_sample_rate_hz =
+          test_config_.initial_sample_rate;
+    }
+
+    // Prepare the audioframe data and metadata.
+    capture_thread_only_state_.capture_input_samples_per_channel =
+        capture_thread_only_state_.capture_input_sample_rate_hz *
+        AudioProcessing::kChunkSizeMs / 1000;
+    capture_thread_only_state_.capture_frame.sample_rate_hz_ =
+        capture_thread_only_state_.capture_input_sample_rate_hz;
+    capture_thread_only_state_.capture_frame.num_channels_ =
+        capture_thread_only_state_.capture_input_number_of_channels;
+    capture_thread_only_state_.capture_frame.samples_per_channel_ =
+        capture_thread_only_state_.capture_input_samples_per_channel;
+    memset(capture_thread_only_state_.capture_frame.data_, 0,
+           capture_thread_only_state_.capture_input_samples_per_channel *
+               sizeof(capture_thread_only_state_.capture_frame.data_[0]));
+    PopulateAudioFrame(&capture_thread_only_state_.capture_frame,
+                       kCaptureInputFixLevel);
+
+    // Prepare the float audio input data and metadata.
+    capture_thread_only_state_.capture_input_stream_config.set_sample_rate_hz(
+        capture_thread_only_state_.capture_input_sample_rate_hz);
+    capture_thread_only_state_.capture_input_stream_config.set_num_channels(
+        capture_thread_only_state_.capture_input_number_of_channels);
+    capture_thread_only_state_.capture_input_stream_config.set_has_keyboard(
+        false);
+    PopulateAudioFrame(
+        &capture_thread_only_state_.capture_input_frame[0],
+        kCaptureInputFloatLevel,
+        capture_thread_only_state_.capture_input_number_of_channels,
+        capture_thread_only_state_.capture_input_samples_per_channel);
+    capture_thread_only_state_.capture_input_channel_layout =
+        (capture_thread_only_state_.capture_input_number_of_channels == 1
+             ? AudioProcessing::ChannelLayout::kMonoAndKeyboard
+             : AudioProcessing::ChannelLayout::kStereoAndKeyboard);
+
+    // Prepare the float audio output data and metadata.
+    capture_thread_only_state_.capture_output_samples_per_channel =
+        capture_thread_only_state_.capture_output_sample_rate_hz *
+        AudioProcessing::kChunkSizeMs / 1000;
+    capture_thread_only_state_.capture_output_stream_config.set_sample_rate_hz(
+        capture_thread_only_state_.capture_output_sample_rate_hz);
+    capture_thread_only_state_.capture_output_stream_config.set_num_channels(
+        capture_thread_only_state_.capture_output_number_of_channels);
+    capture_thread_only_state_.capture_output_stream_config.set_has_keyboard(
+        false);
+    capture_thread_only_state_.capture_output_channel_layout =
+        (capture_thread_only_state_.capture_output_number_of_channels == 1
+             ? AudioProcessing::ChannelLayout::kMono
+             : AudioProcessing::ChannelLayout::kStereo);
+  }
+
+  // Applies any render capture APM API calls and audio stream characteristics
+  // specified by the scheme for the test.
+  void ApplyRenderRuntimeSettingScheme() {
+    const int render_count_local = [this] {
+      rtc::CritScope cs(&crit_);
+      return shared_thread_counter_state_.render_count;
+    }();
+
+    // Update the number of channels and sample rates for the input and output.
+    // Note that the counts frequencies for when to set parameters
+    // are set using prime numbers in order to ensure that the
+    // permutation scheme in the parameter setting changes.
+    switch (test_config_.runtime_parameter_setting_scheme) {
+      case RuntimeParameterSettingScheme::SparseStreamMetadataChangeScheme:
+        if (render_count_local == 0)
+          render_thread_only_state_.render_input_sample_rate_hz = 16000;
+        else if (render_count_local % 47 == 0)
+          render_thread_only_state_.render_input_sample_rate_hz = 32000;
+        else if (render_count_local % 71 == 0)
+          render_thread_only_state_.render_input_sample_rate_hz = 48000;
+        else if (render_count_local % 79 == 0)
+          render_thread_only_state_.render_input_sample_rate_hz = 16000;
+        else if (render_count_local % 83 == 0)
+          render_thread_only_state_.render_input_sample_rate_hz = 8000;
+
+        if (render_count_local == 0)
+          render_thread_only_state_.render_input_number_of_channels = 1;
+        else if (render_count_local % 4 == 0)
+          render_thread_only_state_.render_input_number_of_channels =
+              (render_thread_only_state_.render_input_number_of_channels == 1
+                   ? 2
+                   : 1);
+
+        if (render_count_local == 0)
+          render_thread_only_state_.render_output_sample_rate_hz = 16000;
+        else if (render_count_local % 17 == 0)
+          render_thread_only_state_.render_output_sample_rate_hz = 32000;
+        else if (render_count_local % 19 == 0)
+          render_thread_only_state_.render_output_sample_rate_hz = 48000;
+        else if (render_count_local % 29 == 0)
+          render_thread_only_state_.render_output_sample_rate_hz = 16000;
+        else if (render_count_local % 61 == 0)
+          render_thread_only_state_.render_output_sample_rate_hz = 8000;
+
+        if (render_count_local == 0)
+          render_thread_only_state_.render_output_number_of_channels = 1;
+        else if (render_count_local % 8 == 0)
+          render_thread_only_state_.render_output_number_of_channels =
+              (render_thread_only_state_.render_output_number_of_channels == 1
+                   ? 2
+                   : 1);
+        break;
+      case RuntimeParameterSettingScheme::ExtremeStreamMetadataChangeScheme:
+        if (render_count_local == 0) {
+          render_thread_only_state_.render_input_number_of_channels = 1;
+          render_thread_only_state_.render_input_sample_rate_hz = 16000;
+          render_thread_only_state_.render_output_number_of_channels = 1;
+          render_thread_only_state_.render_output_sample_rate_hz = 16000;
+        } else {
+          render_thread_only_state_.render_input_number_of_channels =
+              (render_thread_only_state_.render_input_number_of_channels == 1
+                   ? 2
+                   : 1);
+          if (render_thread_only_state_.render_input_sample_rate_hz == 8000)
+            render_thread_only_state_.render_input_sample_rate_hz = 16000;
+          else if (render_thread_only_state_.render_input_sample_rate_hz ==
+                   16000)
+            render_thread_only_state_.render_input_sample_rate_hz = 32000;
+          else if (render_thread_only_state_.render_input_sample_rate_hz ==
+                   32000)
+            render_thread_only_state_.render_input_sample_rate_hz = 48000;
+          else if (render_thread_only_state_.render_input_sample_rate_hz ==
+                   48000)
+            render_thread_only_state_.render_input_sample_rate_hz = 8000;
+
+          render_thread_only_state_.render_output_number_of_channels =
+              (render_thread_only_state_.render_output_number_of_channels == 1
+                   ? 2
+                   : 1);
+          if (render_thread_only_state_.render_output_sample_rate_hz == 8000)
+            render_thread_only_state_.render_output_sample_rate_hz = 16000;
+          else if (render_thread_only_state_.render_output_sample_rate_hz ==
+                   16000)
+            render_thread_only_state_.render_output_sample_rate_hz = 32000;
+          else if (render_thread_only_state_.render_output_sample_rate_hz ==
+                   32000)
+            render_thread_only_state_.render_output_sample_rate_hz = 48000;
+          else if (render_thread_only_state_.render_output_sample_rate_hz ==
+                   48000)
+            render_thread_only_state_.render_output_sample_rate_hz = 8000;
+        }
+        break;
+      case RuntimeParameterSettingScheme::FixedMonoStreamMetadataScheme:
+        if (render_count_local == 0) {
+          render_thread_only_state_.render_input_sample_rate_hz = 16000;
+          render_thread_only_state_.render_input_number_of_channels = 1;
+          render_thread_only_state_.render_output_sample_rate_hz = 16000;
+          render_thread_only_state_.render_output_number_of_channels = 1;
+        }
+        break;
+      case RuntimeParameterSettingScheme::FixedStereoStreamMetadataScheme:
+        if (render_count_local == 0) {
+          render_thread_only_state_.render_input_sample_rate_hz = 16000;
+          render_thread_only_state_.render_input_number_of_channels = 2;
+          render_thread_only_state_.render_output_sample_rate_hz = 16000;
+          render_thread_only_state_.render_output_number_of_channels = 2;
+        }
+
+        break;
+      default:
+        assert(false);
+    }
+
+    // Restric the number of output channels not to exceed
+    // the number of input channels.
+    render_thread_only_state_.render_output_number_of_channels =
+        std::min(render_thread_only_state_.render_output_number_of_channels,
+                 render_thread_only_state_.render_input_number_of_channels);
+  }
+
+  // Applies any runtime capture APM API calls and audio stream characteristics
+  // specified by the scheme for the test.
+  void ApplyCaptureRuntimeSettingScheme() {
+    const int capture_count_local = [this] {
+      rtc::CritScope cs(&crit_);
+      return shared_thread_counter_state_.capture_count;
+    }();
+
+    // Update the number of channels and sample rates for the input and output.
+    // Note that the counts frequencies for when to set parameters
+    // are set using prime numbers in order to ensure that the
+    // permutation scheme in the parameter setting changes.
+    switch (test_config_.runtime_parameter_setting_scheme) {
+      case RuntimeParameterSettingScheme::SparseStreamMetadataChangeScheme:
+        if (capture_count_local == 0)
+          capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+        else if (capture_count_local % 11 == 0)
+          capture_thread_only_state_.capture_input_sample_rate_hz = 32000;
+        else if (capture_count_local % 73 == 0)
+          capture_thread_only_state_.capture_input_sample_rate_hz = 48000;
+        else if (capture_count_local % 89 == 0)
+          capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+        else if (capture_count_local % 97 == 0)
+          capture_thread_only_state_.capture_input_sample_rate_hz = 8000;
+
+        if (capture_count_local == 0)
+          capture_thread_only_state_.capture_input_number_of_channels = 1;
+        else if (capture_count_local % 4 == 0)
+          capture_thread_only_state_.capture_input_number_of_channels =
+              (capture_thread_only_state_.capture_input_number_of_channels == 1
+                   ? 2
+                   : 1);
+
+        if (capture_count_local == 0)
+          capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+        else if (capture_count_local % 5 == 0)
+          capture_thread_only_state_.capture_output_sample_rate_hz = 32000;
+        else if (capture_count_local % 47 == 0)
+          capture_thread_only_state_.capture_output_sample_rate_hz = 48000;
+        else if (capture_count_local % 53 == 0)
+          capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+        else if (capture_count_local % 71 == 0)
+          capture_thread_only_state_.capture_output_sample_rate_hz = 8000;
+
+        if (capture_count_local == 0)
+          capture_thread_only_state_.capture_output_number_of_channels = 1;
+        else if (capture_count_local % 8 == 0)
+          capture_thread_only_state_.capture_output_number_of_channels =
+              (capture_thread_only_state_.capture_output_number_of_channels == 1
+                   ? 2
+                   : 1);
+        break;
+      case RuntimeParameterSettingScheme::ExtremeStreamMetadataChangeScheme:
+        if (capture_count_local % 2 == 0) {
+          capture_thread_only_state_.capture_input_number_of_channels = 1;
+          capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+          capture_thread_only_state_.capture_output_number_of_channels = 1;
+          capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+        } else {
+          capture_thread_only_state_.capture_input_number_of_channels =
+              (capture_thread_only_state_.capture_input_number_of_channels == 1
+                   ? 2
+                   : 1);
+          if (capture_thread_only_state_.capture_input_sample_rate_hz == 8000)
+            capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+          else if (capture_thread_only_state_.capture_input_sample_rate_hz ==
+                   16000)
+            capture_thread_only_state_.capture_input_sample_rate_hz = 32000;
+          else if (capture_thread_only_state_.capture_input_sample_rate_hz ==
+                   32000)
+            capture_thread_only_state_.capture_input_sample_rate_hz = 48000;
+          else if (capture_thread_only_state_.capture_input_sample_rate_hz ==
+                   48000)
+            capture_thread_only_state_.capture_input_sample_rate_hz = 8000;
+
+          capture_thread_only_state_.capture_output_number_of_channels =
+              (capture_thread_only_state_.capture_output_number_of_channels == 1
+                   ? 2
+                   : 1);
+          if (capture_thread_only_state_.capture_output_sample_rate_hz == 8000)
+            capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+          else if (capture_thread_only_state_.capture_output_sample_rate_hz ==
+                   16000)
+            capture_thread_only_state_.capture_output_sample_rate_hz = 32000;
+          else if (capture_thread_only_state_.capture_output_sample_rate_hz ==
+                   32000)
+            capture_thread_only_state_.capture_output_sample_rate_hz = 48000;
+          else if (capture_thread_only_state_.capture_output_sample_rate_hz ==
+                   48000)
+            capture_thread_only_state_.capture_output_sample_rate_hz = 8000;
+        }
+        break;
+      case RuntimeParameterSettingScheme::FixedMonoStreamMetadataScheme:
+        if (capture_count_local == 0) {
+          capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+          capture_thread_only_state_.capture_input_number_of_channels = 1;
+          capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+          capture_thread_only_state_.capture_output_number_of_channels = 1;
+        }
+        break;
+      case RuntimeParameterSettingScheme::FixedStereoStreamMetadataScheme:
+        if (capture_count_local == 0) {
+          capture_thread_only_state_.capture_input_sample_rate_hz = 16000;
+          capture_thread_only_state_.capture_input_number_of_channels = 2;
+          capture_thread_only_state_.capture_output_sample_rate_hz = 16000;
+          capture_thread_only_state_.capture_output_number_of_channels = 2;
+        }
+
+        break;
+      default:
+        assert(false);
+    }
+
+    // Call any specified runtime APM setter and
+    // getter calls.
+    switch (test_config_.runtime_parameter_setting_scheme) {
+      case RuntimeParameterSettingScheme::SparseStreamMetadataChangeScheme:
+      case RuntimeParameterSettingScheme::FixedMonoStreamMetadataScheme:
+        break;
+      case RuntimeParameterSettingScheme::ExtremeStreamMetadataChangeScheme:
+      case RuntimeParameterSettingScheme::FixedStereoStreamMetadataScheme:
+        if ((capture_count_local % 2) == 0) {
+          EXPECT_EQ(AudioProcessing::Error::kNoError,
+                    apm_->set_stream_delay_ms(30));
+          apm_->set_stream_key_pressed(true);
+          apm_->set_output_will_be_muted(true);
+          apm_->set_delay_offset_ms(15);
+          (void)apm_->delay_offset_ms();
+          apm_->set_output_will_be_muted(true);
+          (void)apm_->num_reverse_channels();
+        } else {
+          EXPECT_EQ(AudioProcessing::Error::kNoError,
+                    apm_->set_stream_delay_ms(50));
+          apm_->set_stream_key_pressed(false);
+          apm_->set_output_will_be_muted(false);
+          apm_->set_delay_offset_ms(20);
+          (void)apm_->delay_offset_ms();
+          apm_->set_output_will_be_muted(false);
+          (void)apm_->num_reverse_channels();
+        }
+        break;
+      default:
+        ASSERT_TRUE(false);

[hlundin-webrtc, 2015/10/27 10:54:24]

Simply FAIL();
https://code.google.com/p/googletest/wiki/AdvancedGuide#Explicit_Success_and_...

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    }
+
+    // Restric the number of output channels not to exceed
+    // the number of input channels.
+    capture_thread_only_state_.capture_output_number_of_channels =
+        std::min(capture_thread_only_state_.capture_output_number_of_channels,
+                 capture_thread_only_state_.capture_input_number_of_channels);
+  }
+
+  // Makes the render side processing API call.
+  void CallRenderSide() {
+    // Prepare a proper render side processing API call input.
+    PrepareRenderFrame();
+
+    // Call the specified render side API processing method.
+    int result = AudioProcessing::kNoError;
+    switch (test_config_.render_api_function) {
+      case RenderApiFunctionImplementation::ProcessReverseStreamImplementation1:
+        result =
+            apm_->ProcessReverseStream(&render_thread_only_state_.render_frame);
+        break;
+      case RenderApiFunctionImplementation::ProcessReverseStreamImplementation2:
+        result = apm_->ProcessReverseStream(
+            &render_thread_only_state_.render_input_frame[0],
+            render_thread_only_state_.render_input_stream_config,
+            render_thread_only_state_.render_output_stream_config,
+            &render_thread_only_state_.render_output_frame[0]);
+        break;
+      case RenderApiFunctionImplementation::AnalyzeReverseStreamImplementation1:
+        result =
+            apm_->AnalyzeReverseStream(&render_thread_only_state_.render_frame);
+        break;
+      case RenderApiFunctionImplementation::AnalyzeReverseStreamImplementation2:
+        result = apm_->AnalyzeReverseStream(
+            &render_thread_only_state_.render_input_frame[0],
+            render_thread_only_state_.render_input_samples_per_channel,
+            render_thread_only_state_.render_input_sample_rate_hz,
+            render_thread_only_state_.render_input_channel_layout);
+        break;
+      default:
+        assert(false);
+    }
+
+    // Check the return code for error.
+    EXPECT_EQ(AudioProcessing::kNoError, result);
+  }
+
+  // Implements the callback functionality for the capture thread.
+  bool CbCaptureImpl() {
+    // Sleep a random time to simulate thread jitter.
+    SleepRandomTime(3);
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.

[hlundin-webrtc, 2015/10/27 10:54:24]

Same comment as earlier: do you really have to check for fatal failures three
times in this function? Especially in the light of the test only having a single
fatal failure point after thread start-up.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Ensure that there are not more capture side calls than render side
+    // calls.
+    int frame_counter_difference;
+    do {
+      {
+        rtc::CritScope cs(&crit_);
+        frame_counter_difference = shared_thread_counter_state_.capture_count -
+                                   shared_thread_counter_state_.render_count;
+      }
+      if (frame_counter_difference > 0)
+        SleepMs(1);
+    } while (frame_counter_difference > 0);
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.
+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Apply any specified capture side APM non-processing runtime calls.
+    ApplyCaptureRuntimeSettingScheme();
+
+    // Apply the capture side processing call.
+    CallCaptureSide();
+
+    // End the test early if a fatal failure (ASSERT_*) has occurred.
+    if (HasFatalFailure())
+      test_complete_->Set();
+
+    // Increase the number of capture-side calls.
+    {
+      rtc::CritScope cs(&crit_);
+      shared_thread_counter_state_.capture_count++;
+    }
+
+    // Check if the test is done.
+    if (TestDone())
+      test_complete_->Set();
+
+    // Flag that the capture side has been called at least once
+    // (needed to ensure that a capture call has been done
+    // before the first render call is performed (implicitly
+    // required by the APM API).
+    {
+      rtc::CritScope cs(&crit_initial_sync_);
+      shared_thread_init_state_.capture_side_called = true;
+    }
+
+    return true;
+  }
+
+  // Start the threads used in the test.
+  void StartThreads() {
+    ASSERT_TRUE(render_thread_->Start());
+    render_thread_->SetPriority(kRealtimePriority);
+    ASSERT_TRUE(capture_thread_->Start());
+    capture_thread_->SetPriority(kRealtimePriority);
+    ASSERT_TRUE(stats_thread_->Start());
+    stats_thread_->SetPriority(kNormalPriority);
+  }
+
+  // Event handler for the test.
+  const rtc::scoped_ptr<EventWrapper> test_complete_;
+
+  // Thread related variables.
+  rtc::CriticalSection crit_;
+  rtc::CriticalSection crit_initial_sync_;
+  rtc::scoped_ptr<ThreadWrapper> render_thread_;
+  rtc::scoped_ptr<ThreadWrapper> capture_thread_;
+  rtc::scoped_ptr<ThreadWrapper> stats_thread_;
+  mutable ThreadSafeRandomNumberGenerator rand_gen;
+
+  // The APM object.
+  rtc::scoped_ptr<AudioProcessing> apm_;
+
+  // The test configuration.
+  TestConfig test_config_;
+
+  // Variables shared by the threads during the whole test.
+  struct {
+    int render_count = 0;
+    int capture_count = 0;
+  } shared_thread_counter_state_ GUARDED_BY(crit_);
+
+  // Variable shared by the threads during the initialization phase.
+  struct {
+    bool capture_side_called;
+  } shared_thread_init_state_ GUARDED_BY(crit_initial_sync_);
+
+  // Variables only used on the capture side thread.
+  struct {
+    // Variables related to the capture side audio data and formats.
+    AudioFrame capture_frame;
+    std::vector<float*> capture_output_frame;

[hlundin-webrtc, 2015/10/27 10:54:25]

You can make most of the member variable names shorter by dropping the capture_
prefix. When you address them in the code, it is always something like
"capture_thread_only_state_.capture_input_samples_per_channel", which mentions
capture twice.

[peah-webrtc, 2015/10/29 09:00:09]

Done.

+    std::vector<float> capture_output_frame_channels;
+    AudioProcessing::ChannelLayout capture_output_channel_layout;
+    int capture_input_sample_rate_hz = 16000;
+    int capture_input_number_of_channels;
+    std::vector<float*> capture_input_frame;
+    std::vector<float> capture_input_framechannels_;
+    AudioProcessing::ChannelLayout capture_input_channel_layout;
+    int capture_output_sample_rate_hz = 16000;
+    int capture_output_number_of_channels;
+    StreamConfig capture_input_stream_config;
+    StreamConfig capture_output_stream_config;
+    int capture_input_samples_per_channel;
+    int capture_output_samples_per_channel;
+  } capture_thread_only_state_;

[hlundin-webrtc, 2015/10/27 10:54:24]

You can make many lines shorter by abbreviating this struct's name to
capture_state_. I don't think it makes the code any harder to understand, but
definitely easier to read.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+
+  // Variables only used on the render side thread.
+  struct {
+    bool first_render_side_call_ = true;
+
+    // Variables related to the render side audio data and formats.
+    AudioFrame render_frame;

[hlundin-webrtc, 2015/10/27 10:54:25]

Same as above: drop the render_ prefix.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+    std::vector<float*> render_output_frame;
+    std::vector<float> render_output_frame_channels;
+    AudioProcessing::ChannelLayout render_output_channel_layout;
+    int render_input_sample_rate_hz = 16000;
+    int render_input_number_of_channels;
+    std::vector<float*> render_input_frame;
+    std::vector<float> render_input_frame_channels;
+    AudioProcessing::ChannelLayout render_input_channel_layout;
+    int render_output_sample_rate_hz = 16000;
+    int render_output_number_of_channels;
+    StreamConfig render_input_stream_config;
+    StreamConfig render_output_stream_config;
+    int render_input_samples_per_channel;
+    int render_output_samples_per_channel;
+  } render_thread_only_state_;

[hlundin-webrtc, 2015/10/27 10:54:24]

Same as above: name it render_state_.

[peah-webrtc, 2015/10/29 09:00:08]

Done.

+};
+
+}  // anonymous namespace
+
+TEST_P(AudioProcessingImpLockTest, LockTest) {
+  // Run test and verify that it did not time out.
+  EXPECT_EQ(kEventSignaled, RunTest());
+}
+
+// Instantiate tests from the extreme test configuration set.
+INSTANTIATE_TEST_CASE_P(
+    DISABLED_AudioProcessingImpLockExtensive,
+    AudioProcessingImpLockTest,
+    ::testing::ValuesIn(
+        AudioProcessingImpLockTest::GenerateExtensiveTestConfigs()));
+
+INSTANTIATE_TEST_CASE_P(
+    AudioProcessingImpLockBrief,
+    AudioProcessingImpLockTest,
+    ::testing::ValuesIn(
+        AudioProcessingImpLockTest::GenerateBriefTestConfigs()));
+
+}  // namespace webrtc