Update push messaging tests to use both infobars and bubbles (w/ autoresponse)

chrome/browser/push_messaging/push_messaging_browsertest.cc

 // Copyright 2014 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 <map>
 #include <string>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
-#include "chrome/browser/infobars/infobar_responder.h"
-#include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/push_messaging/push_messaging_app_identifier.h"
 #include "chrome/browser/push_messaging/push_messaging_constants.h"
 #include "chrome/browser/push_messaging/push_messaging_service_factory.h"
 #include "chrome/browser/push_messaging/push_messaging_service_impl.h"
 #include "chrome/browser/services/gcm/fake_gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
+#include "chrome/browser/ui/website_settings/permission_bubble_responder.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/gcm_driver/gcm_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
@@ skipping 30 matching lines @@
 }  // namespace
 
 class PushMessagingBrowserTest : public InProcessBrowserTest {
  public:
   PushMessagingBrowserTest() : gcm_service_(nullptr) {}
   ~PushMessagingBrowserTest() override {}
 
   // InProcessBrowserTest:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kEnablePushMessagePayload);
+    command_line->AppendSwitch(switches::kEnablePermissionsBubbles);

[johnme, 2015/06/03 14:14:35]

Nit: Isn't this the default now?

[felt, 2015/06/03 20:44:54]

I've been going back and forth with some test failures, which I am trying to fix
this week so it can stay permanently on. I want to make sure the push tests
always run with it on, moving forwards.

 
     InProcessBrowserTest::SetUpCommandLine(command_line);
   }
 
   // InProcessBrowserTest:
   void SetUp() override {
     https_server_.reset(new net::SpawnedTestServer(
         net::SpawnedTestServer::TYPE_HTTPS,
         net::BaseTestServer::SSLOptions(
             net::BaseTestServer::SSLOptions::CERT_OK),
@@ skipping 46 matching lines @@
 
   bool RunScript(const std::string& script, std::string* result,
                  content::WebContents* web_contents) {
     if (!web_contents)
       web_contents = GetBrowser()->tab_strip_model()->GetActiveWebContents();
     return content::ExecuteScriptAndExtractString(web_contents->GetMainFrame(),
                                                   script,
                                                   result);
   }
 
+  void RequestAndAcceptPermission();
+  void RequestAndDenyPermission();
+
   void TryToSubscribeSuccessfully(
       const std::string& expected_push_subscription_id);
 
   std::string GetEndpointForSubscriptionId(const std::string& subscription_id) {
     return std::string(kPushMessagingEndpoint) + "/" + subscription_id;
   }
 
   PushMessagingAppIdentifier GetAppIdentifierForServiceWorkerRegistration(
       int64 service_worker_registration_id);
 
@@ skipping 29 matching lines @@
 
   PushMessagingServiceImpl* push_service() const { return push_service_; }
 
  protected:
   virtual std::string GetTestURL() {
     return "files/push_messaging/test.html";
   }
 
   virtual Browser* GetBrowser() const { return browser(); }
 
-  InfoBarService* GetInfoBarService() {
-    return InfoBarService::FromWebContents(
-        GetBrowser()->tab_strip_model()->GetActiveWebContents());
-  }
-
  private:
   scoped_ptr<net::SpawnedTestServer> https_server_;
   gcm::FakeGCMProfileService* gcm_service_;
   PushMessagingServiceImpl* push_service_;
 
 #if defined(ENABLE_NOTIFICATIONS)
   scoped_ptr<StubNotificationUIManager> notification_manager_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(PushMessagingBrowserTest);
 };
 
 class PushMessagingBrowserTestEmptySubscriptionOptions
     : public PushMessagingBrowserTest {
   std::string GetTestURL() override {
     return "files/push_messaging/test_no_subscription_options.html";
   }
 };
 
+void PushMessagingBrowserTest::RequestAndAcceptPermission() {
+  std::string script_result;
+
+  EXPECT_TRUE(PermissionBubbleManager::Enabled());
+
+  PermissionBubbleManager* bubble_manager =
+      PermissionBubbleManager::FromWebContents(
+          GetBrowser()->tab_strip_model()->GetActiveWebContents());
+  scoped_ptr<PermissionBubbleResponder> bubble_accept_responder(
+      new PermissionBubbleResponder(bubble_manager,
+                                    PermissionBubbleResponder::ACCEPT_ALL));
+  EXPECT_TRUE(RunScript("requestNotificationPermission();", &script_result));
+  EXPECT_EQ("permission status - granted", script_result);
+}
+
+void PushMessagingBrowserTest::RequestAndDenyPermission() {
+  std::string script_result;
+
+  EXPECT_TRUE(PermissionBubbleManager::Enabled());
+
+  PermissionBubbleManager* bubble_manager =
+      PermissionBubbleManager::FromWebContents(
+          GetBrowser()->tab_strip_model()->GetActiveWebContents());
+  scoped_ptr<PermissionBubbleResponder> bubble_deny_responder(
+      new PermissionBubbleResponder(bubble_manager,
+                                    PermissionBubbleResponder::DENY_ALL));
+  EXPECT_TRUE(RunScript("requestNotificationPermission();", &script_result));
+  EXPECT_EQ("permission status - denied", script_result);
+}
+
 void PushMessagingBrowserTest::TryToSubscribeSuccessfully(
     const std::string& expected_push_subscription_id) {
   std::string script_result;
 
   EXPECT_TRUE(RunScript("registerServiceWorker()", &script_result));
   EXPECT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder accepting_responder(GetInfoBarService(), true);
-  EXPECT_TRUE(RunScript("requestNotificationPermission()", &script_result));
-  EXPECT_EQ("permission status - granted", script_result);
+  RequestAndAcceptPermission();
 
   EXPECT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ(GetEndpointForSubscriptionId(expected_push_subscription_id),
             script_result);
 }
 
 PushMessagingAppIdentifier
 PushMessagingBrowserTest::GetAppIdentifierForServiceWorkerRegistration(
     int64 service_worker_registration_id) {
   GURL origin = https_server()->GetURL(std::string()).GetOrigin();
@@ skipping 23 matching lines @@
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeSuccessNotificationsPrompt) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder accepting_responder(GetInfoBarService(), true);
+  RequestAndAcceptPermission();

[johnme, 2015/06/03 14:14:35]

Actually, I think the point of this test is that if you haven't already called
requestNotificationPermission, then calling subscribePush is expected to show
the bubble instead.

So you probably just want the following here:

EXPECT_TRUE(PermissionBubbleManager::Enabled());
PermissionBubbleManager* bubble_manager =
    PermissionBubbleManager::FromWebContents(
        GetBrowser()->tab_strip_model()->GetActiveWebContents());
scoped_ptr<PermissionBubbleResponder> bubble_accept_responder(
    new PermissionBubbleResponder(
        bubble_manager,
        PermissionBubbleResponder::ACCEPT_ALL));

And since there'll now 3 callsites that check and get the
PermissionBubbleManager, it may also make sense to factor out the first two
statements into a helper function?

[felt, 2015/06/03 20:44:54]

Ah, I missed the point of this test. Fixed.
Done, added GetPermissionBubbleManager() and moved the EXPECT enabled check to
SetUpCommandLine.

+
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ(GetEndpointForSubscriptionId("1-0"),
             script_result);
 
   PushMessagingAppIdentifier app_identifier =
       GetAppIdentifierForServiceWorkerRegistration(0LL);
   EXPECT_EQ(app_identifier.app_id(), gcm_service()->last_registered_app_id());
   EXPECT_EQ("1234567890", gcm_service()->last_registered_sender_ids()[0]);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest,
                        SubscribeFailureNotificationsBlocked) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder cancelling_responder(GetInfoBarService(), false);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - denied", script_result);
+  RequestAndDenyPermission();
 
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribeFailureNoManifest) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder accepting_responder(GetInfoBarService(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
+  RequestAndAcceptPermission();
 
   ASSERT_TRUE(RunScript("removeManifest()", &script_result));
   ASSERT_EQ("manifest removed", script_result);
 
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - no sender id provided",
             script_result);
 }
 
 // TODO(johnme): Test subscribing from a worker - see https://crbug.com/437298.
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTestEmptySubscriptionOptions,
                        RegisterFailureEmptyPushSubscriptionOptions) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder accepting_responder(GetInfoBarService(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  ASSERT_EQ("permission status - granted", script_result);
+  RequestAndAcceptPermission();
 
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, SubscribePersisted) {
   std::string script_result;
 
   // First, test that Service Worker registration IDs are assigned in order of
@@ skipping 330 matching lines @@
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   ASSERT_EQ("permission status - prompt", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PermissionStateSaysGranted) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder accepting_responder(GetInfoBarService(), true);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  EXPECT_EQ("permission status - granted", script_result);
+  RequestAndAcceptPermission();
 
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ(GetEndpointForSubscriptionId("1-0"),
             script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - granted", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, PermissionStateSaysDenied) {
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
-  InfoBarResponder cancelling_responder(GetInfoBarService(), false);
-  ASSERT_TRUE(RunScript("requestNotificationPermission();", &script_result));
-  EXPECT_EQ("permission status - denied", script_result);
+  RequestAndDenyPermission();
 
   ASSERT_TRUE(RunScript("subscribePush()", &script_result));
   EXPECT_EQ("AbortError - Registration failed - permission denied",
             script_result);
 
   ASSERT_TRUE(RunScript("permissionState()", &script_result));
   EXPECT_EQ("permission status - denied", script_result);
 }
 
 IN_PROC_BROWSER_TEST_F(PushMessagingBrowserTest, UnsubscribeSuccess) {
@@ skipping 401 matching lines @@
   std::string script_result;
 
   ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
   ASSERT_EQ("ok - service worker registered", script_result);
 
   // In Incognito mode the promise returned by getSubscription should not hang,
   // it should just fulfill with null.
   ASSERT_TRUE(RunScript("hasSubscription()", &script_result));
   ASSERT_EQ("false - not subscribed", script_result);
 }