Deflake ConnectionTest.Audio test

remoting/protocol/connection_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 216 matching lines @@
     int right = 0;
     for (int i = skipped_samples + 1; i < num_samples; ++i) {
       if (data[(i - 1) * kAudioChannels] < 0 && data[i * kAudioChannels] >= 0) {
         ++left;
       }
       if (data[(i - 1) * kAudioChannels + 1] < 0 &&
           data[i * kAudioChannels + 1] >= 0) {
         ++right;
       }
     }
+
+    const int kMaxErrorHz = 50;
     int left_hz = (left * kAudioSampleRate / (num_samples - skipped_samples));
-    EXPECT_LE(kTestAudioSignalFrequencyLeftHz - 50, left_hz);
-    EXPECT_GE(kTestAudioSignalFrequencyLeftHz + 50, left_hz);
+    EXPECT_LE(kTestAudioSignalFrequencyLeftHz - kMaxErrorHz, left_hz);
+    EXPECT_GE(kTestAudioSignalFrequencyLeftHz + kMaxErrorHz, left_hz);
     int right_hz = (right * kAudioSampleRate / (num_samples - skipped_samples));
-    EXPECT_LE(kTestAudioSignalFrequencyRightHz - 50, right_hz);
-    EXPECT_GE(kTestAudioSignalFrequencyRightHz + 50, right_hz);
+    EXPECT_LE(kTestAudioSignalFrequencyRightHz - kMaxErrorHz, right_hz);
+    EXPECT_GE(kTestAudioSignalFrequencyRightHz + kMaxErrorHz, right_hz);
   }
 
   base::WeakPtr<AudioStub> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
 
  private:
   base::ThreadChecker thread_checker_;
   std::vector<char> data_;
   base::RunLoop* run_loop_ = nullptr;
   size_t samples_expected_ = 0;
 
@@ skipping 362 matching lines @@
                 stats.host_stats.capture_delay +
                 stats.host_stats.capture_overhead_delay +
                 stats.host_stats.encode_delay +
                 stats.host_stats.send_pending_delay,
             stats.client_stats.time_received);
   EXPECT_LE(stats.client_stats.time_received, stats.client_stats.time_decoded);
   EXPECT_LE(stats.client_stats.time_decoded, stats.client_stats.time_rendered);
   EXPECT_LE(stats.client_stats.time_rendered, finish_time);
 }
 
-// Flaky on Linux/ChromeOS, crbug.com/685910.
-// Note: Apparently it's not possible to use the common MAYBE_ prefix with
-// TEST_P, so ifdef it out completely.
-#if !defined(OS_LINUX) && !defined(OS_CHROMEOS)
 TEST_P(ConnectionTest, Audio) {
   Connect();
 
   std::unique_ptr<AudioStream> audio_stream =
       host_connection_->StartAudioStream(base::MakeUnique<TestAudioSource>());
 
   // Wait for 1 second worth of audio samples.
   client_audio_player_.WaitForSamples(kAudioSampleRate * 2);
   client_audio_player_.Verify();
 }
-#endif
 
 TEST_P(ConnectionTest, FirstCaptureFailed) {
   Connect();
 
   base::TimeTicks event_timestamp = base::TimeTicks::FromInternalValue(42);
 
   scoped_refptr<InputEventTimestampsSourceImpl> input_event_timestamps_source =
       new InputEventTimestampsSourceImpl();
   input_event_timestamps_source->OnEventReceived(
       InputEventTimestamps{event_timestamp, base::TimeTicks::Now()});
@@ skipping 27 matching lines @@
   auto capturer = base::MakeUnique<TestScreenCapturer>();
   capturer->FailNthFrame(1);
   auto video_stream = host_connection_->StartVideoStream(std::move(capturer));
 
   WaitNextVideoFrame();
   WaitNextVideoFrame();
 }
 
 }  // namespace protocol
 }  // namespace remoting