Reland of RTCVideoEncoder: Report H264 profile information to WebRTC

chrome/browser/media/webrtc/webrtc_stats_perf_browsertest.cc

 // Copyright 2016 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 <string>
 
 #include "base/command_line.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
@@ skipping 70 matching lines @@
     // Play a suitable, somewhat realistic video file.
     base::FilePath input_video = test::GetReferenceFilesDir()
         .Append(test::kReferenceFileName360p)
         .AddExtension(test::kY4mFileExtension);
     command_line->AppendSwitchPath(switches::kUseFileForFakeVideoCapture,
                                    input_video);
     command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
   }
 
   void StartCall(const std::string& audio_codec,
-                 const std::string& video_codec) {
+                 const std::string& video_codec,
+                 bool prefer_hw_video_codec) {
     ASSERT_TRUE(test::HasReferenceFilesInCheckout());
     ASSERT_TRUE(embedded_test_server()->Start());
 
     ASSERT_GE(TestTimeouts::action_max_timeout().InSeconds(), 100)
         << "This is a long-running test; you must specify "
            "--ui-test-action-max-timeout to have a value of at least 100000.";
 
     left_tab_ = OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
     right_tab_ = OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
     SetupPeerconnectionWithLocalStream(left_tab_);
     SetupPeerconnectionWithLocalStream(right_tab_);
     SetDefaultAudioCodec(left_tab_, audio_codec);
     SetDefaultAudioCodec(right_tab_, audio_codec);
-    SetDefaultVideoCodec(left_tab_, video_codec);
-    SetDefaultVideoCodec(right_tab_, video_codec);
+    SetDefaultVideoCodec(left_tab_, video_codec, prefer_hw_video_codec);
+    SetDefaultVideoCodec(right_tab_, video_codec, prefer_hw_video_codec);
     CreateDataChannel(left_tab_, "data");
     CreateDataChannel(right_tab_, "data");
     NegotiateCall(left_tab_, right_tab_);
     StartDetectingVideo(left_tab_, "remote-view");
     StartDetectingVideo(right_tab_, "remote-view");
     WaitForVideoToPlay(left_tab_);
     WaitForVideoToPlay(right_tab_);
   }
 
   void EndCall() {
     if (left_tab_)
       HangUp(left_tab_);
     if (right_tab_)
       HangUp(right_tab_);
   }
 
-  void RunsAudioAndVideoCallCollectingMetrics(
-      const std::string& audio_codec, const std::string& video_codec) {
-    StartCall(audio_codec, video_codec);
+  void RunsAudioAndVideoCallCollectingMetricsWithAudioCodec(
+      const std::string& audio_codec) {
+    RunsAudioAndVideoCallCollectingMetrics(audio_codec, kUseDefaultVideoCodec,
+                                           false /* prefer_hw_video_codec */);
+  }
+
+  void RunsAudioAndVideoCallCollectingMetricsWithVideoCodec(
+      const std::string& video_codec,
+      bool prefer_hw_video_codec) {
+    RunsAudioAndVideoCallCollectingMetrics(kUseDefaultAudioCodec, video_codec,
+                                           prefer_hw_video_codec);
+  }
+
+  void RunsAudioAndVideoCallCollectingMetrics(const std::string& audio_codec,
+                                              const std::string& video_codec,
+                                              bool prefer_hw_video_codec) {
+    StartCall(audio_codec, video_codec, prefer_hw_video_codec);
 
     // Call for 60 seconds so that values may stabilize, bandwidth ramp up, etc.
     test::SleepInJavascript(left_tab_, 60000);
 
     // The ramp-up may vary greatly and impact the resulting total bytes, to get
     // reliable measurements we do two measurements, at 60 and 70 seconds and
     // look at the average bytes/second in that window.
     double audio_bytes_sent_before = 0.0;
     double audio_bytes_received_before = 0.0;
     double video_bytes_sent_before = 0.0;
@@ skipping 55 matching lines @@
           "bytes/second", false);
     }
 
     EndCall();
   }
 
   void RunsAudioAndVideoCallMeasuringGetStatsPerformance(
       GetStatsVariation variation) {
     EXPECT_TRUE(base::TimeTicks::IsHighResolution());
 
-    StartCall(kUseDefaultAudioCodec, kUseDefaultVideoCodec);
+    StartCall(kUseDefaultAudioCodec, kUseDefaultVideoCodec,
+              false /* prefer_hw_video_codec */);
 
     double invocation_time = 0.0;
     switch (variation) {
       case GetStatsVariation::PROMISE_BASED:
         invocation_time = (MeasureGetStatsPerformance(left_tab_) +
                            MeasureGetStatsPerformance(right_tab_)) / 2.0;
         break;
       case GetStatsVariation::CALLBACK_BASED:
         invocation_time =
             (MeasureGetStatsCallbackPerformance(left_tab_) +
@@ skipping 14 matching lines @@
 
  private:
   content::WebContents* left_tab_ = nullptr;
   content::WebContents* right_tab_ = nullptr;
 };
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_AudioCodec_opus) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics("opus", kUseDefaultVideoCodec);
+  RunsAudioAndVideoCallCollectingMetricsWithAudioCodec("opus");
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_AudioCodec_ISAC) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics("ISAC", kUseDefaultVideoCodec);
+  RunsAudioAndVideoCallCollectingMetricsWithAudioCodec("ISAC");
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_AudioCodec_G722) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics("G722", kUseDefaultVideoCodec);
+  RunsAudioAndVideoCallCollectingMetricsWithAudioCodec("G722");
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_AudioCodec_PCMU) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics("PCMU", kUseDefaultVideoCodec);
+  RunsAudioAndVideoCallCollectingMetricsWithAudioCodec("PCMU");
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_AudioCodec_PCMA) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics("PCMA", kUseDefaultVideoCodec);
+  RunsAudioAndVideoCallCollectingMetricsWithAudioCodec("PCMA");
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_VideoCodec_VP8) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics(kUseDefaultAudioCodec, "VP8");
+  RunsAudioAndVideoCallCollectingMetricsWithVideoCodec(
+      "VP8", false /* prefer_hw_video_codec */);
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_VideoCodec_VP9) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
-  RunsAudioAndVideoCallCollectingMetrics(kUseDefaultAudioCodec, "VP9");
+  RunsAudioAndVideoCallCollectingMetricsWithVideoCodec(
+      "VP9", false /* prefer_hw_video_codec */);
 }
 
 #if BUILDFLAG(RTC_USE_H264)
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallCollectingMetrics_VideoCodec_H264) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   // Only run test if run-time feature corresponding to |rtc_use_h264| is on.
   if (!base::FeatureList::IsEnabled(content::kWebRtcH264WithOpenH264FFmpeg)) {
     LOG(WARNING) << "Run-time feature WebRTC-H264WithOpenH264FFmpeg disabled. "
         "Skipping WebRtcPerfBrowserTest."
         "MANUAL_RunsAudioAndVideoCallCollectingMetrics_VideoCodec_H264 (test "
         "\"OK\")";
     return;
   }
-  RunsAudioAndVideoCallCollectingMetrics(kUseDefaultAudioCodec, "H264");
+  RunsAudioAndVideoCallCollectingMetricsWithVideoCodec(
+      "H264", true /* prefer_hw_video_codec */);
 }
 
 #endif  // BUILDFLAG(RTC_USE_H264)
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallMeasuringGetStatsPerformance_Promise) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   RunsAudioAndVideoCallMeasuringGetStatsPerformance(
       GetStatsVariation::PROMISE_BASED);
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcStatsPerfBrowserTest,
     MANUAL_RunsAudioAndVideoCallMeasuringGetStatsPerformance_Callback) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   RunsAudioAndVideoCallMeasuringGetStatsPerformance(
       GetStatsVariation::CALLBACK_BASED);
 }
 
 }  // namespace
 
 }  // namespace content