Infobar system refactor.

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/strings/stringprintf.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_service.h"
@@ skipping 20 matching lines @@
 
 void WebRtcTestBase::GetUserMediaAndAccept(
     content::WebContents* tab_contents) const {
   GetUserMediaWithSpecificConstraintsAndAccept(tab_contents,
                                                kAudioVideoCallConstraints);
 }
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndAccept(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
-  MediaStreamInfoBarDelegate* infobar =
-      GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
-  infobar->Accept();
+  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));
 }
 
 void WebRtcTestBase::GetUserMediaAndDeny(content::WebContents* tab_contents) {
   return GetUserMediaWithSpecificConstraintsAndDeny(tab_contents,
                                                     kAudioVideoCallConstraints);
 }
 
 void WebRtcTestBase::GetUserMediaWithSpecificConstraintsAndDeny(
     content::WebContents* tab_contents,
     const std::string& constraints) const {
-  MediaStreamInfoBarDelegate* infobar =
-      GetUserMediaAndWaitForInfoBar(tab_contents, constraints);
-  infobar->Cancel();
+  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));
 }
 
 void WebRtcTestBase::GetUserMediaAndDismiss(
     content::WebContents* tab_contents) const {
-  MediaStreamInfoBarDelegate* infobar =
+  InfoBar* infobar =
       GetUserMediaAndWaitForInfoBar(tab_contents, kAudioVideoCallConstraints);
-  infobar->InfoBarDismissed();
+  infobar->delegate()->InfoBarDismissed();
   CloseInfoBarInTab(tab_contents, infobar);
 
   // A dismiss should be treated like a deny.
   EXPECT_TRUE(PollingWaitUntil("obtainGetUserMediaResult()",
                                kFailedWithPermissionDeniedError, tab_contents));
 }
 
 void WebRtcTestBase::GetUserMedia(content::WebContents* tab_contents,
                                   const std::string& constraints) const {
   // TODO(phoglund): temporary debugging measure for crbug.com/281268.
   std::string javascript =
       "if (typeof(doGetUserMedia) != typeof(Function)) {\n"
       "  console.log('hitting weird js load bug: diagnosing...');\n"
       "  for (var v in window) {\n"
       "    if (window.hasOwnProperty(v)) console.log(v);\n"
       "  }\n"
       "  window.domAutomationController.send('failed!');\n"
       "}\n"
       "else\n"
       "  doGetUserMedia(" + constraints + ");";
   // Request user media: this will launch the media stream info bar.
   std::string result;
   EXPECT_TRUE(content::ExecuteScriptAndExtractString(
       tab_contents, javascript, &result));
   EXPECT_EQ("ok-requested", result);
 }
 
-MediaStreamInfoBarDelegate* WebRtcTestBase::GetUserMediaAndWaitForInfoBar(
+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<InfoBar::AddedDetails> details(infobar_added.details());
-  MediaStreamInfoBarDelegate* infobar = details->AsMediaStreamInfoBarDelegate();
-  EXPECT_TRUE(infobar);
-  return infobar;
+  EXPECT_TRUE(details->delegate()->AsMediaStreamInfoBarDelegate());
+  return details.ptr();
 }
 
 content::WebContents* WebRtcTestBase::OpenPageAndAcceptUserMedia(
     const GURL& url) const {
   content::WindowedNotificationObserver infobar_added(
       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
       content::NotificationService::AllSources());
 
   ui_test_utils::NavigateToURL(browser(), url);
 
   infobar_added.Wait();
 
   content::WebContents* tab_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   content::Details<InfoBar::AddedDetails> details(infobar_added.details());
-  MediaStreamInfoBarDelegate* infobar =
-      details->AsMediaStreamInfoBarDelegate();
+  InfoBar* infobar = details.ptr();
   EXPECT_TRUE(infobar);
-  infobar->Accept();
+  infobar->delegate()->AsMediaStreamInfoBarDelegate()->Accept();
 
   CloseInfoBarInTab(tab_contents, infobar);
   return tab_contents;
 }
 
 void WebRtcTestBase::CloseInfoBarInTab(
     content::WebContents* tab_contents,
-    MediaStreamInfoBarDelegate* infobar) const {
+    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();
 }
@@ skipping 12 matching lines @@
 // 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());
   EXPECT_EQ("ok-connected", ExecuteJavascript(javascript, tab_contents));
 }