[WebsiteSettings] Enable permission bubbles by default.

chrome/browser/notifications/notification_browsertest.cc

 // Copyright (c) 2012 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 <deque>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/clock.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_pattern.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "net/base/net_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/window_open_disposition.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/message_center_observer.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kExpectedIconUrl[] = "/notifications/no_such_file.png";
 
-enum InfobarAction {
+enum PromptAction {
   DISMISS = 0,
   ALLOW,
   DENY,
 };
 
 class NotificationChangeObserver {
 public:
   virtual ~NotificationChangeObserver() {}
   virtual bool Wait() = 0;
 };
@@ skipping 42 matching lines @@
     if (message_loop_runner_.get())
       message_loop_runner_->Quit();
   }
 
   bool notification_received_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageCenterChangeObserver);
 };
 
+class MockView : public PermissionBubbleView {
+ public:
+  MockView() : shown_(false), can_accept_updates_(true), delegate_(NULL) {}
+  virtual ~MockView() {}
+
+  void Clear() {
+    shown_ = false;
+    can_accept_updates_ = true;
+    delegate_ = NULL;
+    permission_requests_.clear();
+    permission_states_.clear();
+  }
+
+  // PermissionBubbleView:
+  virtual void SetDelegate(Delegate* delegate) OVERRIDE {
+    delegate_ = delegate;
+  }
+
+  virtual void Show(
+      const std::vector<PermissionBubbleRequest*>& requests,
+      const std::vector<bool>& accept_state,
+      bool customization_state_) OVERRIDE {
+    shown_ = true;
+    permission_requests_ = requests;
+    permission_states_ = accept_state;
+  }
+
+  virtual void Hide() OVERRIDE {
+    shown_ = false;
+  }
+
+  virtual bool IsVisible() OVERRIDE {
+    return shown_;
+  }
+
+  virtual bool CanAcceptRequestUpdate() OVERRIDE {
+    return can_accept_updates_;
+  }
+
+  void Accept() {
+    delegate_->Accept();
+  }
+
+  void Deny() {
+    delegate_->Deny();
+  }
+
+  void Close() {
+    delegate_->Closing();
+  }
+
+  bool shown_;
+  bool can_accept_updates_;
+  Delegate* delegate_;
+  std::vector<PermissionBubbleRequest*> permission_requests_;
+  std::vector<bool> permission_states_;
+};
+
 }  // namespace
 
 class NotificationsTest : public InProcessBrowserTest {
  public:
   NotificationsTest() {}
 
  protected:
   int GetNotificationCount();
   int GetNotificationPopupCount();
 
   void CloseBrowserWindow(Browser* browser);
   void CrashTab(Browser* browser, int index);
 
   void DenyOrigin(const GURL& origin);
   void AllowOrigin(const GURL& origin);
   void AllowAllOrigins();
   void SetDefaultContentSetting(ContentSetting setting);
 
-  void VerifyInfoBar(const Browser* browser, int index);
+  void VerifyPrompt(const Browser* browser, int index);
   std::string CreateNotification(Browser* browser,
                                  bool wait_for_new_balloon,
                                  const char* icon,
                                  const char* title,
                                  const char* body,
                                  const char* replace_id);
   std::string CreateSimpleNotification(Browser* browser,
                                        bool wait_for_new_balloon);
   bool RequestPermissionAndWait(Browser* browser);
   bool CancelNotification(const char* notification_id, Browser* browser);
-  bool PerformActionOnInfoBar(Browser* browser,
-                              InfobarAction action,
-                              size_t infobar_index,
-                              int tab_index);
+  bool PerformAction(Browser* browser,
+                     PromptAction action,
+                     size_t index,
+                     int tab_index);
   void GetPrefsByContentSetting(ContentSetting setting,
                                 ContentSettingsForOneType* settings);
   bool CheckOriginInSetting(const ContentSettingsForOneType& settings,
                             const GURL& origin);
 
   GURL GetTestPageURL() const {
     return embedded_test_server()->GetURL(
       "/notifications/notification_tester.html");
   }
 
+  int GetBubblesQueueSize(PermissionBubbleManager* mgr);
+
  private:
   void DropOriginPreference(const GURL& origin);
+  MockView mock_bubble_view_;
 };
 
 int NotificationsTest::GetNotificationCount() {
   return message_center::MessageCenter::Get()->NotificationCount();
 }
 
 int NotificationsTest::GetNotificationPopupCount() {
   return message_center::MessageCenter::Get()->GetPopupNotifications().size();
 }
 
@@ skipping 24 matching lines @@
   browser()->profile()->GetHostContentSettingsMap()->ClearSettingsForOneType(
        CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
  }
 
 void NotificationsTest::SetDefaultContentSetting(ContentSetting setting) {
   browser()->profile()->GetHostContentSettingsMap()->SetDefaultContentSetting(
       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
 }
 
-void NotificationsTest::VerifyInfoBar(const Browser* browser, int index) {
-  InfoBarService* infobar_service = InfoBarService::FromWebContents(
-      browser->tab_strip_model()->GetWebContentsAt(index));
+void NotificationsTest::VerifyPrompt(const Browser* browser, int index) {
+  if (!PermissionBubbleManager::Enabled()) {
+    InfoBarService* infobar_service = InfoBarService::FromWebContents(
+        browser->tab_strip_model()->GetWebContentsAt(index));
 
-  ASSERT_EQ(1U, infobar_service->infobar_count());
-  ConfirmInfoBarDelegate* confirm_infobar =
-      infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
-  ASSERT_TRUE(confirm_infobar);
-  int buttons = confirm_infobar->GetButtons();
-  EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_OK);
-  EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_CANCEL);
+    ASSERT_EQ(1U, infobar_service->infobar_count());
+    ConfirmInfoBarDelegate* confirm_infobar =
+        infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
+    ASSERT_TRUE(confirm_infobar);
+    int buttons = confirm_infobar->GetButtons();
+    EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_OK);
+    EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_CANCEL);
+  } else {
+    PermissionBubbleManager* permission_manager =
+        PermissionBubbleManager::FromWebContents(
+            browser->tab_strip_model()->GetWebContentsAt(0));
+LOG(INFO) << "Get queue size";
+    ASSERT_EQ(1, GetBubblesQueueSize(permission_manager));
+  }
 }
 
 std::string NotificationsTest::CreateNotification(
     Browser* browser,
     bool wait_for_new_balloon,
     const char* icon,
     const char* title,
     const char* body,
     const char* replace_id) {
   std::string script = base::StringPrintf(
@@ skipping 17 matching lines @@
     Browser* browser,
     bool wait_for_new_balloon) {
   return CreateNotification(
       browser, wait_for_new_balloon,
       "no_such_file.png", "My Title", "My Body", "");
 }
 
 bool NotificationsTest::RequestPermissionAndWait(Browser* browser) {
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser->tab_strip_model()->GetActiveWebContents());
-  content::WindowedNotificationObserver observer(
-      chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
-      content::Source<InfoBarService>(infobar_service));
-  std::string result;
-  bool success = content::ExecuteScriptAndExtractString(
-      browser->tab_strip_model()->GetActiveWebContents(),
-      "requestPermission();",
-      &result);
-  if (!success || result != "1")
-    return false;
-  observer.Wait();
-  return true;
+  PermissionBubbleManager* permission_manager =
+      PermissionBubbleManager::FromWebContents(
+          browser->tab_strip_model()->GetWebContentsAt(0));
+  permission_manager->SetView(&mock_bubble_view_);
+  if (!PermissionBubbleManager::Enabled()) {
+    content::WindowedNotificationObserver observer(
+        chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
+        content::Source<InfoBarService>(infobar_service));
+    std::string result;
+    bool success = content::ExecuteScriptAndExtractString(
+        browser->tab_strip_model()->GetActiveWebContents(),
+        "requestPermission();",
+        &result);
+    if (!success || result != "1")
+      return false;
+    observer.Wait();
+    return true;
+  } else {
+    std::string result;
+    bool success = content::ExecuteScriptAndExtractString(
+        browser->tab_strip_model()->GetActiveWebContents(),
+        "requestPermission();",
+        &result);
+    if (!success || result != "1")
+      return false;
+    while (!mock_bubble_view_.shown_) {
+      (new content::MessageLoopRunner())->Run();
+    }
+    return true;
+  }
 }
 
 bool NotificationsTest::CancelNotification(
     const char* notification_id,
     Browser* browser) {
   std::string script = base::StringPrintf(
       "cancelNotification('%s');",
       notification_id);
 
   MessageCenterChangeObserver observer;
   std::string result;
   bool success = content::ExecuteScriptAndExtractString(
       browser->tab_strip_model()->GetActiveWebContents(),
       script,
       &result);
   if (!success || result != "1")
     return false;
   return observer.Wait();
 }
 
-bool NotificationsTest::PerformActionOnInfoBar(
+bool NotificationsTest::PerformAction(
     Browser* browser,
-    InfobarAction action,
-    size_t infobar_index,
+    PromptAction action,
+    size_t index,
     int tab_index) {
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser->tab_strip_model()->GetWebContentsAt(tab_index));
-  if (infobar_index >= infobar_service->infobar_count()) {
-    ADD_FAILURE();
-    return false;
+  PermissionBubbleManager* permission_manager =
+      PermissionBubbleManager::FromWebContents(
+          browser->tab_strip_model()->GetWebContentsAt(0));
+  if (!PermissionBubbleManager::Enabled()) {
+    if (index >= infobar_service->infobar_count()) {
+      ADD_FAILURE();
+      return false;
+    }
+  } else {
+    if (static_cast<int>(index) >= GetBubblesQueueSize(permission_manager)) {
+      ADD_FAILURE();
+      return false;
+    }
   }
 
-  infobars::InfoBar* infobar = infobar_service->infobar_at(infobar_index);
-  infobars::InfoBarDelegate* infobar_delegate = infobar->delegate();
-  switch (action) {
-    case DISMISS:
-      infobar_delegate->InfoBarDismissed();
-      infobar_service->RemoveInfoBar(infobar);
-      return true;
-
-    case ALLOW: {
-      ConfirmInfoBarDelegate* confirm_infobar_delegate =
-          infobar_delegate->AsConfirmInfoBarDelegate();
-      if (!confirm_infobar_delegate) {
-        ADD_FAILURE();
-      } else if (confirm_infobar_delegate->Accept()) {
+  if (!PermissionBubbleManager::Enabled()) {
+    infobars::InfoBar* infobar = infobar_service->infobar_at(index);
+    infobars::InfoBarDelegate* infobar_delegate = infobar->delegate();
+    switch (action) {
+      case DISMISS:
+        infobar_delegate->InfoBarDismissed();
         infobar_service->RemoveInfoBar(infobar);
         return true;
+
+      case ALLOW: {
+        ConfirmInfoBarDelegate* confirm_infobar_delegate =
+            infobar_delegate->AsConfirmInfoBarDelegate();
+        if (!confirm_infobar_delegate) {
+          ADD_FAILURE();
+        } else if (confirm_infobar_delegate->Accept()) {
+          infobar_service->RemoveInfoBar(infobar);
+          return true;
+        }
+      }
+
+      case DENY: {
+        ConfirmInfoBarDelegate* confirm_infobar_delegate =
+            infobar_delegate->AsConfirmInfoBarDelegate();
+        if (!confirm_infobar_delegate) {
+          ADD_FAILURE();
+        } else if (confirm_infobar_delegate->Cancel()) {
+          infobar_service->RemoveInfoBar(infobar);
+          return true;
+        }
       }
     }
-
-    case DENY: {
-      ConfirmInfoBarDelegate* confirm_infobar_delegate =
-          infobar_delegate->AsConfirmInfoBarDelegate();
-      if (!confirm_infobar_delegate) {
-        ADD_FAILURE();
-      } else if (confirm_infobar_delegate->Cancel()) {
-        infobar_service->RemoveInfoBar(infobar);
+  } else {
+    switch (action) {
+      case DISMISS:
+        mock_bubble_view_.Close();
         return true;
-      }
+      case ALLOW:
+        mock_bubble_view_.Accept();
+        return true;
+      case DENY:
+        mock_bubble_view_.Deny();
+        return true;
     }
   }
 
   return false;
 }
 
 void NotificationsTest::GetPrefsByContentSetting(
     ContentSetting setting,
     ContentSettingsForOneType* settings) {
   DesktopNotificationProfileUtil::GetNotificationsSettings(
@@ skipping 18 matching lines @@
       return true;
   }
   return false;
 }
 
 void NotificationsTest::DropOriginPreference(const GURL& origin) {
   DesktopNotificationProfileUtil::ClearSetting(browser()->profile(),
       ContentSettingsPattern::FromURLNoWildcard(origin));
 }
 
+int NotificationsTest::GetBubblesQueueSize(
+    PermissionBubbleManager* mgr) {
+LOG(INFO) << "Have " << mgr->requests_.size();
+  return static_cast<int>(mgr->requests_.size());
+}
+
 // If this flakes, use http://crbug.com/62311 and http://crbug.com/74428.
-IN_PROC_BROWSER_TEST_F(NotificationsTest, TestUserGestureInfobar) {
+IN_PROC_BROWSER_TEST_F(NotificationsTest, TestUserGesture) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   ui_test_utils::NavigateToURL(
       browser(),
       embedded_test_server()->GetURL(
           "/notifications/notifications_request_function.html"));
 
   // Request permission by calling request() while eval'ing an inline script;
   // That's considered a user gesture to webkit, and should produce an infobar.
   bool result;
   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
       browser()->tab_strip_model()->GetActiveWebContents(),
       "window.domAutomationController.send(request());",
       &result));
   EXPECT_TRUE(result);
 
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser()->tab_strip_model()->GetWebContentsAt(0));
-  EXPECT_EQ(1U, infobar_service->infobar_count());
+  PermissionBubbleManager* permission_manager =
+      PermissionBubbleManager::FromWebContents(
+          browser()->tab_strip_model()->GetWebContentsAt(0));
+  if (!PermissionBubbleManager::Enabled())
+    EXPECT_EQ(1U, infobar_service->infobar_count());
+  else
+    EXPECT_EQ(1, GetBubblesQueueSize(permission_manager));
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCreateSimpleNotification) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Creates a simple notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
@@ skipping 37 matching lines @@
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string note_id = CreateSimpleNotification(browser(), true);
   EXPECT_NE(note_id, "-1");
 
   ASSERT_EQ(1, GetNotificationCount());
   ASSERT_TRUE(CancelNotification(note_id.c_str(), browser()));
   ASSERT_EQ(0, GetNotificationCount());
 }
 
-IN_PROC_BROWSER_TEST_F(NotificationsTest, TestPermissionInfobarAppears) {
+IN_PROC_BROWSER_TEST_F(NotificationsTest, TestPermissionPromptAppears) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Requests notification privileges and verifies the infobar appears.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 
   ASSERT_EQ(0, GetNotificationCount());
-  ASSERT_NO_FATAL_FAILURE(VerifyInfoBar(browser(), 0));
+LOG(INFO) << "VerifyPrompt";
+  ASSERT_NO_FATAL_FAILURE(VerifyPrompt(browser(), 0));
 }
 
-IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowOnPermissionInfobar) {
+IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowOnPermission) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Tries to create a notification and clicks allow on the infobar.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   // This notification should not be shown because we do not have permission.
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
 
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
-  ASSERT_TRUE(PerformActionOnInfoBar(browser(), ALLOW, 0, 0));
+  ASSERT_TRUE(PerformAction(browser(), ALLOW, 0, 0));
 
   CreateSimpleNotification(browser(), true);
   EXPECT_EQ(1, GetNotificationCount());
 }
 
-IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyOnPermissionInfobar) {
+IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyOnPermission) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Test that no notification is created
   // when Deny is chosen from permission infobar.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
-  PerformActionOnInfoBar(browser(), DENY, 0, 0);
+  PerformAction(browser(), DENY, 0, 0);
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   EXPECT_TRUE(CheckOriginInSetting(settings, GetTestPageURL()));
 }
 
-IN_PROC_BROWSER_TEST_F(NotificationsTest, TestClosePermissionInfobar) {
+IN_PROC_BROWSER_TEST_F(NotificationsTest, TestClosePermission) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Test that no notification is created when permission infobar is dismissed.
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
-  PerformActionOnInfoBar(browser(), DISMISS, 0, 0);
+  PerformAction(browser(), DISMISS, 0, 0);
   CreateSimpleNotification(browser(), false);
   ASSERT_EQ(0, GetNotificationCount());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   EXPECT_EQ(0U, settings.size());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowNotificationsFromAllSites) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
@@ skipping 104 matching lines @@
 // Crashes on Linux/Win. See http://crbug.com/160657.
 IN_PROC_BROWSER_TEST_F(
     NotificationsTest,
     DISABLED_TestOriginPrefsNotSavedInIncognito) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Verify that allow/deny origin preferences are not saved in incognito.
   Browser* incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(incognito));
-  PerformActionOnInfoBar(incognito, DENY, 0, 0);
+  PerformAction(incognito, DENY, 0, 0);
   CloseBrowserWindow(incognito);
 
   incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(incognito));
-  PerformActionOnInfoBar(incognito, ALLOW, 0, 0);
+  PerformAction(incognito, ALLOW, 0, 0);
   CreateSimpleNotification(incognito, true);
   ASSERT_EQ(1, GetNotificationCount());
   CloseBrowserWindow(incognito);
 
   incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(incognito));
 
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
@@ skipping 35 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestIncognitoNotification) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Test notifications in incognito window.
   Browser* browser = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(browser, GetTestPageURL());
   browser->tab_strip_model()->ActivateTabAt(0, true);
   ASSERT_TRUE(RequestPermissionAndWait(browser));
-  PerformActionOnInfoBar(browser, ALLOW, 0, 0);
+  PerformAction(browser, ALLOW, 0, 0);
   CreateSimpleNotification(browser, true);
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseTabWithPermissionInfobar) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Test that user can close tab when infobar present.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("about:blank"),
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
   browser()->tab_strip_model()->ActivateTabAt(0, true);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
   content::WebContentsDestroyedWatcher destroyed_watcher(
       browser()->tab_strip_model()->GetWebContentsAt(0));
   browser()->tab_strip_model()->CloseWebContentsAt(0,
                                                    TabStripModel::CLOSE_NONE);
   destroyed_watcher.Wait();
 }
 
 IN_PROC_BROWSER_TEST_F(
     NotificationsTest,
-    TestNavigateAwayWithPermissionInfobar) {
+    TestNavigateAwayWithPermission) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Test navigating away when an infobar is present,
   // then trying to create a notification from the same page.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(),
       GURL("about:blank"),
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
   browser()->tab_strip_model()->ActivateTabAt(0, true);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
-  PerformActionOnInfoBar(browser(), ALLOW, 0, 0);
+  PerformAction(browser(), ALLOW, 0, 0);
   CreateSimpleNotification(browser(), true);
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 // See crbug.com/248470
 #if defined(OS_LINUX)
 #define MAYBE_TestCrashRendererNotificationRemain \
     DISABLED_TestCrashRendererNotificationRemain
 #else
 #define MAYBE_TestCrashRendererNotificationRemain \
@@ skipping 103 matching lines @@
       (*notifications.rbegin())->id());
 
   ASSERT_EQ(0, GetNotificationPopupCount());
 
   result = CreateNotification(
       browser(), true, "abc.png", "Title2", "Body2", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationPopupCount());
 }