Rewrote WebRTC browser tests to not use peerconnection_server.

chrome/browser/media/chrome_webrtc_typing_detection_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/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/media/webrtc_browsertest_base.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
@@ skipping 32 matching lines @@
   return source_dir;
 }
 
 // Test that the typing detection feature works.
 // You must have the src-internal solution in your .gclient to put the required
 // pyauto_private directory into chrome/test/data/.
 class WebRtcTypingDetectionBrowserTest : public WebRtcTestBase {
  public:
   // TODO(phoglund): clean up duplication from audio quality browser test when
   // this test is complete and is proven to work.
-  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
-    test::PeerConnectionServerRunner::KillAllPeerConnectionServers();
-  }
-
   bool HasAllRequiredResources() {
     base::FilePath reference_file =
         GetTestDataDir().Append(kReferenceFile);
     if (!base::PathExists(reference_file)) {
       LOG(ERROR) << "Cannot find the reference file to be used for audio "
                  << "quality comparison: " << reference_file.value();
       return false;
     }
     return true;
   }
@@ skipping 18 matching lines @@
                      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));
   }
-
-  test::PeerConnectionServerRunner peerconnection_server_;
 };
 
 // TODO(phoglund): enable when fully implemented.
 IN_PROC_BROWSER_TEST_F(WebRtcTypingDetectionBrowserTest,
                        DISABLED_MANUAL_TestTypingDetection) {
   // TODO(phoglund): make this use embedded_test_server when that test server
   // can handle files > ~400Kb.
   ASSERT_TRUE(test_server()->Start());
-  ASSERT_TRUE(peerconnection_server_.Start());
 
   ui_test_utils::NavigateToURL(
       browser(), 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(), test_server()->GetURL(kMainWebrtcTestHtmlPage));
 
-  ConnectToPeerConnectionServer("peer 1", left_tab);
-  ConnectToPeerConnectionServer("peer 2", right_tab);
-
   GetUserMediaWithSpecificConstraintsAndAccept(left_tab,
                                                kAudioOnlyCallConstraints);
   EXPECT_EQ("ok-peerconnection-created",
             ExecuteJavascript("preparePeerConnection()", left_tab));
 
   AddAudioFile(kReferenceFileRelativeUrl, left_tab);
   MixLocalStreamWithPreviouslyLoadedAudioFile(left_tab);
 
-  EstablishCall(left_tab, right_tab);
+  SetupPeerconnectionWithLocalStream(left_tab);
+  SetupPeerconnectionWithLocalStream(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);
 
   PlayAudioFile(left_tab);
 
   // TODO(phoglund): simulate key presses, look for changes in typing detection
   // state.
   test::SleepInJavascript(left_tab, 10000);
 
   HangUp(left_tab);
-  WaitUntilHangupVerified(left_tab);
-  WaitUntilHangupVerified(right_tab);
-
-  ASSERT_TRUE(peerconnection_server_.Stop());
 }