Revert of Convert the WebRtcTestBase to use infobar and bubble autoresponders

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/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "chrome/browser/infobars/infobar_responder.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/browser/media/media_stream_infobar_delegate.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/website_settings/mock_permission_bubble_view.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/infobars/core/infobar.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
 #if defined(OS_WIN)
 // For fine-grained suppression.
 #include "base/win/windows_version.h"
 #endif
 
 const char WebRtcTestBase::kAudioVideoCallConstraints[] =
     "{audio: true, video: true}";
@@ skipping 73 matching lines @@
 
 bool WebRtcTestBase::GetUserMediaAndAccept(
     content::WebContents* tab_contents) const {
   return GetUserMediaWithSpecificConstraintsAndAccept(
       tab_contents, kAudioVideoCallConstraints);
 }
 
 bool WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
-  std::string result;
   if (PermissionBubbleManager::Enabled()) {
+    scoped_ptr<MockPermissionBubbleView> mock_bubble_view(
+        new MockPermissionBubbleView());
     PermissionBubbleManager::FromWebContents(tab_contents)
-        ->set_auto_response_for_test(PermissionBubbleManager::ACCEPT_ALL);
+        ->SetView(mock_bubble_view.get());
+    mock_bubble_view->SetBrowserTest(true);
     GetUserMedia(tab_contents, constraints);
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    if (!mock_bubble_view->IsVisible())
+      content::RunMessageLoop();
+    mock_bubble_view->Accept();
+    // Wait for WebRTC to call the success callback, then remove the view.
+    const bool result = test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                               kOkGotStream, tab_contents);
+    PermissionBubbleManager::FromWebContents(tab_contents)->SetView(NULL);
+    return result;
   } else {
-    InfoBarResponder infobar_accept_responder(
-        InfoBarService::FromWebContents(tab_contents),
-        InfoBarResponder::ACCEPT);
-    GetUserMedia(tab_contents, constraints);
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    infobars::InfoBar* infobar =
+        GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
+    infobar->delegate()->AsConfirmInfoBarDelegate()->Accept();
+    CloseInfoBarInTab(tab_contents, infobar);
+    // Wait for WebRTC to call the success callback.
+    return test::PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
+                                  tab_contents);
   }
-  return kOkGotStream == result;
 }
 
 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
                                                     kAudioVideoCallConstraints);
 }
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
-  std::string result;
   if (PermissionBubbleManager::Enabled()) {
+    scoped_ptr<MockPermissionBubbleView> mock_bubble_view(
+        new MockPermissionBubbleView());
     PermissionBubbleManager::FromWebContents(tab_contents)
-        ->set_auto_response_for_test(PermissionBubbleManager::DENY_ALL);
+        ->SetView(mock_bubble_view.get());
+    mock_bubble_view->SetBrowserTest(true);
     GetUserMedia(tab_contents, constraints);
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    if (!mock_bubble_view->IsVisible())
+      content::RunMessageLoop();
+    mock_bubble_view->Deny();
+    // Wait for WebRTC to call the fail callback, then remove the view.
+    EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                       kFailedWithPermissionDeniedError,
+                                       tab_contents));
+    PermissionBubbleManager::FromWebContents(tab_contents)->SetView(NULL);
   } else {
-    InfoBarResponder infobar_deny_responder(
-        InfoBarService::FromWebContents(tab_contents), InfoBarResponder::DENY);
-    GetUserMedia(tab_contents, constraints);
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    infobars::InfoBar* infobar =
+        GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
+    infobar->delegate()->AsConfirmInfoBarDelegate()->Cancel();
+    CloseInfoBarInTab(tab_contents, infobar);
+    // Wait for WebRTC to call the fail callback.
+    EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                       kFailedWithPermissionDeniedError,
+                                       tab_contents));
   }
-  EXPECT_EQ(kFailedWithPermissionDeniedError, result);
 }
 
 void WebRtcTestBase::GetUserMediaAndDismiss(
     content::WebContents* tab_contents) const {
-  std::string result;
   if (PermissionBubbleManager::Enabled()) {
+    scoped_ptr<MockPermissionBubbleView> mock_bubble_view(
+        new MockPermissionBubbleView());
     PermissionBubbleManager::FromWebContents(tab_contents)
-        ->set_auto_response_for_test(PermissionBubbleManager::DISMISS);
+        ->SetView(mock_bubble_view.get());
+    mock_bubble_view->SetBrowserTest(true);
     GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+    if (!mock_bubble_view->IsVisible())
+      content::RunMessageLoop();
+    mock_bubble_view->Close();
     // A dismiss should be treated like a deny.
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                       kFailedWithPermissionDismissedError,
+                                       tab_contents));
+    PermissionBubbleManager::FromWebContents(tab_contents)->SetView(NULL);
   } else {
-    InfoBarResponder infobar_dismiss_responder(
-        InfoBarService::FromWebContents(tab_contents),
-        InfoBarResponder::DISMISS);
-    GetUserMedia(tab_contents, kAudioVideoCallConstraints);
+    infobars::InfoBar* infobar =
+        GetUserMediaAndWaitForInfoBar(tab_contents, kAudioVideoCallConstraints);
+    infobar->delegate()->InfoBarDismissed();
+    CloseInfoBarInTab(tab_contents, infobar);
     // A dismiss should be treated like a deny.
-    EXPECT_TRUE(content::ExecuteScriptAndExtractString(
-        tab_contents->GetMainFrame(), "obtainGetUserMediaResult();", &result));
+    EXPECT_TRUE(test::PollingWaitUntil("obtainGetUserMediaResult()",
+                                       kFailedWithPermissionDismissedError,
+                                       tab_contents));
   }
-  EXPECT_EQ(kFailedWithPermissionDismissedError, result);
 }
 
 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
                                   const std::string& constraints) const {
-  // Request user media: this will launch the media stream info bar or bubble.
+  // Request user media: this will launch the media stream info bar.
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents, "doGetUserMedia(" + constraints + ");", &result));
-  EXPECT_TRUE(result == "request-callback-denied" ||
-              result == "request-callback-granted");
+  EXPECT_EQ("ok-requested", result);
+}
+
+infobars::InfoBar* WebRtcTestBase::GetUserMediaAndWaitForInfoBar(
+    content::WebContents* tab_contents,
+    const std::string& constraints) const {
+  content::WindowedNotificationObserver infobar_added(
+      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
+      content::NotificationService::AllSources());
+
+  // Request user media: this will launch the media stream info bar.
+  GetUserMedia(tab_contents, constraints);
+
+  // Wait for the bar to pop up, then return it.
+  infobar_added.Wait();
+  content::Details<infobars::InfoBar::AddedDetails> details(
+      infobar_added.details());
+  EXPECT_TRUE(details->delegate()->AsMediaStreamInfoBarDelegate());
+  return details.ptr();
 }
 
 content::WebContents* WebRtcTestBase::OpenPageAndGetUserMediaInNewTab(
     const GURL& url) const {
   return OpenPageAndGetUserMediaInNewTabWithConstraints(
       url, kAudioVideoCallConstraints);
 }
 
 content::WebContents*
 WebRtcTestBase::OpenPageAndGetUserMediaInNewTabWithConstraints(
@@ skipping 11 matching lines @@
 content::WebContents* WebRtcTestBase::OpenTestPageAndGetUserMediaInNewTab(
     const std::string& test_page) const {
   return OpenPageAndGetUserMediaInNewTab(
       embedded_test_server()->GetURL(test_page));
 }
 
 content::WebContents* WebRtcTestBase::OpenPageAndAcceptUserMedia(
     const GURL& url) const {
   content::WebContents* tab_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  ui_test_utils::NavigateToURL(browser(), url);
-  GetUserMediaAndAccept(tab_contents);
+  if (PermissionBubbleManager::Enabled()) {
+    scoped_ptr<MockPermissionBubbleView> mock_bubble_view(
+        new MockPermissionBubbleView());
+    PermissionBubbleManager::FromWebContents(tab_contents)
+        ->SetView(mock_bubble_view.get());
+    mock_bubble_view->SetBrowserTest(true);
+    ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(browser(), url,
+                                                              1);
+    if (!mock_bubble_view->IsVisible())
+      content::RunMessageLoop();
+    mock_bubble_view->Accept();
+    // Wait to make sure the callback is fired before deleting the bubble view.
+    test::PollingWaitUntil("obtainGetUserMediaResult()", kOkGotStream,
+                           tab_contents);
+    PermissionBubbleManager::FromWebContents(tab_contents)->SetView(NULL);
+  } else {
+    content::WindowedNotificationObserver nav(
+        chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
+        content::NotificationService::AllSources());
+    ui_test_utils::NavigateToURL(browser(), url);
+    nav.Wait();
+
+    content::Details<infobars::InfoBar::AddedDetails> details(nav.details());
+    infobars::InfoBar* infobar = details.ptr();
+    EXPECT_TRUE(infobar);
+    infobar->delegate()->AsMediaStreamInfoBarDelegate()->Accept();
+
+    CloseInfoBarInTab(tab_contents, infobar);
+  }
   return tab_contents;
 }
 
+void WebRtcTestBase::CloseInfoBarInTab(content::WebContents* tab_contents,
+                                       infobars::InfoBar* infobar) const {
+  content::WindowedNotificationObserver infobar_removed(
+      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+      content::NotificationService::AllSources());
+
+  InfoBarService* infobar_service =
+      InfoBarService::FromWebContents(tab_contents);
+  infobar_service->RemoveInfoBar(infobar);
+
+  infobar_removed.Wait();
+}
+
 void WebRtcTestBase::CloseLastLocalStream(
     content::WebContents* tab_contents) const {
   EXPECT_EQ("ok-stopped",
             ExecuteJavascript("stopLocalStream();", tab_contents));
 }
 
 // Convenience method which executes the provided javascript in the context
 // of the provided web contents and returns what it evaluated to.
 std::string WebRtcTestBase::ExecuteJavascript(
     const std::string& javascript,
@@ skipping 119 matching lines @@
 #endif
 }
 
 bool WebRtcTestBase::OnWin8() const {
 #if defined(OS_WIN)
   return base::win::GetVersion() > base::win::VERSION_WIN7;
 #else
   return false;
 #endif
 }