chrome/browser/media/webrtc_browsertest_base.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/media/webrtc_browsertest_base.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/strings/string_util.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "chrome/browser/chrome_notification_types.h"
  11 #include "chrome/browser/infobars/infobar_service.h"
  12 #include "chrome/browser/media/media_stream_infobar_delegate.h"
  13 #include "chrome/browser/media/webrtc_browsertest_common.h"
  14 #include "chrome/browser/ui/browser.h"
  15 #include "chrome/browser/ui/browser_tabstrip.h"
  16 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  17 #include "chrome/test/base/ui_test_utils.h"
  18 #include "components/infobars/core/infobar.h"
  19 #include "content/public/browser/notification_service.h"
  20 #include "content/public/test/browser_test_utils.h"
  21 #include "net/test/embedded_test_server/embedded_test_server.h"
  22
  23 #if defined(OS_WIN)
  24 // For fine-grained suppression.
  25 #include "base/win/windows_version.h"
  26 #endif
  27
  28 const char WebRtcTestBase::kAudioVideoCallConstraints[] =
  29     "{audio: true, video: true}";
  30 const char WebRtcTestBase::kAudioVideoCallConstraintsQVGA[] =
  31    "{audio: true, video: {mandatory: {minWidth: 320, maxWidth: 320, "
  32    " minHeight: 240, maxHeight: 240}}}";
  33 const char WebRtcTestBase::kAudioVideoCallConstraints360p[] =
  34    "{audio: true, video: {mandatory: {minWidth: 640, maxWidth: 640, "
  35    " minHeight: 360, maxHeight: 360}}}";
  36 const char WebRtcTestBase::kAudioVideoCallConstraintsVGA[] =
  37    "{audio: true, video: {mandatory: {minWidth: 640, maxWidth: 640, "
  38    " minHeight: 480, maxHeight: 480}}}";
  39 const char WebRtcTestBase::kAudioVideoCallConstraints720p[] =
  40    "{audio: true, video: {mandatory: {minWidth: 1280, maxWidth: 1280, "
  41    " minHeight: 720, maxHeight: 720}}}";
  42 const char WebRtcTestBase::kAudioVideoCallConstraints1080p[] =
  43     "{audio: true, video: {mandatory: {minWidth: 1920, maxWidth: 1920, "
  44     " minHeight: 1080, maxHeight: 1080}}}";
  45 const char WebRtcTestBase::kAudioOnlyCallConstraints[] = "{audio: true}";
  46 const char WebRtcTestBase::kVideoOnlyCallConstraints[] = "{video: true}";
  47 const char WebRtcTestBase::kFailedWithPermissionDeniedError[] =
  48     "failed-with-error-PermissionDeniedError";
  49 const char WebRtcTestBase::kFailedWithPermissionDismissedError[] =
  50     "failed-with-error-PermissionDismissedError";
  51
  52 namespace {
  53
  54 base::LazyInstance<bool> hit_javascript_errors_ =
  55       LAZY_INSTANCE_INITIALIZER;
  56
  57 // Intercepts all log messages. We always attach this handler but only look at
  58 // the results if the test requests so. Note that this will only work if the
  59 // WebrtcTestBase-inheriting test cases do not run in parallel (if they did they
  60 // would race to look at the log, which is global to all tests).
  61 bool JavascriptErrorDetectingLogHandler(int severity,
  62                                         const char* file,
  63                                         int line,
  64                                         size_t message_start,
  65                                         const std::string& str) {
  66   if (file == NULL || std::string("CONSOLE") != file)
  67     return false;
  68
  69   bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos;
  70   if (severity == logging::LOG_ERROR ||
  71       (severity == logging::LOG_INFO && contains_uncaught)) {
  72     hit_javascript_errors_.Get() = true;
  73   }
  74
  75   return false;
  76 }
  77
  78 }  // namespace
  79
  80 WebRtcTestBase::WebRtcTestBase(): detect_errors_in_javascript_(false) {
  81   // The handler gets set for each test method, but that's fine since this
  82   // set operation is idempotent.
  83   logging::SetLogMessageHandler(&JavascriptErrorDetectingLogHandler);
  84   hit_javascript_errors_.Get() = false;
  85
  86   EnablePixelOutput();
  87 }
  88
  89 WebRtcTestBase::~WebRtcTestBase() {
  90   if (detect_errors_in_javascript_) {
  91     EXPECT_FALSE(hit_javascript_errors_.Get())
  92         << "Encountered javascript errors during test execution (Search "
  93         << "for Uncaught or ERROR:CONSOLE in the test output).";
  94   }
  95 }
  96
  97 void WebRtcTestBase::GetUserMediaAndAccept(
  98     content::WebContents* tab_contents) const {
  99   GetUserMediaWithSpecificConstraintsAndAccept(tab_contents,
 100                                                kAudioVideoCallConstraints);
 101 }
 102
 103 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
 104     content::WebContents* tab_contents,
 105     const std::string& constraints) const {
 106   infobars::InfoBar* infobar =
 107       GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
 108   infobar->delegate()->AsConfirmInfoBarDelegate()->Accept();
 109   CloseInfoBarInTab(tab_contents, infobar);
 110
 111   // Wait for WebRTC to call the success callback.
 112   const char kOkGotStream[] = "ok-got-stream";
 113   EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
 114                                      tab_contents));
 115 }
 116
 117 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
 118   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
 119                                                     kAudioVideoCallConstraints);
 120 }
 121
 122 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
 123     content::WebContents* tab_contents,
 124     const std::string& constraints) const {
 125   infobars::InfoBar* infobar =
 126       GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
 127   infobar->delegate()->AsConfirmInfoBarDelegate()->Cancel();
 128   CloseInfoBarInTab(tab_contents, infobar);
 129
 130   // Wait for WebRTC to call the fail callback.
 131   EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
 132                                      kFailedWithPermissionDeniedError,
 133                                      tab_contents));
 134 }
 135
 136 void WebRtcTestBase::GetUserMediaAndDismiss(
 137     content::WebContents* tab_contents) const {
 138   infobars::InfoBar* infobar =
 139       GetUserMediaAndWaitForInfoBar(tab_contents, kAudioVideoCallConstraints);
 140   infobar->delegate()->InfoBarDismissed();
 141   CloseInfoBarInTab(tab_contents, infobar);
 142
 143   // A dismiss should be treated like a deny.
 144   EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
 145                                      kFailedWithPermissionDismissedError,
 146                                      tab_contents));
 147 }
 148
 149 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
 150                                   const std::string& constraints) const {
 151   // Request user media: this will launch the media stream info bar.
 152   std::string result;
 153   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
 154       tab_contents, "doGetUserMedia(" + constraints + ");", &result));
 155   EXPECT_EQ("ok-requested", result);
 156 }
 157
 158 infobars::InfoBar* WebRtcTestBase::GetUserMediaAndWaitForInfoBar(
 159     content::WebContents* tab_contents,
 160     const std::string& constraints) const {
 161   content::WindowedNotificationObserver infobar_added(
 162       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
 163       content::NotificationService::AllSources());
 164
 165   // Request user media: this will launch the media stream info bar.
 166   GetUserMedia(tab_contents, constraints);
 167
 168   // Wait for the bar to pop up, then return it.
 169   infobar_added.Wait();
 170   content::Details<infobars::InfoBar::AddedDetails> details(
 171       infobar_added.details());
 172   EXPECT_TRUE(details->delegate()->AsMediaStreamInfoBarDelegate());
 173   return details.ptr();
 174 }
 175
 176 content::WebContents* WebRtcTestBase::OpenPageAndGetUserMediaInNewTab(
 177     const GURL& url) const {
 178   return OpenPageAndGetUserMediaInNewTabWithConstraints(
 179       url, kAudioVideoCallConstraints);
 180 }
 181
 182 content::WebContents*
 183 WebRtcTestBase::OpenPageAndGetUserMediaInNewTabWithConstraints(
 184     const GURL& url,
 185     const std::string& constraints) const {
 186   chrome::AddTabAt(browser(), GURL(), -1, true);
 187   ui_test_utils::NavigateToURL(browser(), url);
 188   content::WebContents* new_tab =
 189       browser()->tab_strip_model()->GetActiveWebContents();
 190   GetUserMediaWithSpecificConstraintsAndAccept(new_tab, constraints);
 191   return new_tab;
 192 }
 193
 194 content::WebContents* WebRtcTestBase::OpenTestPageAndGetUserMediaInNewTab(
 195     const std::string& test_page) const {
 196   return OpenPageAndGetUserMediaInNewTab(
 197       embedded_test_server()->GetURL(test_page));
 198 }
 199
 200 content::WebContents* WebRtcTestBase::OpenPageAndAcceptUserMedia(
 201     const GURL& url) const {
 202   content::WindowedNotificationObserver infobar_added(
 203       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
 204       content::NotificationService::AllSources());
 205
 206   ui_test_utils::NavigateToURL(browser(), url);
 207
 208   infobar_added.Wait();
 209
 210   content::WebContents* tab_contents =
 211       browser()->tab_strip_model()->GetActiveWebContents();
 212   content::Details<infobars::InfoBar::AddedDetails> details(
 213       infobar_added.details());
 214   infobars::InfoBar* infobar = details.ptr();
 215   EXPECT_TRUE(infobar);
 216   infobar->delegate()->AsMediaStreamInfoBarDelegate()->Accept();
 217
 218   CloseInfoBarInTab(tab_contents, infobar);
 219   return tab_contents;
 220 }
 221
 222 void WebRtcTestBase::CloseInfoBarInTab(content::WebContents* tab_contents,
 223                                        infobars::InfoBar* infobar) const {
 224   content::WindowedNotificationObserver infobar_removed(
 225       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
 226       content::NotificationService::AllSources());
 227
 228   InfoBarService* infobar_service =
 229       InfoBarService::FromWebContents(tab_contents);
 230   infobar_service->RemoveInfoBar(infobar);
 231
 232   infobar_removed.Wait();
 233 }
 234
 235 void WebRtcTestBase::CloseLastLocalStream(
 236     content::WebContents* tab_contents) const {
 237   EXPECT_EQ("ok-stopped",
 238             ExecuteJavascript("stopLocalStream();", tab_contents));
 239 }
 240
 241 // Convenience method which executes the provided javascript in the context
 242 // of the provided web contents and returns what it evaluated to.
 243 std::string WebRtcTestBase::ExecuteJavascript(
 244     const std::string& javascript,
 245     content::WebContents* tab_contents) const {
 246   std::string result;
 247   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
 248       tab_contents, javascript, &result));
 249   return result;
 250 }
 251
 252 void WebRtcTestBase::SetupPeerconnectionWithLocalStream(
 253     content::WebContents* tab) const {
 254   SetupPeerconnectionWithoutLocalStream(tab);
 255   EXPECT_EQ("ok-added", ExecuteJavascript("addLocalStream()", tab));
 256 }
 257
 258 void WebRtcTestBase::SetupPeerconnectionWithoutLocalStream(
 259     content::WebContents* tab) const {
 260   EXPECT_EQ("ok-peerconnection-created",
 261             ExecuteJavascript("preparePeerConnection()", tab));
 262 }
 263
 264 std::string WebRtcTestBase::CreateLocalOffer(
 265       content::WebContents* from_tab) const {
 266   std::string response = ExecuteJavascript("createLocalOffer({})", from_tab);
 267   EXPECT_EQ("ok-", response.substr(0, 3)) << "Failed to create local offer: "
 268       << response;
 269
 270   std::string local_offer = response.substr(3);
 271   return local_offer;
 272 }
 273
 274 std::string WebRtcTestBase::CreateAnswer(std::string local_offer,
 275                                          content::WebContents* to_tab) const {
 276   std::string javascript =
 277       base::StringPrintf("receiveOfferFromPeer('%s', {})", local_offer.c_str());
 278   std::string response = ExecuteJavascript(javascript, to_tab);
 279   EXPECT_EQ("ok-", response.substr(0, 3))
 280       << "Receiving peer failed to receive offer and create answer: "
 281       << response;
 282
 283   std::string answer = response.substr(3);
 284   return answer;
 285 }
 286
 287 void WebRtcTestBase::ReceiveAnswer(std::string answer,
 288                                    content::WebContents* from_tab) const {
 289   ASSERT_EQ(
 290       "ok-accepted-answer",
 291       ExecuteJavascript(
 292           base::StringPrintf("receiveAnswerFromPeer('%s')", answer.c_str()),
 293           from_tab));
 294 }
 295
 296 void WebRtcTestBase::GatherAndSendIceCandidates(
 297     content::WebContents* from_tab,
 298     content::WebContents* to_tab) const {
 299   std::string ice_candidates =
 300       ExecuteJavascript("getAllIceCandidates()", from_tab);
 301
 302   EXPECT_EQ("ok-received-candidates", ExecuteJavascript(
 303       base::StringPrintf("receiveIceCandidates('%s')", ice_candidates.c_str()),
 304       to_tab));
 305 }
 306
 307 void WebRtcTestBase::NegotiateCall(content::WebContents* from_tab,
 308                                    content::WebContents* to_tab) const {
 309   std::string local_offer = CreateLocalOffer(from_tab);
 310   std::string answer = CreateAnswer(local_offer, to_tab);
 311   ReceiveAnswer(answer, from_tab);
 312
 313   // Send all ICE candidates (wait for gathering to finish if necessary).
 314   GatherAndSendIceCandidates(to_tab, from_tab);
 315   GatherAndSendIceCandidates(from_tab, to_tab);
 316 }
 317
 318 void WebRtcTestBase::HangUp(content::WebContents* from_tab) const {
 319   EXPECT_EQ("ok-call-hung-up", ExecuteJavascript("hangUp()", from_tab));
 320 }
 321
 322 void WebRtcTestBase::DetectErrorsInJavaScript() {
 323   detect_errors_in_javascript_ = true;
 324 }
 325
 326 void WebRtcTestBase::StartDetectingVideo(
 327     content::WebContents* tab_contents,
 328     const std::string& video_element) const {
 329   std::string javascript = base::StringPrintf(
 330       "startDetection('%s', 320, 240)", video_element.c_str());
 331   EXPECT_EQ("ok-started", ExecuteJavascript(javascript, tab_contents));
 332 }
 333
 334 void WebRtcTestBase::WaitForVideoToPlay(
 335     content::WebContents* tab_contents) const {
 336   EXPECT_TRUE(test::PollingWaitUntil("isVideoPlaying()", "video-playing",
 337                                      tab_contents));
 338 }
 339
 340 std::string WebRtcTestBase::GetStreamSize(
 341     content::WebContents* tab_contents,
 342     const std::string& video_element) const {
 343   std::string javascript =
 344       base::StringPrintf("getStreamSize('%s')", video_element.c_str());
 345   std::string result = ExecuteJavascript(javascript, tab_contents);
 346   EXPECT_TRUE(StartsWithASCII(result, "ok-", true));
 347   return result.substr(3);
 348 }
 349
 350 bool WebRtcTestBase::HasWebcamAvailableOnSystem(
 351     content::WebContents* tab_contents) const {
 352   std::string result =
 353       ExecuteJavascript("hasVideoInputDeviceOnSystem();", tab_contents);
 354   return result == "has-video-input-device";
 355 }
 356
 357 bool WebRtcTestBase::OnWinXp() const {
 358 #if defined(OS_WIN)
 359   return base::win::GetVersion() <= base::win::VERSION_XP;
 360 #else
 361   return false;
 362 #endif
 363 }
 364
 365 bool WebRtcTestBase::OnWin8() const {
 366 #if defined(OS_WIN)
 367   return base::win::GetVersion() > base::win::VERSION_WIN7;
 368 #else
 369   return false;
 370 #endif
 371 }