Rewrote WebRTC browser tests to not use peerconnection_server.

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/file_util.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
@@ skipping 69 matching lines @@
 // 5. Launch chrome and try playing a video with sound. You should see
 //    in the volume meter for the mix device. Configure the mix device to have
 //    50 / 100 in level. Also go into the playback tab, right-click Speakers,
 //    and set that level to 50 / 100. Otherwise you will get distortion in
 //    the recording.
 class WebRtcAudioQualityBrowserTest : public WebRtcTestBase,
                                       public testing::WithParamInterface<bool> {
  public:
   WebRtcAudioQualityBrowserTest() {}
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    test::PeerConnectionServerRunner::KillAllPeerConnectionServers();
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     // This test expects real device handling and requires a real webcam / audio
     // device; it will not work with fake devices.
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeDeviceForMediaStream));
     EXPECT_FALSE(command_line->HasSwitch(
         switches::kUseFakeUIForMediaStream));
 
     bool enable_audio_track_processing = GetParam();
     if (enable_audio_track_processing)
       command_line->AppendSwitch(switches::kEnableAudioTrackProcessing);
   }
 
   void AddAudioFile(const std::string& input_file_relative_url,
                     content::WebContents* tab_contents) {
     EXPECT_EQ("ok-added", ExecuteJavascript(
         "addAudioFile('" + input_file_relative_url + "')", tab_contents));
   }
 
   void PlayAudioFile(content::WebContents* tab_contents) {
     EXPECT_EQ("ok-playing", ExecuteJavascript("playAudioFile()", tab_contents));
   }
 
-  void EstablishCall(content::WebContents* from_tab,
-                     content::WebContents* to_tab) {
-    EXPECT_EQ("ok-negotiating",
-              ExecuteJavascript("negotiateCall()", from_tab));
-
-    // Ensure the call gets up on both sides.
-    EXPECT_TRUE(test::PollingWaitUntil("getPeerConnectionReadyState()",
-                                       "active", from_tab));
-    EXPECT_TRUE(test::PollingWaitUntil("getPeerConnectionReadyState()",
-                                       "active", to_tab));
-  }
-
   base::FilePath CreateTemporaryWaveFile() {
     base::FilePath filename;
     EXPECT_TRUE(base::CreateTemporaryFile(&filename));
     base::FilePath wav_filename =
         filename.AddExtension(FILE_PATH_LITERAL(".wav"));
     EXPECT_TRUE(base::Move(filename, wav_filename));
     return wav_filename;
   }
-
-  test::PeerConnectionServerRunner peerconnection_server_;
 };
 
 class AudioRecorder {
  public:
   AudioRecorder(): recording_application_(base::kNullProcessHandle) {}
   ~AudioRecorder() {}
 
   // Starts the recording program for the specified duration. Returns true
   // on success.
   bool StartRecording(int duration_sec, const base::FilePath& output_file,
@@ skipping 217 matching lines @@
                        MAYBE_MANUAL_TestAudioQuality) {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     // It would take work to implement this on XP; not prioritized right now.
     LOG(ERROR) << "This test is not implemented for Windows XP.";
     return;
   }
 #endif
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
-  ASSERT_TRUE(peerconnection_server_.Start());
 
   ASSERT_TRUE(ForceMicrophoneVolumeTo100Percent());
 
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(kMainWebrtcTestHtmlPage));
   content::WebContents* left_tab =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   chrome::AddTabAt(browser(), GURL(), -1, true);
   content::WebContents* right_tab =
       browser()->tab_strip_model()->GetActiveWebContents();
   ui_test_utils::NavigateToURL(
       browser(), embedded_test_server()->GetURL(kMainWebrtcTestHtmlPage));
 
-  ConnectToPeerConnectionServer("peer 1", left_tab);
-  ConnectToPeerConnectionServer("peer 2", right_tab);
-
+  // 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()", left_tab));
+  EXPECT_EQ("ok-peerconnection-created",
+            ExecuteJavascript("preparePeerConnection()", right_tab));
 
   AddAudioFile(kReferenceFileRelativeUrl, left_tab);
 
-  EstablishCall(left_tab, right_tab);
+  NegotiateCall(left_tab, right_tab);
 
   // Note: the media flow isn't necessarily established on the connection just
   // because the ready state is ok on both sides. We sleep a bit between call
   // establishment and playing to avoid cutting of the beginning of the audio
   // file.
   test::SleepInJavascript(left_tab, 2000);
 
   base::FilePath recording = CreateTemporaryWaveFile();
 
   // Note: the sound clip is about 10 seconds: record for 15 seconds to get some
   // safety margins on each side.
   AudioRecorder recorder;
   static int kRecordingTimeSeconds = 15;
   ASSERT_TRUE(recorder.StartRecording(kRecordingTimeSeconds, recording, true));
 
   PlayAudioFile(left_tab);
 
   ASSERT_TRUE(recorder.WaitForRecordingToEnd());
   VLOG(0) << "Done recording to " << recording.value() << std::endl;
 
   HangUp(left_tab);
-  WaitUntilHangupVerified(left_tab);
-  WaitUntilHangupVerified(right_tab);
 
   base::FilePath trimmed_recording = CreateTemporaryWaveFile();
 
   ASSERT_TRUE(RemoveSilence(recording, trimmed_recording));
   VLOG(0) << "Trimmed silence: " << trimmed_recording.value() << std::endl;
 
   std::string raw_mos;
   std::string mos_lqo;
   base::FilePath reference_file_in_test_dir =
       test::GetReferenceFilesDir().Append(kReferenceFile);
   ASSERT_TRUE(RunPesq(reference_file_in_test_dir, trimmed_recording, 16000,
                       &raw_mos, &mos_lqo));
 
   perf_test::PrintResult("audio_pesq", "", "raw_mos", raw_mos, "score", true);
   perf_test::PrintResult("audio_pesq", "", "mos_lqo", mos_lqo, "score", true);
 
   EXPECT_TRUE(base::DeleteFile(recording, false));
   EXPECT_TRUE(base::DeleteFile(trimmed_recording, false));
-
-  ASSERT_TRUE(peerconnection_server_.Stop());
 }