Migrate the notification permission to the new common permission classes.

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_service.h"
-#include "chrome/browser/notifications/desktop_notification_service_factory.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/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"
@@ skipping 86 matching lines @@
 class NotificationsTest : public InProcessBrowserTest {
  public:
   NotificationsTest() {}
 
  protected:
   int GetNotificationCount();
 
   void CloseBrowserWindow(Browser* browser);
   void CrashTab(Browser* browser, int index);
 
-  void SetDefaultPermissionSetting(ContentSetting setting);
   void DenyOrigin(const GURL& origin);
   void AllowOrigin(const GURL& origin);
   void AllowAllOrigins();
+  void SetDefaultContentSetting(ContentSetting setting);
 
   void VerifyInfoBar(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);
   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");
   }
 
  private:
   void DropOriginPreference(const GURL& origin);
-  DesktopNotificationService* GetDesktopNotificationService();
 };
 
 int NotificationsTest::GetNotificationCount() {
   return message_center::MessageCenter::Get()->NotificationCount();
 }
 
 void NotificationsTest::CloseBrowserWindow(Browser* browser) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(browser));
   browser->window()->Close();
   observer.Wait();
 }
 
 void NotificationsTest::CrashTab(Browser* browser, int index) {
   content::CrashTab(browser->tab_strip_model()->GetWebContentsAt(index));
 }
 
-void NotificationsTest::SetDefaultPermissionSetting(ContentSetting setting) {
-  DesktopNotificationService* service = GetDesktopNotificationService();
-  service->SetDefaultContentSetting(setting);
-}
-
 void NotificationsTest::DenyOrigin(const GURL& origin) {
   DropOriginPreference(origin);
-  GetDesktopNotificationService()->DenyPermission(origin);
+  DesktopNotificationProfileUtil::DenyPermission(browser()->profile(), origin);
 }
 
 void NotificationsTest::AllowOrigin(const GURL& origin) {
   DropOriginPreference(origin);
-  GetDesktopNotificationService()->GrantPermission(origin);
+  DesktopNotificationProfileUtil::GrantPermission(browser()->profile(), origin);
 }
 
 void NotificationsTest::AllowAllOrigins() {
-  GetDesktopNotificationService()->ResetAllOrigins();
-  GetDesktopNotificationService()->SetDefaultContentSetting(
-      CONTENT_SETTING_ALLOW);
+  // Reset all origins
+  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));
 
   ASSERT_EQ(1U, infobar_service->infobar_count());
   ConfirmInfoBarDelegate* confirm_infobar =
       infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
   ASSERT_TRUE(confirm_infobar);
@@ skipping 111 matching lines @@
       }
     }
   }
 
   return false;
 }
 
 void NotificationsTest::GetPrefsByContentSetting(
     ContentSetting setting,
     ContentSettingsForOneType* settings) {
-  DesktopNotificationService* service = GetDesktopNotificationService();
-  service->GetNotificationsSettings(settings);
+  DesktopNotificationProfileUtil::GetNotificationsSettings(
+      browser()->profile(), settings);
   for (ContentSettingsForOneType::iterator it = settings->begin();
        it != settings->end(); ) {
     if (it->setting != setting || it->source.compare("preference") != 0)
       it = settings->erase(it);
     else
       ++it;
   }
 }
 
 bool NotificationsTest::CheckOriginInSetting(
     const ContentSettingsForOneType& settings,
     const GURL& origin) {
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromURLNoWildcard(origin);
   for (ContentSettingsForOneType::const_iterator it = settings.begin();
        it != settings.end(); ++it) {
     if (it->primary_pattern == pattern)
       return true;
   }
   return false;
 }
 
 void NotificationsTest::DropOriginPreference(const GURL& origin) {
-  GetDesktopNotificationService()->ClearSetting(
+  DesktopNotificationProfileUtil::ClearSetting(browser()->profile(),
       ContentSettingsPattern::FromURLNoWildcard(origin));
 }
 
-DesktopNotificationService* NotificationsTest::GetDesktopNotificationService() {
-  Profile* profile = browser()->profile();
-  return DesktopNotificationServiceFactory::GetForProfile(profile);
-}
-
 // If this flakes, use http://crbug.com/62311 and http://crbug.com/74428.
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestUserGestureInfobar) {
   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;
@@ skipping 118 matching lines @@
   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());
 
   // Verify that all domains can be allowed to show notifications.
-  SetDefaultPermissionSetting(CONTENT_SETTING_ALLOW);
+  SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser()->tab_strip_model()->GetWebContentsAt(0));
   EXPECT_EQ(0U, infobar_service->infobar_count());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyNotificationsFromAllSites) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Verify that no domain can show notifications.
-  SetDefaultPermissionSetting(CONTENT_SETTING_BLOCK);
+  SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), false);
   EXPECT_EQ("-1", result);
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyDomainAndAllowAll) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Verify that denying a domain and allowing all shouldn't show
   // notifications from the denied domain.
   DenyOrigin(GetTestPageURL().GetOrigin());
-  SetDefaultPermissionSetting(CONTENT_SETTING_ALLOW);
+  SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), false);
   EXPECT_EQ("-1", result);
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowDomainAndDenyAll) {
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 
   // Verify that allowing a domain and denying all others should show
   // notifications from the allowed domain.
   AllowOrigin(GetTestPageURL().GetOrigin());
-  SetDefaultPermissionSetting(CONTENT_SETTING_BLOCK);
+  SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
 
   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyAndThenAllowDomain) {
@@ skipping 247 matching lines @@
 
   result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   EXPECT_EQ(settings_map->GetLastUsage(GetTestPageURL().GetOrigin(),
                                        GetTestPageURL().GetOrigin(),
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
                 .ToDoubleT(),
             13);
 }