Made WebRTC AQ test two-way, adjusted volume on Mac.

chrome/browser/media/chrome_webrtc_audio_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 <ctime>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 137 matching lines @@
     content::WebContents* tab =
         browser()->tab_strip_model()->GetActiveWebContents();
 
     // Prepare the peer connections manually in this test since we don't add
     // getUserMedia-derived media streams in this test like the other tests.
     EXPECT_EQ("ok-peerconnection-created",
               ExecuteJavascript("preparePeerConnection()", tab));
     return tab;
   }
 
+  void MuteMediaElement(const std::string& element_id,
+                        content::WebContents* tab_contents) {
+    EXPECT_EQ("ok-muted", ExecuteJavascript(
+        "setMediaElementMuted('" + element_id + "', true)", tab_contents));
+  }
+
  protected:
   void TestAutoGainControl(const base::FilePath::StringType& reference_filename,
                            const std::string& constraints,
                            const std::string& perf_modifier);
   void SetupAndRecordAudioCall(const base::FilePath& reference_file,
                                const base::FilePath& recording,
                                const std::string& constraints,
                                const base::TimeDelta recording_time);
 };
 
@@ skipping 91 matching lines @@
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
 #elif defined(OS_MACOSX)
   base::CommandLine command_line(
       base::FilePath(FILE_PATH_LITERAL("osascript")));
   command_line.AppendArg("-e");
   command_line.AppendArg("set volume input volume 100");
   command_line.AppendArg("-e");
-  command_line.AppendArg("set volume output volume 100");
+  command_line.AppendArg("set volume output volume 85");
 
   std::string result;
   if (!base::GetAppOutput(command_line, &result)) {
     LOG(ERROR) << "Failed to set source volume: output was " << result;
     return false;
   }
 #else
   // Just force the volume of, say the first 5 devices. A machine will rarely
   // have more input sources than that. This is way easier than finding the
   // input device we happen to be using.
@@ skipping 278 matching lines @@
       "audio_pesq", perf_modifier, "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult(
       "audio_pesq", perf_modifier, "mos_lqo", mos_lqo, "score", true);
 
   EXPECT_TRUE(base::DeleteFile(trimmed_reference, false));
   EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
 }
 
 }  // namespace
 
-// Sets up a one-way WebRTC call and records its output to |recording|, using
+// Sets up a two-way WebRTC call and records its output to |recording|, using
 // getUserMedia.
 //
 // |reference_file| should have at least two seconds of silence in the
 // beginning: otherwise all the reference audio will not be picked up by the
 // recording. Note that the reference file will start playing as soon as the
 // audio device is up following the getUserMedia call in the left tab. The time
 // it takes to negotiate a call isn't deterministic, but two seconds should be
 // plenty of time. Similarly, the recording time should be enough to catch the
 // whole reference file. If you then silence-trim the reference file and actual
 // file, you should end up with two time-synchronized files.
 void MAYBE_WebRtcAudioQualityBrowserTest::SetupAndRecordAudioCall(
     const base::FilePath& reference_file,
     const base::FilePath& recording,
     const std::string& constraints,
     const base::TimeDelta recording_time) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
   ConfigureFakeDeviceToPlayFile(reference_file);
 
-  // Create a one-way call.
+  // Create a two-way call. Mute one of the receivers though; that way it will
+  // be receiving audio bytes, but we will not be playing out of both elements.
   GURL test_page = embedded_test_server()->GetURL(kWebRtcAudioTestHtmlPage);
   content::WebContents* left_tab =
       OpenPageAndGetUserMediaInNewTabWithConstraints(test_page, constraints);
   SetupPeerconnectionWithLocalStream(left_tab);
+  MuteMediaElement("remote-view", left_tab);
 
   content::WebContents* right_tab =
-      OpenPageWithoutGetUserMedia(kWebRtcAudioTestHtmlPage);
+      OpenPageAndGetUserMediaInNewTabWithConstraints(test_page, constraints);
+  SetupPeerconnectionWithLocalStream(right_tab);
 
   AudioRecorder recorder;
   ASSERT_TRUE(recorder.StartRecording(recording_time, recording));
 
   NegotiateCall(left_tab, right_tab);
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   DVLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
 }
 
-#if defined(OS_MACOSX)
-// Broken on Mac for some reason: http://crbug.com/446859.
-#define MAYBE_MANUAL_TestCallQualityWithAudioFromFakeDevice \
-    DISABLED_MANUAL_TestCallQualityWithAudioFromFakeDevice
-#else
-#define MAYBE_MANUAL_TestCallQualityWithAudioFromFakeDevice \
-    MANUAL_TestCallQualityWithAudioFromFakeDevice
-#endif
-
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
-                       MAYBE_MANUAL_TestCallQualityWithAudioFromFakeDevice) {
+                       MANUAL_TestCallQualityWithAudioFromFakeDevice) {
   if (OnWinXp() || OnWin8()) {
     // http://crbug.com/379798.
     LOG(ERROR) << "This test is not implemented for Windows XP/Win8.";
     return;
   }
 
   base::FilePath reference_file =
       test::GetReferenceFilesDir().Append(kReferenceFile);
   base::FilePath recording = CreateTemporaryWaveFile();
 
@@ skipping 143 matching lines @@
 #endif
 
 // Since the AGC is off here there should be no gain at all.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcAudioQualityBrowserTest,
                        MAYBE_MANUAL_TestAutoGainIsOffWithAudioProcessingOff) {
   const char* kAudioCallWithoutAudioProcessing =
       "{audio: { mandatory: { echoCancellation: false } } }";
   ASSERT_NO_FATAL_FAILURE(TestAutoGainControl(
       kReferenceFile, kAudioCallWithoutAudioProcessing, "_no_agc"));
 }