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/stringprintf.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/infobars/infobar.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 "content/public/browser/notification_service.h"
  19 #include "content/public/test/browser_test_utils.h"
  20
  21 const char WebRtcTestBase::kAudioVideoCallConstraints[] =
  22     "'{audio: true, video: true}'";
  23 const char WebRtcTestBase::kAudioOnlyCallConstraints[] = "'{audio: true}'";
  24 const char WebRtcTestBase::kVideoOnlyCallConstraints[] = "'{video: true}'";
  25 const char WebRtcTestBase::kFailedWithPermissionDeniedError[] =
  26     "failed-with-error-PermissionDeniedError";
  27
  28 namespace {
  29
  30 base::LazyInstance<bool> hit_javascript_errors_ =
  31       LAZY_INSTANCE_INITIALIZER;
  32
  33 // Intercepts all log messages. We always attach this handler but only look at
  34 // the results if the test requests so. Note that this will only work if the
  35 // WebrtcTestBase-inheriting test cases do not run in parallel (if they did they
  36 // would race to look at the log, which is global to all tests).
  37 bool JavascriptErrorDetectingLogHandler(int severity,
  38                                         const char* file,
  39                                         int line,
  40                                         size_t message_start,
  41                                         const std::string& str) {
  42   if (file == NULL || std::string("CONSOLE") != file)
  43     return false;
  44
  45   bool contains_uncaught = str.find("\"Uncaught ") != std::string::npos;
  46   if (severity == logging::LOG_ERROR ||
  47       (severity == logging::LOG_INFO && contains_uncaught)) {
  48     hit_javascript_errors_.Get() = true;
  49   }
  50
  51   return false;
  52 }
  53
  54 }  // namespace
  55
  56 WebRtcTestBase::WebRtcTestBase(): detect_errors_in_javascript_(false) {
  57   // The handler gets set for each test method, but that's fine since this
  58   // set operation is idempotent.
  59   logging::SetLogMessageHandler(&JavascriptErrorDetectingLogHandler);
  60   hit_javascript_errors_.Get() = false;
  61 }
  62
  63 WebRtcTestBase::~WebRtcTestBase() {
  64   if (detect_errors_in_javascript_) {
  65     EXPECT_FALSE(hit_javascript_errors_.Get())
  66         << "Encountered javascript errors during test execution (Search "
  67         << "for Uncaught or ERROR:CONSOLE in the test output).";
  68   }
  69 }
  70
  71 void WebRtcTestBase::GetUserMediaAndAccept(
  72     content::WebContents* tab_contents) const {
  73   GetUserMediaWithSpecificConstraintsAndAccept(tab_contents,
  74                                                kAudioVideoCallConstraints);
  75 }
  76
  77 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
  78     content::WebContents* tab_contents,
  79     const std::string& constraints) const {
  80   InfoBar* infobar = GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
  81   infobar->delegate()->AsConfirmInfoBarDelegate()->Accept();
  82   CloseInfoBarInTab(tab_contents, infobar);
  83
  84   // Wait for WebRTC to call the success callback.
  85   const char kOkGotStream[] = "ok-got-stream";
  86   EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
  87                                tab_contents));
  88 }
  89
  90 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
  91   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
  92                                                     kAudioVideoCallConstraints);
  93 }
  94
  95 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
  96     content::WebContents* tab_contents,
  97     const std::string& constraints) const {
  98   InfoBar* infobar = GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
  99   infobar->delegate()->AsConfirmInfoBarDelegate()->Cancel();
 100   CloseInfoBarInTab(tab_contents, infobar);
 101
 102   // Wait for WebRTC to call the fail callback.
 103   EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()",
 104                                kFailedWithPermissionDeniedError, tab_contents));
 105 }
 106
 107 void WebRtcTestBase::GetUserMediaAndDismiss(
 108     content::WebContents* tab_contents) const {
 109   InfoBar* infobar =
 110       GetUserMediaAndWaitForInfoBar(tab_contents, kAudioVideoCallConstraints);
 111   infobar->delegate()->InfoBarDismissed();
 112   CloseInfoBarInTab(tab_contents, infobar);
 113
 114   // A dismiss should be treated like a deny.
 115   EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()",
 116                                kFailedWithPermissionDeniedError, tab_contents));
 117 }
 118
 119 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
 120                                   const std::string& constraints) const {
 121   // Request user media: this will launch the media stream info bar.
 122   std::string result;
 123   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
 124       tab_contents, "doGetUserMedia(" + constraints + ");", &result));
 125   EXPECT_EQ("ok-requested", result);
 126 }
 127
 128 InfoBar* WebRtcTestBase::GetUserMediaAndWaitForInfoBar(
 129     content::WebContents* tab_contents,
 130     const std::string& constraints) const {
 131   content::WindowedNotificationObserver infobar_added(
 132       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
 133       content::NotificationService::AllSources());
 134
 135   // Request user media: this will launch the media stream info bar.
 136   GetUserMedia(tab_contents, constraints);
 137
 138   // Wait for the bar to pop up, then return it.
 139   infobar_added.Wait();
 140   content::Details<InfoBar::AddedDetails> details(infobar_added.details());
 141   EXPECT_TRUE(details->delegate()->AsMediaStreamInfoBarDelegate());
 142   return details.ptr();
 143 }
 144
 145 content::WebContents* WebRtcTestBase::OpenPageAndGetUserMediaInNewTab(
 146       const GURL& url) const {
 147   chrome::AddTabAt(browser(), GURL(), -1, true);
 148   ui_test_utils::NavigateToURL(browser(), url);
 149 #if defined (OS_LINUX)
 150   // Load the page again on Linux to work around crbug.com/281268.
 151   ui_test_utils::NavigateToURL(browser(), url);
 152 #endif
 153   content::WebContents* new_tab =
 154       browser()->tab_strip_model()->GetActiveWebContents();
 155   GetUserMediaAndAccept(new_tab);
 156   return new_tab;
 157 }
 158
 159 content::WebContents* WebRtcTestBase::OpenPageAndAcceptUserMedia(
 160     const GURL& url) const {
 161   content::WindowedNotificationObserver infobar_added(
 162       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
 163       content::NotificationService::AllSources());
 164
 165   ui_test_utils::NavigateToURL(browser(), url);
 166
 167   infobar_added.Wait();
 168
 169   content::WebContents* tab_contents =
 170       browser()->tab_strip_model()->GetActiveWebContents();
 171   content::Details<InfoBar::AddedDetails> details(infobar_added.details());
 172   InfoBar* infobar = details.ptr();
 173   EXPECT_TRUE(infobar);
 174   infobar->delegate()->AsMediaStreamInfoBarDelegate()->Accept();
 175
 176   CloseInfoBarInTab(tab_contents, infobar);
 177   return tab_contents;
 178 }
 179
 180 void WebRtcTestBase::CloseInfoBarInTab(
 181     content::WebContents* tab_contents,
 182     InfoBar* infobar) const {
 183   content::WindowedNotificationObserver infobar_removed(
 184       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
 185       content::NotificationService::AllSources());
 186
 187   InfoBarService* infobar_service =
 188       InfoBarService::FromWebContents(tab_contents);
 189   infobar_service->RemoveInfoBar(infobar);
 190
 191   infobar_removed.Wait();
 192 }
 193
 194 // Convenience method which executes the provided javascript in the context
 195 // of the provided web contents and returns what it evaluated to.
 196 std::string WebRtcTestBase::ExecuteJavascript(
 197     const std::string& javascript,
 198     content::WebContents* tab_contents) const {
 199   std::string result;
 200   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
 201       tab_contents, javascript, &result));
 202   return result;
 203 }
 204
 205 // The peer connection server lets our two tabs find each other and talk to
 206 // each other (e.g. it is the application-specific "signaling solution").
 207 void WebRtcTestBase::ConnectToPeerConnectionServer(
 208     const std::string& peer_name,
 209     content::WebContents* tab_contents) const {
 210   std::string javascript = base::StringPrintf(
 211       "connect('http://localhost:%s', '%s');",
 212       PeerConnectionServerRunner::kDefaultPort, peer_name.c_str());
 213   EXPECT_EQ("ok-connected", ExecuteJavascript(javascript, tab_contents));
 214 }
 215
 216 void WebRtcTestBase::DetectErrorsInJavaScript() {
 217   detect_errors_in_javascript_ = true;
 218 }