Use MediaRecorder to capture video for quality test.

chrome/browser/media/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 <stddef.h>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/files/file.h"
@@ skipping 35 matching lines @@
 }
 }  // namespace
 
 static const base::FilePath::CharType kFrameAnalyzerExecutable[] =
 #if defined(OS_WIN)
     FILE_PATH_LITERAL("frame_analyzer.exe");
 #else
     FILE_PATH_LITERAL("frame_analyzer");
 #endif
 
-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 base::FilePath::CharType kCapturedYuvFileName[] =
     FILE_PATH_LITERAL("captured_video.yuv");
+static const base::FilePath::CharType kCapturedWebmFileName[] =
+    FILE_PATH_LITERAL("captured_video.webm");
 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 struct VideoQualityTestConfig {
   const char* test_name;
   int width;
@@ skipping 50 matching lines @@
         .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);
   }
 
-  // Writes all frames we've captured so far by grabbing them from the
-  // javascript and writing them to the temporary work directory.
-  void WriteCapturedFramesToWorkingDir(content::WebContents* capturing_tab) {
-    int num_frames = 0;
-    std::string response =
-        ExecuteJavascript("getTotalNumberCapturedFrames()", capturing_tab);
-    ASSERT_TRUE(base::StringToInt(response, &num_frames)) <<
-        "Failed to retrieve frame count: got " << response;
-    ASSERT_NE(0, num_frames) << "Failed to capture any frames.";
-
-    for (int i = 0; i < num_frames; i++) {
-      std::string base64_encoded_frame =
-          ExecuteJavascript(base::StringPrintf("getOneCapturedFrame(%d)", i),
-                            capturing_tab);
-      std::string decoded_frame;
-      ASSERT_TRUE(base::Base64Decode(base64_encoded_frame, &decoded_frame))
-          << "Failed to decode frame data '" << base64_encoded_frame << "'.";
-
-      std::string file_name = base::StringPrintf("frame_%04d", i);
-      base::File frame_file(GetWorkingDir().AppendASCII(file_name),
-                            base::File::FLAG_CREATE | base::File::FLAG_WRITE);
-      size_t written = frame_file.Write(0, decoded_frame.c_str(),
-                                        decoded_frame.length());
-      ASSERT_EQ(decoded_frame.length(), written);
-    }
+  // Writes the captured video to a webm file.
+  void WriteCapturedWebmVideo(content::WebContents* capturing_tab,
+                          const base::FilePath& webm_video_filename) {
+    std::string base64_encoded_video =
+        ExecuteJavascript("getRecordedVideoAsBase64()", capturing_tab);
+    std::string recorded_video;
+    ASSERT_TRUE(base::Base64Decode(base64_encoded_video, &recorded_video));
+    base::File video_file(webm_video_filename,
+                          base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+    size_t written = video_file.Write(0, recorded_video.c_str(),
+                                      recorded_video.length());
+    ASSERT_EQ(recorded_video.length(), written);
   }
 
-  // Runs the RGBA to I420 converter on the video in |capture_video_filename|,
-  // which should contain frames of size |width| x |height|.
-  //
-  // The rgba_to_i420_converter is part of the webrtc_test_tools target which
-  // should be build prior to running this test. The resulting binary should
-  // live next to Chrome.
-  bool RunARGBtoI420Converter(int width,

[kjellander_chromium, 2016/08/01 05:53:34]

I'm quite sure this is the only place we use this tool so we should take the
opportunity to delete the tool now, i.e. essentially make sure
https://cs.chromium.org/search/?q=rgba_to_i420&sq=package:chromium&type=cs
returns 0 results. Great to reduce the complexity of the video quality
toolchain!

-                              int height,
-                              const base::FilePath& captured_video_filename) {
-    base::FilePath path_to_converter =
-        GetBrowserDir().Append(kArgbToI420ConverterExecutable);
-
-    if (!base::PathExists(path_to_converter)) {
-      LOG(ERROR) << "Missing ARGB->I420 converter: should be in "
-          << path_to_converter.value()
-          << ". Try building the chromium_builder_webrtc target.";
+  // Runs ffmpeg on the captured webm video and writes it to a yuv video file.
+  bool RunWebmToI420Converter(const base::FilePath& webm_video_filename,
+                              const base::FilePath& yuv_video_filename) {
+    base::FilePath path_to_ffmpeg = test::GetToolForPlatform("ffmpeg");
+    if (!base::PathExists(path_to_ffmpeg)) {
+      LOG(ERROR) << "Missing ffmpeg: should be in " << path_to_ffmpeg.value();
       return false;
     }
 
-    base::CommandLine converter_command(path_to_converter);
-    converter_command.AppendSwitchPath("--frames_dir", GetWorkingDir());
-    converter_command.AppendSwitchPath("--output_file",
-                                       captured_video_filename);
-    converter_command.AppendSwitchASCII("--width", base::IntToString(width));
-    converter_command.AppendSwitchASCII("--height", base::IntToString(height));
-    converter_command.AppendSwitchASCII("--delete_frames", "true");
+    base::CommandLine ffmpeg_command(path_to_ffmpeg);
+    ffmpeg_command.AppendArg("-i");
+    ffmpeg_command.AppendArgPath(webm_video_filename);
+    ffmpeg_command.AppendArgPath(yuv_video_filename);
 
     // We produce an output file that will later be used as an input to the
     // barcode decoder and frame analyzer tools.
-    DVLOG(0) << "Running " << converter_command.GetCommandLineString();
+    DVLOG(0) << "Running " << ffmpeg_command.GetCommandLineString();
     std::string result;
-    bool ok = base::GetAppOutput(converter_command, &result);
+    bool ok = base::GetAppOutput(ffmpeg_command, &result);
     DVLOG(0) << "Output was:\n\n" << result;
     return ok;
   }
 
   // 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
@@ skipping 98 matching lines @@
 
     // 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);
 
-    WriteCapturedFramesToWorkingDir(right_tab);
+    WriteCapturedWebmVideo(
+        right_tab, GetWorkingDir().Append(kCapturedWebmFileName));
 
     // 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).
     chrome::CloseWebContents(browser(), left_tab, false);
     chrome::CloseWebContents(browser(), right_tab, false);
 
-    ASSERT_TRUE(
-        RunARGBtoI420Converter(test_config_.width, test_config_.height,
-                               GetWorkingDir().Append(kCapturedYuvFileName)));
+    RunWebmToI420Converter(GetWorkingDir().Append(kCapturedWebmFileName),
+                           GetWorkingDir().Append(kCapturedYuvFileName));
 
     ASSERT_TRUE(CompareVideosAndPrintResult(
         MakeLabel(test_config_.test_name, video_codec), test_config_.width,
         test_config_.height, GetWorkingDir().Append(kCapturedYuvFileName),
         test::GetReferenceFilesDir()
             .Append(test_config_.reference_video)
             .AddExtension(test::kYuvFileExtension),
         GetWorkingDir().Append(kStatsFileName)));
   }
 
@@ skipping 43 matching lines @@
   if (!base::FeatureList::IsEnabled(content::kWebRtcH264WithOpenH264FFmpeg)) {
     LOG(WARNING) << "Run-time feature WebRTC-H264WithOpenH264FFmpeg disabled. "
         "Skipping WebRtcVideoQualityBrowserTest.MANUAL_TestVideoQualityH264 "
         "(test \"OK\")";
     return;
   }
   TestVideoQuality("H264");
 }
 
 #endif  // BUILDFLAG(RTC_USE_H264)