Fixed quality tests after PyAuto test purge.

chrome/browser/media/chrome_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 <ctime>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/stringprintf.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/media/webrtc_browsertest_base.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/perf/perf_test.h"
 
+// These are relative to the reference file dir defined by
+// webrtc_browsertest_common.h (i.e. chrome/test/data/webrtc/resources).
 static const base::FilePath::CharType kReferenceFile[] =
 #if defined (OS_WIN)
-    FILE_PATH_LITERAL("pyauto_private/webrtc/human-voice-win.wav");
+    FILE_PATH_LITERAL("human-voice-win.wav");
 #else
-    FILE_PATH_LITERAL("pyauto_private/webrtc/human-voice-linux.wav");
+    FILE_PATH_LITERAL("human-voice-linux.wav");
 #endif
 
 // The javascript will load the reference file relative to its location,
-// which is in /webrtc on the web server. Therefore, prepend a '..' traversal.
+// 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[] =
 #if defined (OS_WIN)
-    "../pyauto_private/webrtc/human-voice-win.wav";
+    "resources/human-voice-win.wav";
 #else
-    "../pyauto_private/webrtc/human-voice-linux.wav";
+    "resources/human-voice-linux.wav";
 #endif
 
-static const base::FilePath::CharType kToolsPath[] =
-    FILE_PATH_LITERAL("pyauto_private/media/tools");
-
 static const char kMainWebrtcTestHtmlPage[] =
     "/webrtc/webrtc_audio_quality_test.html";
 
-static base::FilePath GetTestDataDir() {
-  base::FilePath source_dir;
-  PathService::Get(chrome::DIR_TEST_DATA, &source_dir);
-  return source_dir;
-}
-
 // Test we can set up a WebRTC call and play audio through it.
 //
 // You must have the src-internal solution in your .gclient to put the required
 // pyauto_private directory into chrome/test/data/.
 //
 // This test will only work on machines that have been configured to record
 // their own input.
 //
 // On Linux:
 // 1. # sudo apt-get install pavucontrol
@@ skipping 38 matching lines @@
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeDeviceForMediaStream));
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeUIForMediaStream));
 
     bool enable_audio_track_processing = GetParam();
     if (enable_audio_track_processing)
       command_line->AppendSwitch(switches::kEnableAudioTrackProcessing);
   }
 
-  bool HasAllRequiredResources() {
-    base::FilePath reference_file = GetTestDataDir().Append(kReferenceFile);
-    if (!base::PathExists(reference_file)) {
-      LOG(ERROR) << "Cannot find the reference file to be used for audio "
-          << "quality comparison: " << reference_file.value();
-      return false;
-    }
-    return true;
-  }
-
   void AddAudioFile(const std::string& input_file_relative_url,
                     content::WebContents* tab_contents) {
     EXPECT_EQ("ok-added", ExecuteJavascript(
         "addAudioFile('" + input_file_relative_url + "')", tab_contents));
   }
 
   void PlayAudioFile(content::WebContents* tab_contents) {
     EXPECT_EQ("ok-playing", ExecuteJavascript("playAudioFile()", tab_contents));
   }
 
@@ skipping 87 matching lines @@
     int exit_code = -1;
     base::WaitForExitCode(recording_application_, &exit_code);
     return exit_code == 0;
   }
  private:
   base::ProcessHandle recording_application_;
 };
 
 bool ForceMicrophoneVolumeTo100Percent() {
 #if defined(OS_WIN)
-  CommandLine command_line(GetTestDataDir().Append(kToolsPath).Append(
+  CommandLine command_line(test::GetReferenceFilesDir().Append(
       FILE_PATH_LITERAL("force_mic_volume_max.exe")));
   VLOG(0) << "Running " << command_line.GetCommandLineString();
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
 #else
   // Just force the volume of, say the first 5 devices. A machine will rarely
   // have more input sources than that. This is way easier than finding the
@@ skipping 27 matching lines @@
   // ABOVE_PERIODS: The period for which silence occurs. Value 1 is used for
   //                 silence at beginning of audio.
   // DURATION: the amount of time in seconds that non-silence must be detected
   //           before sox stops trimming audio.
   // THRESHOLD: value used to indicate what sample value is treates as silence.
   const char* kAbovePeriods = "1";
   const char* kDuration = "2";
   const char* kTreshold = "5%";
 
 #if defined(OS_WIN)
-  CommandLine command_line(GetTestDataDir().Append(kToolsPath).Append(
+  CommandLine command_line(test::GetReferenceFilesDir().Append(
       FILE_PATH_LITERAL("sox.exe")));
 #else
   CommandLine command_line(base::FilePath(FILE_PATH_LITERAL("sox")));
 #endif
   command_line.AppendArgPath(input_file);
   command_line.AppendArgPath(output_file);
   command_line.AppendArg("silence");
   command_line.AppendArg(kAbovePeriods);
   command_line.AppendArg(kDuration);
   command_line.AppendArg(kTreshold);
@@ skipping 28 matching lines @@
 // "3.145", etc). Returns true on success.
 bool RunPesq(const base::FilePath& reference_file,
              const base::FilePath& actual_file,
              int sample_rate, std::string* raw_mos, std::string* mos_lqo) {
   // PESQ will break if the paths are too long (!).
   EXPECT_LT(reference_file.value().length(), 128u);
   EXPECT_LT(actual_file.value().length(), 128u);
 
 #if defined(OS_WIN)
   base::FilePath pesq_path =
-      GetTestDataDir().Append(kToolsPath).Append(FILE_PATH_LITERAL("pesq.exe"));
+      test::GetReferenceFilesDir().Append(FILE_PATH_LITERAL("pesq.exe"));
 #else
   base::FilePath pesq_path =
-      GetTestDataDir().Append(kToolsPath).Append(FILE_PATH_LITERAL("pesq"));
+      test::GetReferenceFilesDir().Append(FILE_PATH_LITERAL("pesq"));
 #endif
 
   if (!base::PathExists(pesq_path)) {
     LOG(ERROR) << "Missing PESQ binary in " << pesq_path.value();
     return false;
   }
 
   CommandLine command_line(pesq_path);
   command_line.AppendArg(base::StringPrintf("+%d", sample_rate));
   command_line.AppendArgPath(reference_file);
@@ skipping 30 matching lines @@
                         WebRtcAudioQualityBrowserTest,
                         testing::ValuesIn(kRunTestsWithFlag));
 
 #if defined(OS_LINUX) || defined(OS_WIN)
 // Only implemented on Linux and Windows for now.
 #define MAYBE_MANUAL_TestAudioQuality MANUAL_TestAudioQuality
 #else
 #define MAYBE_MANUAL_TestAudioQuality DISABLED_MANUAL_TestAudioQuality
 #endif
 
-// Disabled due to crbug.com/359579.
 IN_PROC_BROWSER_TEST_P(WebRtcAudioQualityBrowserTest,
-                       DISABLED_MANUAL_TestAudioQuality) {
+                       MANUAL_TestAudioQuality) {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     // It would take work to implement this on XP; not prioritized right now.
     LOG(ERROR) << "This test is not implemented for Windows XP.";
     return;
   }
 #endif
-  ASSERT_TRUE(HasAllRequiredResources());
+  ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   ASSERT_TRUE(peerconnection_server_.Start());
 
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(kMainWebrtcTestHtmlPage));
   content::WebContents* left_tab =
       browser()->tab_strip_model()->GetActiveWebContents();
 
@@ skipping 37 matching lines @@
   WaitUntilHangupVerified(right_tab);
 
   base::FilePath trimmed_recording = CreateTemporaryWaveFile();
 
   ASSERT_TRUE(RemoveSilence(recording, trimmed_recording));
   VLOG(0) << "Trimmed silence: " << trimmed_recording.value() << std::endl;
 
   std::string raw_mos;
   std::string mos_lqo;
   base::FilePath reference_file_in_test_dir =
-      GetTestDataDir().Append(kReferenceFile);
+      test::GetReferenceFilesDir().Append(kReferenceFile);
   ASSERT_TRUE(RunPesq(reference_file_in_test_dir, trimmed_recording, 16000,
                       &raw_mos, &mos_lqo));
 
   perf_test::PrintResult("audio_pesq", "", "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult("audio_pesq", "", "mos_lqo", mos_lqo, "score", true);
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
   EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 
   ASSERT_TRUE(peerconnection_server_.Stop());
 }