Removed the timeout for the delay estimate quality.

webrtc/modules/audio_processing/aec3/render_delay_controller_unittest.cc

 /*
  *  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.
  */
 
@@ skipping 35 matching lines @@
 TEST(RenderDelayController, NoRenderSignal) {
   std::vector<float> block(kBlockSize, 0.f);
   for (auto rate : {8000, 16000, 32000, 48000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<RenderDelayBuffer> delay_buffer(
         RenderDelayBuffer::Create(NumBandsForRate(rate)));
     std::unique_ptr<RenderDelayController> delay_controller(
         RenderDelayController::Create(AudioProcessing::Config::EchoCanceller3(),
                                       rate));
     for (size_t k = 0; k < 100; ++k) {
-      EXPECT_EQ(0u, delay_controller->GetDelay(
-                        delay_buffer->GetDownsampledRenderBuffer(), block));
+      EXPECT_EQ(kMinEchoPathDelayBlocks,
+                delay_controller->GetDelay(
+                    delay_buffer->GetDownsampledRenderBuffer(), block));
     }
   }
 }
 
 // Verifies the basic API call sequence.
 TEST(RenderDelayController, BasicApiCalls) {
   std::vector<float> capture_block(kBlockSize, 0.f);
   size_t delay_blocks = 0;
   for (auto rate : {8000, 16000, 32000, 48000}) {
     std::vector<std::vector<float>> render_block(
         NumBandsForRate(rate), std::vector<float>(kBlockSize, 0.f));
     std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
         RenderDelayBuffer::Create(NumBandsForRate(rate)));
     std::unique_ptr<RenderDelayController> delay_controller(
         RenderDelayController::Create(AudioProcessing::Config::EchoCanceller3(),
                                       rate));
     for (size_t k = 0; k < 10; ++k) {
       render_delay_buffer->Insert(render_block);
       render_delay_buffer->UpdateBuffers();
       delay_blocks = delay_controller->GetDelay(
           render_delay_buffer->GetDownsampledRenderBuffer(), capture_block);
     }
     EXPECT_FALSE(delay_controller->AlignmentHeadroomSamples());
-    EXPECT_EQ(0u, delay_blocks);
+    EXPECT_EQ(kMinEchoPathDelayBlocks, delay_blocks);
   }
 }
 
 // Verifies that the RenderDelayController is able to align the signals for
 // simple timeshifts between the signals.
 TEST(RenderDelayController, Alignment) {
   Random random_generator(42U);
   std::vector<float> capture_block(kBlockSize, 0.f);
   size_t delay_blocks = 0;
   for (auto rate : {8000, 16000, 32000, 48000}) {
@@ skipping 14 matching lines @@
         render_delay_buffer->Insert(render_block);
         render_delay_buffer->UpdateBuffers();
         delay_blocks = delay_controller->GetDelay(
             render_delay_buffer->GetDownsampledRenderBuffer(), capture_block);
       }
 
       constexpr int kDelayHeadroomBlocks = 1;
       size_t expected_delay_blocks =
           std::max(0, static_cast<int>(delay_samples / kBlockSize) -
                           kDelayHeadroomBlocks);
-      if (expected_delay_blocks < 2) {
-        expected_delay_blocks = 0;
-      }
 
       EXPECT_EQ(expected_delay_blocks, delay_blocks);
 
       const rtc::Optional<size_t> headroom_samples =
           delay_controller->AlignmentHeadroomSamples();
       ASSERT_TRUE(headroom_samples);
       EXPECT_NEAR(delay_samples - delay_blocks * kBlockSize, *headroom_samples,
                   4);
     }
   }
@@ skipping 99 matching lines @@
     EXPECT_DEATH(
         std::unique_ptr<RenderDelayController>(RenderDelayController::Create(
             AudioProcessing::Config::EchoCanceller3(), rate)),
         "");
   }
 }
 
 #endif
 
 }  // namespace webrtc