Deprecate AudioProcessing::AnalyzeReverseStream(AudioFrame) API

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.
  */
 
@@ skipping 17 matching lines @@
 namespace webrtc {
 
 namespace {
 
 class AudioProcessingImplLockTest;
 
 // Type of the render thread APM API call to use in the test.
 enum class RenderApiImpl {
   ProcessReverseStreamImpl1,
   ProcessReverseStreamImpl2,
-  AnalyzeReverseStreamImpl1,
-  AnalyzeReverseStreamImpl2
+  AnalyzeReverseStreamImpl
 };
 
 // Type of the capture thread APM API call to use in the test.
 enum class CaptureApiImpl {
   ProcessStreamImpl1,
   ProcessStreamImpl2,
   ProcessStreamImpl3
 };
 
 // The runtime parameter setting scheme to use in the test.
@@ skipping 93 matching lines @@
       test_config.initial_sample_rate_hz = 16000;
 
       // Create test config for the second processing API function set.
       test_config.render_api_function =
           RenderApiImpl::ProcessReverseStreamImpl2;
       test_config.capture_api_function = CaptureApiImpl::ProcessStreamImpl2;
 
       // Create test config for the first processing API function set.
       test_configs.push_back(test_config);
       test_config.render_api_function =
-          RenderApiImpl::AnalyzeReverseStreamImpl2;
+          RenderApiImpl::AnalyzeReverseStreamImpl;
       test_config.capture_api_function = CaptureApiImpl::ProcessStreamImpl3;
       test_configs.push_back(test_config);
     }
 
     // Return the created test configurations.
     return test_configs;
   }
 
   // Test case generator for the test configurations to use in the extensive
   // tests.
   static std::vector<TestConfig> GenerateExtensiveTestConfigs() {
     // Lambda functions for the test config generation.
     auto add_processing_apis = [](TestConfig test_config) {
       struct AllowedApiCallCombinations {
         RenderApiImpl render_api;
         CaptureApiImpl capture_api;
       };
 
       const AllowedApiCallCombinations api_calls[] = {
           {RenderApiImpl::ProcessReverseStreamImpl1,
            CaptureApiImpl::ProcessStreamImpl1},
-          {RenderApiImpl::AnalyzeReverseStreamImpl1,
-           CaptureApiImpl::ProcessStreamImpl1},
           {RenderApiImpl::ProcessReverseStreamImpl2,
            CaptureApiImpl::ProcessStreamImpl2},
           {RenderApiImpl::ProcessReverseStreamImpl2,
            CaptureApiImpl::ProcessStreamImpl3},
-          {RenderApiImpl::AnalyzeReverseStreamImpl2,
+          {RenderApiImpl::AnalyzeReverseStreamImpl,
            CaptureApiImpl::ProcessStreamImpl2},
-          {RenderApiImpl::AnalyzeReverseStreamImpl2,
+          {RenderApiImpl::AnalyzeReverseStreamImpl,
            CaptureApiImpl::ProcessStreamImpl3}};
       std::vector<TestConfig> out;
       for (auto api_call : api_calls) {
         test_config.render_api_function = api_call.render_api;
         test_config.capture_api_function = api_call.capture_api;
         out.push_back(test_config);
       }
       return out;
     };
 
@@ skipping 740 matching lines @@
   render_call_event_->Set();
   return true;
 }
 
 // Prepares the render side frame and the accompanying metadata
 // with the appropriate information.
 void RenderProcessor::PrepareFrame() {
   // Restrict to a common fixed sample rate if the AudioFrame interface is
   // used.
   if ((test_config_->render_api_function ==
-       RenderApiImpl::AnalyzeReverseStreamImpl1) ||
-      (test_config_->render_api_function ==
        RenderApiImpl::ProcessReverseStreamImpl1) ||
       (test_config_->aec_type !=
        AecType::BasicWebRtcAecSettingsWithAecMobile)) {
     frame_data_.input_sample_rate_hz = test_config_->initial_sample_rate_hz;
     frame_data_.output_sample_rate_hz = test_config_->initial_sample_rate_hz;
   }
 
   // Prepare the audioframe data and metadata
   frame_data_.input_samples_per_channel =
       frame_data_.input_sample_rate_hz * AudioProcessing::kChunkSizeMs / 1000;
@@ skipping 40 matching lines @@
   int result = AudioProcessing::kNoError;
   switch (test_config_->render_api_function) {
     case RenderApiImpl::ProcessReverseStreamImpl1:
       result = apm_->ProcessReverseStream(&frame_data_.frame);
       break;
     case RenderApiImpl::ProcessReverseStreamImpl2:
       result = apm_->ProcessReverseStream(
           &frame_data_.input_frame[0], frame_data_.input_stream_config,
           frame_data_.output_stream_config, &frame_data_.output_frame[0]);
       break;
-    case RenderApiImpl::AnalyzeReverseStreamImpl1:
-      result = apm_->AnalyzeReverseStream(&frame_data_.frame);
-      break;
-    case RenderApiImpl::AnalyzeReverseStreamImpl2:
+    case RenderApiImpl::AnalyzeReverseStreamImpl:
       result = apm_->AnalyzeReverseStream(
           &frame_data_.input_frame[0], frame_data_.input_samples_per_channel,
           frame_data_.input_sample_rate_hz, frame_data_.input_channel_layout);
       break;
     default:
       FAIL();
   }
 
   // Check the return code for error.
   ASSERT_EQ(AudioProcessing::kNoError, result);
@@ skipping 114 matching lines @@
     DISABLED_AudioProcessingImplLockExtensive,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateExtensiveTestConfigs()));
 
 INSTANTIATE_TEST_CASE_P(
     AudioProcessingImplLockBrief,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateBriefTestConfigs()));
 
 }  // namespace webrtc