Relanding Switched main WebRTC browser tests to use a more realistic video

chrome/browser/media/webrtc_browsertest_base.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 "chrome/browser/media/webrtc_browsertest_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/infobars/infobar.h"
@@ skipping 73 matching lines @@
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
   InfoBar* infobar = GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
   infobar->delegate()->AsConfirmInfoBarDelegate()->Accept();
   CloseInfoBarInTab(tab_contents, infobar);
 
   // Wait for WebRTC to call the success callback.
   const char kOkGotStream[] = "ok-got-stream";
-  EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
-                               tab_contents));
+  EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
+                                     tab_contents));
 }
 
 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
                                                     kAudioVideoCallConstraints);
 }
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
   InfoBar* infobar = GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
   infobar->delegate()->AsConfirmInfoBarDelegate()->Cancel();
   CloseInfoBarInTab(tab_contents, infobar);
 
   // Wait for WebRTC to call the fail callback.
-  EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()",
-                               kFailedWithPermissionDeniedError, tab_contents));
+  EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                     kFailedWithPermissionDeniedError,
+                                     tab_contents));
 }
 
 void WebRtcTestBase::GetUserMediaAndDismiss(
     content::WebContents* tab_contents) const {
   InfoBar* infobar =
       GetUserMediaAndWaitForInfoBar(tab_contents, kAudioVideoCallConstraints);
   infobar->delegate()->InfoBarDismissed();
   CloseInfoBarInTab(tab_contents, infobar);
 
   // A dismiss should be treated like a deny.
-  EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()",
-                               kFailedWithPermissionDismissedError,
-                               tab_contents));
+  EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                     kFailedWithPermissionDismissedError,
+                                     tab_contents));
 }
 
 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
                                   const std::string& constraints) const {
   // Request user media: this will launch the media stream info bar.
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents, "doGetUserMedia(" + constraints + ");", &result));
   EXPECT_EQ("ok-requested", result);
 }
@@ skipping 89 matching lines @@
   return result;
 }
 
 // The peer connection server lets our two tabs find each other and talk to
 // each other (e.g. it is the application-specific "signaling solution").
 void WebRtcTestBase::ConnectToPeerConnectionServer(
     const std::string& peer_name,
     content::WebContents* tab_contents) const {
   std::string javascript = base::StringPrintf(
       "connect('http://localhost:%s', '%s');",
-      PeerConnectionServerRunner::kDefaultPort, peer_name.c_str());
+      test::PeerConnectionServerRunner::kDefaultPort, peer_name.c_str());
   EXPECT_EQ("ok-connected", ExecuteJavascript(javascript, tab_contents));
 }
 
 void WebRtcTestBase::EstablishCall(content::WebContents* from_tab,
                                    content::WebContents* to_tab) const {
   ConnectToPeerConnectionServer("peer 1", from_tab);
   ConnectToPeerConnectionServer("peer 2", to_tab);
 
   EXPECT_EQ("ok-peerconnection-created",
             ExecuteJavascript("preparePeerConnection()", from_tab));
   EXPECT_EQ("ok-added", ExecuteJavascript("addLocalStream()", from_tab));
   EXPECT_EQ("ok-negotiating", ExecuteJavascript("negotiateCall()", from_tab));
 
   // Ensure the call gets up on both sides.
-  EXPECT_TRUE(PollingWaitUntil("getPeerConnectionReadyState()",
-                               "active", from_tab));
-  EXPECT_TRUE(PollingWaitUntil("getPeerConnectionReadyState()",
-                               "active", to_tab));
+  EXPECT_TRUE(test::PollingWaitUntil("getPeerConnectionReadyState()",
+                                     "active", from_tab));
+  EXPECT_TRUE(test::PollingWaitUntil("getPeerConnectionReadyState()",
+                                     "active", to_tab));
 }
 
 void WebRtcTestBase::HangUp(content::WebContents* from_tab) const {
   EXPECT_EQ("ok-call-hung-up", ExecuteJavascript("hangUp()", from_tab));
 }
 
 void WebRtcTestBase::WaitUntilHangupVerified(
     content::WebContents* tab_contents) const {
-  EXPECT_TRUE(PollingWaitUntil("getPeerConnectionReadyState()",
-                               "no-peer-connection", tab_contents));
+  EXPECT_TRUE(test::PollingWaitUntil("getPeerConnectionReadyState()",
+                                     "no-peer-connection", tab_contents));
 }
 
 void WebRtcTestBase::DetectErrorsInJavaScript() {
   detect_errors_in_javascript_ = true;
 }
 
 void WebRtcTestBase::StartDetectingVideo(
     content::WebContents* tab_contents,
     const std::string& video_element) const {
   std::string javascript = base::StringPrintf(
       "startDetection('%s', 320, 240)", video_element.c_str());
   EXPECT_EQ("ok-started", ExecuteJavascript(javascript, tab_contents));
 }
 
 void WebRtcTestBase::WaitForVideoToPlay(
     content::WebContents* tab_contents) const {
-  EXPECT_TRUE(PollingWaitUntil("isVideoPlaying()", "video-playing",
-                               tab_contents));
+  EXPECT_TRUE(test::PollingWaitUntil("isVideoPlaying()", "video-playing",
+                                     tab_contents));
 }