Add HD browser test to WebRTC suite.

chrome/browser/media/chrome_webrtc_video_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 "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/strings/string_split.h"
@@ skipping 35 matching lines @@
 
 static const base::FilePath::CharType kArgbToI420ConverterExecutable[] =
 #if defined(OS_WIN)
     FILE_PATH_LITERAL("rgba_to_i420_converter.exe");
 #else
     FILE_PATH_LITERAL("rgba_to_i420_converter");
 #endif
 
 static const char kHomeEnvName[] =
 #if defined(OS_WIN)
-    "HOMEPATH";
+    "USERPROFILE";
 #else
     "HOME";
 #endif
 
 // The working dir should be in the user's home folder.
 static const base::FilePath::CharType kWorkingDirName[] =
     FILE_PATH_LITERAL("webrtc_video_quality");
 static const base::FilePath::CharType kCapturedYuvFileName[] =
     FILE_PATH_LITERAL("captured_video.yuv");
 static const base::FilePath::CharType kStatsFileName[] =
     FILE_PATH_LITERAL("stats.txt");
 static const char kMainWebrtcTestHtmlPage[] =
     "/webrtc/webrtc_jsep01_test.html";
-static const char kCapturingWebrtcHtmlPage[] =
-    "/webrtc/webrtc_video_quality_test.html";
-static const int k360pWidth = 640;
-static const int k360pHeight = 360;
 
 // If you change the port number, don't forget to modify video_extraction.js
 // too!
 static const char kPyWebSocketPortNumber[] = "12221";
 
+static const struct VideoQualityTestConfig {
+  const char* test_name;
+  int width;
+  int height;
+  const char* capture_page;
+  const base::FilePath::CharType* reference_video;
+  const char* constraints;
+} kVideoConfigurations[] = {
+  { "360p", 640, 360,
+    "/webrtc/webrtc_video_quality_test.html",
+    test::kReferenceFileName360p,
+    WebRtcTestBase::kAudioVideoCallConstraints360p },
+  { "720p", 1280, 720,
+    "/webrtc/webrtc_video_quality_test_hd.html",
+    test::kReferenceFileName720p,
+    WebRtcTestBase::kAudioVideoCallConstraints720p },
+};
+
 // Test the video quality of the WebRTC output.
 //
 // Prerequisites: This test case must run on a machine with a chrome playing
 // the video from the reference files located in GetReferenceFilesDir().
 // The file kReferenceY4mFileName.kY4mFileExtension is played using a
 // FileVideoCaptureDevice and its sibling with kYuvFileExtension is used for
 // comparison.
 //
 // You must also compile the chromium_builder_webrtc target before you run this
 // test to get all the tools built.
 //
 // The external compare_videos.py script also depends on two external
 // executables which must be located in the PATH when running this test.
 // * zxing (see the CPP version at https://code.google.com/p/zxing)
 // * ffmpeg 0.11.1 or compatible version (see http://www.ffmpeg.org)
 //
 // The test case will launch a custom binary (peerconnection_server) which will
 // allow two WebRTC clients to find each other.
 //
 // The test also runs several other custom binaries - rgba_to_i420 converter and
 // frame_analyzer. Both tools can be found under third_party/webrtc/tools. The
 // test also runs a stand alone Python implementation of a WebSocket server
 // (pywebsocket) and a barcode_decoder script.
-class WebRtcVideoQualityBrowserTest : public WebRtcTestBase {
+class WebRtcVideoQualityBrowserTest : public WebRtcTestBase,
+    public testing::WithParamInterface<VideoQualityTestConfig> {
  public:
   WebRtcVideoQualityBrowserTest()
       : pywebsocket_server_(0),
-        environment_(base::Environment::Create()) {}
+        environment_(base::Environment::Create()) {
+    test_config_ = GetParam();
+  }
 
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     test::PeerConnectionServerRunner::KillAllPeerConnectionServers();
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // Set up the command line option with the expected file name. We will check
     // its existence in HasAllRequiredResources().
     webrtc_reference_video_y4m_ = test::GetReferenceFilesDir()
-        .Append(test::kReferenceFileName360p)
+        .Append(test_config_.reference_video)
         .AddExtension(test::kY4mFileExtension);
     command_line->AppendSwitchPath(switches::kUseFileForFakeVideoCapture,
                                    webrtc_reference_video_y4m_);
     command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
 
     // The video playback will not work without a GPU, so force its use here.
     command_line->AppendSwitch(switches::kUseGpuInTests);
   }
 
   bool HasAllRequiredResources() {
@@ skipping 85 matching lines @@
 
   // Compares the |captured_video_filename| with the |reference_video_filename|.
   //
   // The barcode decoder decodes the captured video containing barcodes overlaid
   // into every frame of the video (produced by rgba_to_i420_converter). It
   // produces a set of PNG images and a |stats_file| that maps each captured
   // frame to a frame in the reference video. The frames should be of size
   // |width| x |height|.
   // All measurements calculated are printed as perf parsable numbers to stdout.
   bool CompareVideosAndPrintResult(
+      const char* test_label,
       int width,
       int height,
       const base::FilePath& captured_video_filename,
       const base::FilePath& reference_video_filename,
       const base::FilePath& stats_file) {
 
     base::FilePath path_to_analyzer = base::MakeAbsoluteFilePath(
         GetBrowserDir().Append(kFrameAnalyzerExecutable));
     base::FilePath path_to_compare_script = GetSourceDir().Append(
         FILE_PATH_LITERAL("third_party/webrtc/tools/compare_videos.py"));
 
     if (!base::PathExists(path_to_analyzer)) {
       LOG(ERROR) << "Missing frame analyzer: should be in "
           << path_to_analyzer.value();
       return false;
     }
     if (!base::PathExists(path_to_compare_script)) {
       LOG(ERROR) << "Missing video compare script: should be in "
           << path_to_compare_script.value();
       return false;
     }
 
     // Note: don't append switches to this command since it will mess up the
     // -u in the python invocation!
     CommandLine compare_command(CommandLine::NO_PROGRAM);
     EXPECT_TRUE(GetPythonCommand(&compare_command));
 
     compare_command.AppendArgPath(path_to_compare_script);
-    compare_command.AppendArg("--label=360p");
+    compare_command.AppendArg(base::StringPrintf("--label=%s", test_label));
     compare_command.AppendArg("--ref_video");
     compare_command.AppendArgPath(reference_video_filename);
     compare_command.AppendArg("--test_video");
     compare_command.AppendArgPath(captured_video_filename);
     compare_command.AppendArg("--frame_analyzer");
     compare_command.AppendArgPath(path_to_analyzer);
     compare_command.AppendArg("--yuv_frame_width");
     compare_command.AppendArg(base::StringPrintf("%d", width));
     compare_command.AppendArg("--yuv_frame_height");
     compare_command.AppendArg(base::StringPrintf("%d", height));
@@ skipping 10 matching lines @@
   }
 
   base::FilePath GetWorkingDir() {
     std::string home_dir;
     environment_->GetVar(kHomeEnvName, &home_dir);
     base::FilePath::StringType native_home_dir(home_dir.begin(),
                                                home_dir.end());
     return base::FilePath(native_home_dir).Append(kWorkingDirName);
   }
 
+ protected:
   test::PeerConnectionServerRunner peerconnection_server_;
+  VideoQualityTestConfig test_config_;
 
  private:
   base::FilePath GetSourceDir() {
     base::FilePath source_dir;
     PathService::Get(base::DIR_SOURCE_ROOT, &source_dir);
     return source_dir;
   }
 
   base::FilePath GetBrowserDir() {
     base::FilePath browser_dir;
     EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &browser_dir));
     return browser_dir;
   }
 
   base::ProcessHandle pywebsocket_server_;
   scoped_ptr<base::Environment> environment_;
   base::FilePath webrtc_reference_video_y4m_;
 };
 
-IN_PROC_BROWSER_TEST_F(WebRtcVideoQualityBrowserTest,
-                       MANUAL_TestVGAVideoQuality) {
+INSTANTIATE_TEST_CASE_P(
+    WebRtcVideoQualityBrowserTests,
+    WebRtcVideoQualityBrowserTest,
+    testing::ValuesIn(kVideoConfigurations));
+
+IN_PROC_BROWSER_TEST_P(WebRtcVideoQualityBrowserTest,
+                       MANUAL_TestVideoQuality) {
+
 #if defined(OS_WIN)
   // Fails on XP. http://crbug.com/353078
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     return;
 #endif
 
   ASSERT_GE(TestTimeouts::action_max_timeout().InSeconds(), 150) <<
       "This is a long-running test; you must specify "
       "--ui-test-action-max-timeout to have a value of at least 150000.";
-
   ASSERT_TRUE(HasAllRequiredResources());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   ASSERT_TRUE(StartPyWebSocketServer());
   ASSERT_TRUE(peerconnection_server_.Start());
 
   content::WebContents* left_tab =
       OpenPageAndGetUserMediaInNewTabWithConstraints(
           embedded_test_server()->GetURL(kMainWebrtcTestHtmlPage),
-          kAudioVideoCallConstraints360p);
+          test_config_.constraints);
   content::WebContents* right_tab =
       OpenPageAndGetUserMediaInNewTabWithConstraints(
-          embedded_test_server()->GetURL(kCapturingWebrtcHtmlPage),
-          kAudioVideoCallConstraints360p);
+          embedded_test_server()->GetURL(test_config_.capture_page),
+          test_config_.constraints);
 
   EstablishCall(left_tab, right_tab);
 
   // Poll slower here to avoid flooding the log with messages: capturing and
   // sending frames take quite a bit of time.
   int polling_interval_msec = 1000;
 
   EXPECT_TRUE(test::PollingWaitUntil(
       "doneFrameCapturing()", "done-capturing", right_tab,
       polling_interval_msec));
 
   HangUp(left_tab);
   WaitUntilHangupVerified(left_tab);
   WaitUntilHangupVerified(right_tab);
 
   EXPECT_TRUE(test::PollingWaitUntil(
       "haveMoreFramesToSend()", "no-more-frames", right_tab,
       polling_interval_msec));
 
   // Shut everything down to avoid having the javascript race with the analysis
   // tools. For instance, dont have console log printouts interleave with the
   // RESULT lines from the analysis tools (crbug.com/323200).
   ASSERT_TRUE(peerconnection_server_.Stop());
   ASSERT_TRUE(ShutdownPyWebSocketServer());
 
   chrome::CloseWebContents(browser(), left_tab, false);
   chrome::CloseWebContents(browser(), right_tab, false);
 
   RunARGBtoI420Converter(
-      k360pWidth, k360pHeight, GetWorkingDir().Append(kCapturedYuvFileName));
+      test_config_.width, test_config_.height,
+      GetWorkingDir().Append(kCapturedYuvFileName));
   ASSERT_TRUE(CompareVideosAndPrintResult(
-      k360pWidth,
-      k360pHeight,
+      test_config_.test_name,
+      test_config_.width,
+      test_config_.height,
       GetWorkingDir().Append(kCapturedYuvFileName),
       test::GetReferenceFilesDir()
-          .Append(test::kReferenceFileName360p)
+          .Append(test_config_.reference_video)
           .AddExtension(test::kYuvFileExtension),
       GetWorkingDir().Append(kStatsFileName)));
 }