Adds a WebRTC browser_test with opus dtx enabled.

chrome/browser/media/webrtc_perf_browsertest.cc

 // Copyright 2014 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 <memory>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
@@ skipping 87 matching lines @@
     ui_test_utils::NavigateToURL(browser(), GURL("chrome://webrtc-internals"));
     content::WebContents* webrtc_internals_tab =
         browser()->tab_strip_model()->GetActiveWebContents();
 
     test::SleepInJavascript(webrtc_internals_tab, duration_msec);
 
     return std::unique_ptr<base::DictionaryValue>(
         GetWebrtcInternalsData(webrtc_internals_tab));
   }
 
   void RunsAudioVideoCall60SecsAndLogsInternalMetrics(

[phoglund_chromium, 2016/07/27 09:15:05]

You're not using opus_dtx for two-way calls, so remove the argument here. Just
do

NegotiateCall(left_tab, right_tab, video_codec, false /* opus_dtx */);

and remove the opus_dtx suffics from 145-148.

[Ivo-OOO until feb 6, 2016/07/27 14:12:43]

Done.

-      const std::string& video_codec) {
+      const std::string& video_codec,
+      bool opus_dtx) {
     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);
 
-    NegotiateCall(left_tab, right_tab, video_codec);
+    NegotiateCall(left_tab, right_tab, video_codec, opus_dtx);
 
     StartDetectingVideo(left_tab, "remote-view");
     StartDetectingVideo(right_tab, "remote-view");
 
     WaitForVideoToPlay(left_tab);
     WaitForVideoToPlay(right_tab);
 
     // Let values stabilize, bandwidth ramp up, etc.
     test::SleepInJavascript(left_tab, 60000);
 
     // Start measurements.
     std::unique_ptr<base::DictionaryValue> all_data =
         MeasureWebRtcInternalsData(10000);
     ASSERT_TRUE(all_data.get() != NULL);
 
     const base::DictionaryValue* first_pc_dict =
         GetDataOnPeerConnection(all_data.get(), 0);
     ASSERT_TRUE(first_pc_dict != NULL);
-    test::PrintBweForVideoMetrics(*first_pc_dict, "", video_codec);
-    test::PrintMetricsForAllStreams(*first_pc_dict, "", video_codec);
+    test::PrintBweForVideoMetrics(*first_pc_dict, opus_dtx ? "opus_dtx" : "",
+                                  video_codec);
+    test::PrintMetricsForAllStreams(*first_pc_dict, opus_dtx ? "opus_dtx" : "",
+                                    video_codec);
 
     HangUp(left_tab);
     HangUp(right_tab);
   }
 
   void RunsOneWayCall60SecsAndLogsInternalMetrics(
-      const std::string& video_codec) {
+      const std::string& video_codec,
+      bool opus_dtx) {
     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);
     SetupPeerconnectionWithoutLocalStream(right_tab);
 
-    NegotiateCall(left_tab, right_tab, video_codec);
+    NegotiateCall(left_tab, right_tab, video_codec, opus_dtx);
 
     // Remote video will only play in one tab since the call is one-way.
     StartDetectingVideo(right_tab, "remote-view");
     WaitForVideoToPlay(right_tab);
 
     // Let values stabilize, bandwidth ramp up, etc.
     test::SleepInJavascript(left_tab, 60000);
 
     std::unique_ptr<base::DictionaryValue> all_data =
         MeasureWebRtcInternalsData(10000);
     ASSERT_TRUE(all_data.get() != NULL);
 
     // This assumes the sending peer connection is always listed first in the
     // data store, and the receiving second.
     const base::DictionaryValue* first_pc_dict =
         GetDataOnPeerConnection(all_data.get(), 0);
     ASSERT_TRUE(first_pc_dict != NULL);
-    test::PrintBweForVideoMetrics(*first_pc_dict, "_sendonly", video_codec);
-    test::PrintMetricsForSendStreams(*first_pc_dict, "_sendonly", video_codec);
+    test::PrintBweForVideoMetrics(
+        *first_pc_dict, opus_dtx ? "_sendonly_with_opus_dtx" : "_sendonly",
+        video_codec);
+    test::PrintMetricsForSendStreams(
+        *first_pc_dict, opus_dtx ? "_sendonly_with_opus_dtx" : "_sendonly",
+        video_codec);
 
     const base::DictionaryValue* second_pc_dict =
         GetDataOnPeerConnection(all_data.get(), 1);
     ASSERT_TRUE(second_pc_dict != NULL);
-    test::PrintBweForVideoMetrics(*second_pc_dict, "_recvonly", video_codec);
-    test::PrintMetricsForRecvStreams(*second_pc_dict, "_recvonly", video_codec);
+    test::PrintBweForVideoMetrics(
+        *second_pc_dict, opus_dtx ? "_recvonly_with_opus_dtx" : "_recvonly",
+        video_codec);
+    test::PrintMetricsForRecvStreams(
+        *second_pc_dict, opus_dtx ? "_recvonly_with_opus_dtx" : "_recvonly",
+        video_codec);
 
     HangUp(left_tab);
     HangUp(right_tab);
   }
 };
 
 // This is manual for its long execution time.
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcPerfBrowserTest,
     MANUAL_RunsAudioVideoCall60SecsAndLogsInternalMetricsVp8) {
-  RunsAudioVideoCall60SecsAndLogsInternalMetrics("VP8");
+  RunsAudioVideoCall60SecsAndLogsInternalMetrics("VP8", false);
 }
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcPerfBrowserTest,
     MANUAL_RunsAudioVideoCall60SecsAndLogsInternalMetricsVp9) {
-  RunsAudioVideoCall60SecsAndLogsInternalMetrics("VP9");
+  RunsAudioVideoCall60SecsAndLogsInternalMetrics("VP9", false);
 }
 
 #if BUILDFLAG(RTC_USE_H264)
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcPerfBrowserTest,
     MANUAL_RunsAudioVideoCall60SecsAndLogsInternalMetricsH264) {
   // 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_RunsAudioVideoCall60SecsAndLogs"
         "InternalMetricsH264 (test \"OK\")";
     return;
   }
-  RunsAudioVideoCall60SecsAndLogsInternalMetrics("H264");
+  RunsAudioVideoCall60SecsAndLogsInternalMetrics("H264", false);
 }
 
 #endif  // BUILDFLAG(RTC_USE_H264)
 
 IN_PROC_BROWSER_TEST_F(
     WebRtcPerfBrowserTest,
     MANUAL_RunsOneWayCall60SecsAndLogsInternalMetricsDefault) {
-  RunsOneWayCall60SecsAndLogsInternalMetrics("");
+  RunsOneWayCall60SecsAndLogsInternalMetrics("", false);
 }
+
+IN_PROC_BROWSER_TEST_F(
+    WebRtcPerfBrowserTest,
+    MANUAL_RunsOneWayCall60SecsAndLogsInternalMetricsWithOpusDtx) {
+  RunsOneWayCall60SecsAndLogsInternalMetrics("", true);
+}