Rewrote WebRTC browser tests to not use peerconnection_server.

chrome/browser/media/chrome_webrtc_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 "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
@@ skipping 30 matching lines @@
 
 // Top-level integration test for WebRTC. The test methods here must run
 // sequentially since they use a server binary on the system (hence they are
 // tagged as MANUAL). In addition, they need the reference videos which require
 // the webrtc.DEPS solution, which is not generally available on Chromium bots.
 class WebRtcBrowserTest : public WebRtcTestBase,
                           public testing::WithParamInterface<bool> {
  public:
   WebRtcBrowserTest() {}
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    test::PeerConnectionServerRunner::KillAllPeerConnectionServers();
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
 
   virtual void SetUpCommandLine(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)
@@ skipping 60 matching lines @@
     return NULL;
   }
 
   bool OnWinXp() {
 #if defined(OS_WIN)
     return base::win::GetVersion() <= base::win::VERSION_XP;
 #else
     return false;
 #endif
   }
-
-  test::PeerConnectionServerRunner peerconnection_server_;
 };
 
 static const bool kRunTestsWithFlag[] = { false, true };
 INSTANTIATE_TEST_CASE_P(WebRtcBrowserTests,
                         WebRtcBrowserTest,
                         testing::ValuesIn(kRunTestsWithFlag));
 
 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
                        MANUAL_RunsAudioVideoWebRTCCallInTwoTabs) {
   if (OnWinXp()) return;
 
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
-  ASSERT_TRUE(peerconnection_server_.Start());
 
   content::WebContents* left_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
   content::WebContents* right_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
-  EstablishCall(left_tab, right_tab);
+  SetupPeerconnectionWithLocalStream(left_tab);
+  SetupPeerconnectionWithLocalStream(right_tab);
+
+  NegotiateCall(left_tab, right_tab);
 
   StartDetectingVideo(left_tab, "remote-view");
   StartDetectingVideo(right_tab, "remote-view");
 
   WaitForVideoToPlay(left_tab);
   WaitForVideoToPlay(right_tab);
 
   HangUp(left_tab);
-  WaitUntilHangupVerified(left_tab);
-  WaitUntilHangupVerified(right_tab);
-
-  ASSERT_TRUE(peerconnection_server_.Stop());
 }
 
 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MANUAL_CpuUsage15Seconds) {
   if (OnWinXp()) return;
 
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
-  ASSERT_TRUE(peerconnection_server_.Start());
 
   base::FilePath results_file;
   ASSERT_TRUE(base::CreateTemporaryFile(&results_file));
 
   content::WebContents* left_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
 #if defined(OS_MACOSX)
   // Don't measure renderer CPU on mac: requires a mach broker we don't have
   // access to from the browser test.
@@ skipping 11 matching lines @@
 
   scoped_ptr<base::ProcessMetrics> browser_process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(
           base::Process::Current().handle()));
   browser_process_metrics->GetCPUUsage();
 #endif
 
   content::WebContents* right_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
-  EstablishCall(left_tab, right_tab);
+  SetupPeerconnectionWithLocalStream(left_tab);
+  SetupPeerconnectionWithLocalStream(right_tab);
+
+  NegotiateCall(left_tab, right_tab);
 
   test::SleepInJavascript(left_tab, 15000);
 
   HangUp(left_tab);
-  WaitUntilHangupVerified(left_tab);
-  WaitUntilHangupVerified(right_tab);
 
 #if !defined(OS_MACOSX)
   PrintProcessMetrics(renderer_process_metrics.get(), "_r");
 #endif
   PrintProcessMetrics(browser_process_metrics.get(), "_b");
-
-  ASSERT_TRUE(peerconnection_server_.Stop());
 }
 
 // This is manual for its long execution time.
 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest,
                        MANUAL_RunsAudioVideoCall60SecsAndLogsInternalMetrics) {
   if (OnWinXp()) return;
 
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
-  ASSERT_TRUE(peerconnection_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);
 
-  EstablishCall(left_tab, right_tab);
+  SetupPeerconnectionWithLocalStream(left_tab);
+  SetupPeerconnectionWithLocalStream(right_tab);
+
+  NegotiateCall(left_tab, right_tab);
 
   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.
   chrome::AddTabAt(browser(), GURL(), -1, true);
   ui_test_utils::NavigateToURL(browser(), GURL("chrome://webrtc-internals"));
   content::WebContents* webrtc_internals_tab =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   test::SleepInJavascript(left_tab, 10000);
 
   scoped_ptr<base::DictionaryValue> all_data(
       GetWebrtcInternalsData(webrtc_internals_tab));
   ASSERT_TRUE(all_data.get() != NULL);
 
   const base::DictionaryValue* first_pc_dict =
       GetDataOnFirstPeerConnection(all_data.get());
   ASSERT_TRUE(first_pc_dict != NULL);
   test::PrintBweForVideoMetrics(*first_pc_dict);
   test::PrintMetricsForAllStreams(*first_pc_dict);
 
   HangUp(left_tab);
-  WaitUntilHangupVerified(left_tab);
-  WaitUntilHangupVerified(right_tab);
-
-  ASSERT_TRUE(peerconnection_server_.Stop());
 }
 
 IN_PROC_BROWSER_TEST_P(WebRtcBrowserTest, MANUAL_TestWebAudioMediaStream) {
   if (OnWinXp()) return;
 
   ASSERT_TRUE(test::HasReferenceFilesInCheckout());
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   GURL url(embedded_test_server()->GetURL("/webrtc/webaudio_crash.html"));
   ui_test_utils::NavigateToURL(browser(), url);
   content::WebContents* tab =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   // A sleep is necessary to be able to detect the crash.
   test::SleepInJavascript(tab, 1000);
 
   ASSERT_FALSE(tab->IsCrashed());
 }