Disabling WebRtcAudioQualityBrowserTest for Win 7

chrome/browser/media/webrtc/webrtc_audio_quality_browsertest.cc

 // Copyright 2013 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.
 
 #include <stddef.h>
 
 #include <ctime>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
@@ skipping 18 matching lines @@
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/media_switches.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/perf/perf_test.h"
 
+#if defined(OS_WIN)
+#include "base/win/windows_version.h"
+#endif
+
 namespace {
 
 static const base::FilePath::CharType kReferenceFile[] =
     FILE_PATH_LITERAL("speech_44kHz_16bit_stereo.wav");
 
 // The javascript will load the reference file relative to its location,
 // which is in /webrtc on the web server. The files we are looking for are in
 // webrtc/resources in the chrome/test/data folder.
 static const char kReferenceFileRelativeUrl[] =
     "resources/speech_44kHz_16bit_stereo.wav";
@@ skipping 573 matching lines @@
 // audio device is up following the getUserMedia call in the left tab. The time
 // it takes to negotiate a call isn't deterministic, but five seconds should be
 // plenty of time. Similarly, the recording time should be enough to catch the
 // whole reference file. If you then silence-trim the reference file and actual
 // file, you should end up with two time-synchronized files.
 void MAYBE_WebRtcAudioQualityBrowserTest::SetupAndRecordAudioCall(
     const base::FilePath& reference_file,
     const base::FilePath& recording,
     const std::string& constraints,
     const base::TimeDelta recording_time) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
+
   ASSERT_TRUE(embedded_test_server()->Start());
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
   ConfigureFakeDeviceToPlayFile(reference_file);
 
   // Create a two-way call. Mute one of the receivers though; that way it will
   // be receiving audio bytes, but we will not be playing out of both elements.
   GURL test_page = embedded_test_server()->GetURL(kWebRtcAudioTestHtmlPage);
   content::WebContents* left_tab =
@@ skipping 12 matching lines @@
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   DVLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
 }
 
 void MAYBE_WebRtcAudioQualityBrowserTest::TestWithFakeDeviceGetUserMedia(
     const std::string& constraints,
     const std::string& perf_modifier) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
   if (OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
 
   base::FilePath reference_file =
       test::GetReferenceFilesDir().Append(kReferenceFile);
   base::FilePath recording = CreateTemporaryWaveFile();
 
   ASSERT_NO_FATAL_FAILURE(SetupAndRecordAudioCall(
       reference_file, recording, constraints,
       base::TimeDelta::FromSeconds(30)));
 
   ComputeAndPrintPesqResults(reference_file, recording, perf_modifier);
   DeleteFileUnlessTestFailed(recording, false);
 }
 
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestCallQualityWithAudioFromFakeDevice) {
   TestWithFakeDeviceGetUserMedia(kAudioOnlyCallConstraints, "_getusermedia");
 }
 
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestCallQualityWithAudioFromWebAudio) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
   if (OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->Start());
 
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
@@ skipping 55 matching lines @@
  * The test only exercises digital AGC for now.
  *
  * We record in CD format here (44.1 kHz) because that's what the fake input
  * device currently supports, and we want to be able to compare directly. See
  * http://crbug.com/421054.
  */
 void MAYBE_WebRtcAudioQualityBrowserTest::TestAutoGainControl(
     const base::FilePath::StringType& reference_filename,
     const std::string& constraints,
     const std::string& perf_modifier) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
   if (OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
   base::FilePath reference_file =
       test::GetReferenceFilesDir().Append(reference_filename);
   base::FilePath recording = CreateTemporaryWaveFile();
 
   ASSERT_NO_FATAL_FAILURE(SetupAndRecordAudioCall(
@@ skipping 20 matching lines @@
   AnalyzeSegmentsAndPrintResult(
       ref_segments, actual_segments, reference_file, perf_modifier);
 
   DeleteFileUnlessTestFailed(recording, false);
   DeleteFileUnlessTestFailed(actual_files_dir, true);
 }
 
 // The AGC should apply non-zero gain here.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestAutoGainControlOnLowAudio) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kReferenceFile, kAudioOnlyCallConstraints, "_with_agc"));
 }
 
 // Since the AGC is off here there should be no gain at all.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MANUAL_TestAutoGainIsOffWithAudioProcessingOff) {
+  if (OnWin7()) {
+    // http://crbug.com/677256.
+    LOG(ERROR) << "This test is flaky on Windows 7.";
+    return;
+  }
   const char* kAudioCallWithoutAudioProcessing =
       "{audio: { mandatory: { echoCancellation: false } } }";
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kReferenceFile, kAudioCallWithoutAudioProcessing, "_no_agc"));
 }