WebRtcStatsPerfBrowserTest added, a perf test using the new getStats

chrome/browser/media/webrtc/webrtc_performance_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 "chrome/browser/media/webrtc/rtc_stats_dictionary.h"
+#include "chrome/browser/media/webrtc/webrtc_browsertest_base.h"
+#include "chrome/browser/media/webrtc/webrtc_browsertest_common.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/common/feature_h264_with_openh264_ffmpeg.h"
+#include "media/base/media_switches.h"
+#include "testing/perf/perf_test.h"
+
+namespace content {
+
+namespace {
+
+const char kMainWebrtcTestHtmlPage[] = "/webrtc/webrtc_jsep01_test.html";
+
+// Sums up "RTC[In/Out]boundRTPStreamStats.bytes_[received/sent]" values.
+double GetTotalRTPStreamBytes(
+    RTCStatsReportDictionary* report, bool inbound, const char* media_type) {

[hta - Chromium, 2016/12/05 09:07:16]

would actually like this better if the "inbound" parameter had the values
"inbound-rtp" and "outbound-rtp". Call site is easier to read. You'd have to
check the value here for correctness, of course.

[hbos_chromium, 2016/12/05 09:41:58]

Done.

+  const char* type = inbound ? "inbound-rtp" : "outbound-rtp";
+  const char* bytes_name = inbound ? "bytesReceived" : "bytesSent";
+  double total_bytes = 0.0;
+  report->ForEach([&type, &bytes_name, &media_type, &total_bytes](
+      const RTCStatsDictionary& stats) {
+    if (stats.GetString("type") == type &&
+        stats.GetString("mediaType") == media_type) {
+      total_bytes += stats.GetNumber(bytes_name);
+    }
+  });
+  return total_bytes;
+}
+
+double GetAudioBytesSent(RTCStatsReportDictionary* report) {
+  return GetTotalRTPStreamBytes(report, false, "audio");
+}
+
+double GetAudioBytesReceived(RTCStatsReportDictionary* report) {
+  return GetTotalRTPStreamBytes(report, true, "audio");
+}
+
+double GetVideoBytesSent(RTCStatsReportDictionary* report) {
+  return GetTotalRTPStreamBytes(report, false, "video");
+}
+
+double GetVideoBytesReceived(RTCStatsReportDictionary* report) {
+  return GetTotalRTPStreamBytes(report, true, "video");
+}
+
+// This is different from |WebRtcPerfBrowserTest| in that it uses the
+// promise-based "RTCPeerConnection.getStats" (as opposed to
+// "chrome://webrtc-internals/"). The stats provided are different.

[hta - Chromium, 2016/12/05 09:07:16]

s/different/standards conformant/. Be proud!

[hbos_chromium, 2016/12/05 09:41:58]

:D

+class WebRtcPerformanceBrowserTest : public WebRtcTestBase {
+ public:
+  void SetUpInProcessBrowserTestFixture() override {
+    DetectErrorsInJavaScript();
+  }
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    // Ensure the infobar is enabled, since we expect that in this test.
+    EXPECT_FALSE(command_line->HasSwitch(switches::kUseFakeUIForMediaStream));
+
+    // 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);
+
+    command_line->AppendSwitchASCII(switches::kEnableBlinkFeatures,
+                                    "RTCPeerConnectionNewGetStats");
+  }
+
+  void RunsAudioAndVideoCallFor60Secs(
+      const std::string& audio_codec, const std::string& 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.";
+
+    content::WebContents* left_tab =
+        OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
+    content::WebContents* 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);
+    NegotiateCall(left_tab, right_tab);
+    StartDetectingVideo(left_tab, "remote-view");
+    StartDetectingVideo(right_tab, "remote-view");
+    WaitForVideoToPlay(left_tab);
+    WaitForVideoToPlay(right_tab);
+
+    // Let call last for 60 seconds so that values may stabilize, bandwidth can
+    // ramp up, etc.
+    test::SleepInJavascript(left_tab, 60000);
+
+    scoped_refptr<RTCStatsReportDictionary> report =
+        GetStatsReportDictionary(left_tab);
+
+    if (audio_codec != kUseDefaultAudioCodec) {
+      double audio_bytes_sent = GetAudioBytesSent(report.get());
+      double audio_bytes_received = GetAudioBytesReceived(report.get());
+
+      std::string audio_codec_modifier = "_" + audio_codec;
+      perf_test::PrintResult(
+          "audio", audio_codec_modifier, "bytes_sent", audio_bytes_sent,
+          "bytes", false);
+      perf_test::PrintResult(
+          "audio", audio_codec_modifier, "bytes_received", audio_bytes_received,
+          "bytes", false);
+    }
+
+    if (video_codec != kUseDefaultVideoCodec) {
+      double video_bytes_sent = GetVideoBytesSent(report.get());
+      double video_bytes_received = GetVideoBytesReceived(report.get());
+
+      std::string video_codec_modifier = "_" + video_codec;
+      perf_test::PrintResult(
+          "video", video_codec_modifier, "bytes_sent", video_bytes_sent,
+          "bytes", false);
+      perf_test::PrintResult(
+          "video", video_codec_modifier, "bytes_received", video_bytes_received,
+          "bytes", false);
+    }
+
+    HangUp(left_tab);
+    HangUp(right_tab);
+  }
+};
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_AudioCodec_opus) {
+  RunsAudioAndVideoCallFor60Secs("opus", kUseDefaultVideoCodec);
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_AudioCodec_ISAC) {
+  RunsAudioAndVideoCallFor60Secs("ISAC", kUseDefaultVideoCodec);
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_AudioCodec_G722) {
+  RunsAudioAndVideoCallFor60Secs("G722", kUseDefaultVideoCodec);
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_AudioCodec_PCMU) {
+  RunsAudioAndVideoCallFor60Secs("PCMU", kUseDefaultVideoCodec);
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_AudioCodec_PCMA) {
+  RunsAudioAndVideoCallFor60Secs("PCMA", kUseDefaultVideoCodec);
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_VideoCodec_VP8) {
+  RunsAudioAndVideoCallFor60Secs(kUseDefaultAudioCodec, "VP8");
+}
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_VideoCodec_VP9) {
+  RunsAudioAndVideoCallFor60Secs(kUseDefaultAudioCodec, "VP9");
+}
+
+#if BUILDFLAG(RTC_USE_H264)
+
+IN_PROC_BROWSER_TEST_F(WebRtcPerformanceBrowserTest,
+                       MANUAL_RunsAudioAndVideoCallFor60Secs_VideoCodec_H264) {
+  // 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_RunsAudioAndVideoCallFor60Secs_VideoCodec_H264 (test \"OK\")";
+    return;
+  }
+  RunsAudioAndVideoCallFor60Secs(kUseDefaultAudioCodec, "H264");
+}
+
+#endif  // BUILDFLAG(RTC_USE_H264)
+
+}  // namespace
+
+}  // namespace content