chrome/browser/notifications/platform_notification_service_browsertest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6 #include <vector>
   7
   8 #include "base/command_line.h"
   9 #include "base/files/file_path.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/path_service.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
  14 #include "chrome/browser/notifications/notification_permission_context.h"
  15 #include "chrome/browser/notifications/notification_permission_context_factory.h"
  16 #include "chrome/browser/notifications/notification_test_util.h"
  17 #include "chrome/browser/notifications/platform_notification_service_impl.h"
  18 #include "chrome/browser/ui/browser.h"
  19 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  20 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/grit/generated_resources.h"
  23 #include "chrome/test/base/in_process_browser_test.h"
  24 #include "chrome/test/base/ui_test_utils.h"
  25 #include "content/public/test/browser_test_utils.h"
  26 #include "net/base/filename_util.h"
  27 #include "net/test/spawned_test_server/spawned_test_server.h"
  28 #include "testing/gmock/include/gmock/gmock.h"
  29 #include "ui/base/l10n/l10n_util.h"
  30
  31 // -----------------------------------------------------------------------------
  32
  33 // Dimensions of the icon.png resource in the notification test data directory.
  34 const int kIconWidth = 100;
  35 const int kIconHeight = 100;
  36
  37 const int kNotificationVibrationPattern[] = { 100, 200, 300 };
  38
  39 class PlatformNotificationServiceBrowserTest : public InProcessBrowserTest {
  40  public:
  41   PlatformNotificationServiceBrowserTest();
  42   ~PlatformNotificationServiceBrowserTest() override {}
  43
  44   // InProcessBrowserTest overrides.
  45   void SetUp() override;
  46   void SetUpCommandLine(base::CommandLine* command_line) override;
  47   void SetUpOnMainThread() override;
  48   void TearDown() override;
  49
  50  protected:
  51   // Returns the Platform Notification Service these unit tests are for.
  52   PlatformNotificationServiceImpl* service() const {
  53     return PlatformNotificationServiceImpl::GetInstance();
  54   }
  55
  56   // Grants permission to display Web Notifications for origin of the test
  57   // page that's being used in this browser test.
  58   void GrantNotificationPermissionForTest() const;
  59
  60   bool RequestAndAcceptPermission();
  61   bool RequestAndDenyPermission();
  62
  63   // Returns the UI Manager on which notifications will be displayed.
  64   StubNotificationUIManager* ui_manager() const { return ui_manager_.get(); }
  65
  66   const base::FilePath& server_root() const { return server_root_; }
  67
  68   // Navigates the browser to the test page indicated by |path|.
  69   void NavigateToTestPage(const std::string& path) const;
  70
  71   // Executes |script| and stores the result as a string in |result|. A boolean
  72   // will be returned, indicating whether the script was executed successfully.
  73   bool RunScript(const std::string& script, std::string* result) const;
  74
  75   net::HostPortPair ServerHostPort() const;
  76   GURL TestPageUrl() const;
  77
  78  private:
  79   std::string RequestAndRespondToPermission(
  80       PermissionBubbleManager::AutoResponseType bubble_response);
  81
  82   content::WebContents* GetActiveWebContents(Browser* browser) {
  83     return browser->tab_strip_model()->GetActiveWebContents();
  84   }
  85
  86   const base::FilePath server_root_;
  87   const std::string test_page_url_;
  88   scoped_ptr<StubNotificationUIManager> ui_manager_;
  89   scoped_ptr<net::SpawnedTestServer> https_server_;
  90 };
  91
  92 // -----------------------------------------------------------------------------
  93
  94 namespace {
  95 const char kTestFileName[] = "notifications/platform_notification_service.html";
  96 }
  97
  98 PlatformNotificationServiceBrowserTest::PlatformNotificationServiceBrowserTest()
  99     : server_root_(FILE_PATH_LITERAL("chrome/test/data")),
 100       // The test server has a base directory that doesn't exist in the
 101       // filesystem.
 102       test_page_url_(std::string("files/") + kTestFileName) {
 103 }
 104
 105 void PlatformNotificationServiceBrowserTest::SetUpCommandLine(
 106     base::CommandLine* command_line) {
 107   const testing::TestInfo* const test_info =
 108       testing::UnitTest::GetInstance()->current_test_info();
 109   if (strcmp(test_info->name(), "WebNotificationSiteSettingsButton") == 0)
 110     command_line->AppendSwitch(switches::kNotificationSettingsButton);
 111 }
 112
 113 void PlatformNotificationServiceBrowserTest::SetUp() {
 114   ui_manager_.reset(new StubNotificationUIManager);
 115   https_server_.reset(new net::SpawnedTestServer(
 116       net::SpawnedTestServer::TYPE_HTTPS,
 117       net::BaseTestServer::SSLOptions(net::BaseTestServer::SSLOptions::CERT_OK),
 118       server_root_));
 119   ASSERT_TRUE(https_server_->Start());
 120
 121   service()->SetNotificationUIManagerForTesting(ui_manager_.get());
 122
 123   InProcessBrowserTest::SetUp();
 124 }
 125
 126 void PlatformNotificationServiceBrowserTest::SetUpOnMainThread() {
 127   NavigateToTestPage(test_page_url_);
 128
 129   InProcessBrowserTest::SetUpOnMainThread();
 130 }
 131
 132 void PlatformNotificationServiceBrowserTest::TearDown() {
 133   service()->SetNotificationUIManagerForTesting(nullptr);
 134 }
 135
 136 void PlatformNotificationServiceBrowserTest::
 137     GrantNotificationPermissionForTest() const {
 138   GURL origin = TestPageUrl().GetOrigin();
 139
 140   DesktopNotificationProfileUtil::GrantPermission(browser()->profile(), origin);
 141   ASSERT_EQ(CONTENT_SETTING_ALLOW,
 142             DesktopNotificationProfileUtil::GetContentSetting(
 143                 browser()->profile(), origin));
 144 }
 145
 146 void PlatformNotificationServiceBrowserTest::NavigateToTestPage(
 147     const std::string& path) const {
 148   ui_test_utils::NavigateToURL(browser(), https_server_->GetURL(path));
 149 }
 150
 151 bool PlatformNotificationServiceBrowserTest::RunScript(
 152     const std::string& script, std::string* result) const {
 153   return content::ExecuteScriptAndExtractString(
 154       browser()->tab_strip_model()->GetActiveWebContents()->GetMainFrame(),
 155       script,
 156       result);
 157 }
 158
 159 net::HostPortPair PlatformNotificationServiceBrowserTest::ServerHostPort()
 160     const {
 161   return https_server_->host_port_pair();
 162 }
 163
 164 GURL PlatformNotificationServiceBrowserTest::TestPageUrl() const {
 165   return https_server_->GetURL(test_page_url_);
 166 }
 167
 168 std::string
 169 PlatformNotificationServiceBrowserTest::RequestAndRespondToPermission(
 170     PermissionBubbleManager::AutoResponseType bubble_response) {
 171   std::string result;
 172   content::WebContents* web_contents = GetActiveWebContents(browser());
 173   PermissionBubbleManager::FromWebContents(web_contents)
 174       ->set_auto_response_for_test(bubble_response);
 175   EXPECT_TRUE(RunScript("RequestPermission();", &result));
 176   return result;
 177 }
 178
 179 bool PlatformNotificationServiceBrowserTest::RequestAndAcceptPermission() {
 180   std::string result =
 181       RequestAndRespondToPermission(PermissionBubbleManager::ACCEPT_ALL);
 182   return "granted" == result;
 183 }
 184
 185 bool PlatformNotificationServiceBrowserTest::RequestAndDenyPermission() {
 186   std::string result =
 187       RequestAndRespondToPermission(PermissionBubbleManager::DENY_ALL);
 188   return "denied" == result;
 189 }
 190
 191 // -----------------------------------------------------------------------------
 192
 193 // TODO(peter): Move PlatformNotificationService-related tests over from
 194 // notification_browsertest.cc to this file.
 195
 196 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 197                        DisplayPersistentNotificationWithoutPermission) {
 198   RequestAndDenyPermission();
 199
 200   std::string script_result;
 201   ASSERT_TRUE(RunScript("DisplayPersistentNotification()", &script_result));
 202   EXPECT_EQ(
 203       "TypeError: No notification permission has been granted for this origin.",
 204       script_result);
 205
 206   ASSERT_EQ(0u, ui_manager()->GetNotificationCount());
 207 }
 208
 209 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 210                        DisplayPersistentNotificationWithPermission) {
 211   RequestAndAcceptPermission();
 212
 213   std::string script_result;
 214   ASSERT_TRUE(RunScript("DisplayPersistentNotification('action_none')",
 215        &script_result));
 216   EXPECT_EQ("ok", script_result);
 217
 218   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 219
 220   const Notification& notification = ui_manager()->GetNotificationAt(0);
 221   notification.delegate()->Click();
 222
 223   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
 224   EXPECT_EQ("action_none", script_result);
 225
 226   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 227 }
 228
 229 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 230                        WebNotificationOptionsReflection) {
 231   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 232
 233   // First, test the default values.
 234
 235   std::string script_result;
 236   ASSERT_TRUE(RunScript("DisplayPersistentNotification('Some title', {})",
 237                         &script_result));
 238   EXPECT_EQ("ok", script_result);
 239
 240   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 241
 242   // We don't use or check the notification's direction and language.
 243   const Notification& default_notification = ui_manager()->GetNotificationAt(0);
 244   EXPECT_EQ("Some title", base::UTF16ToUTF8(default_notification.title()));
 245   EXPECT_EQ("", base::UTF16ToUTF8(default_notification.message()));
 246   EXPECT_EQ("", default_notification.tag());
 247   EXPECT_TRUE(default_notification.icon().IsEmpty());
 248   EXPECT_FALSE(default_notification.silent());
 249   EXPECT_FALSE(default_notification.never_timeout());
 250
 251   // Now, test the non-default values.
 252
 253   ASSERT_TRUE(RunScript("DisplayPersistentAllOptionsNotification()",
 254                         &script_result));
 255   EXPECT_EQ("ok", script_result);
 256
 257   ASSERT_EQ(2u, ui_manager()->GetNotificationCount());
 258
 259   // We don't use or check the notification's direction and language.
 260   const Notification& all_options_notification =
 261       ui_manager()->GetNotificationAt(1);
 262   EXPECT_EQ("Title", base::UTF16ToUTF8(all_options_notification.title()));
 263   EXPECT_EQ("Contents", base::UTF16ToUTF8(all_options_notification.message()));
 264   EXPECT_EQ("replace-id", all_options_notification.tag());
 265   EXPECT_FALSE(all_options_notification.icon().IsEmpty());
 266   EXPECT_TRUE(all_options_notification.silent());
 267   EXPECT_TRUE(all_options_notification.never_timeout());
 268
 269   EXPECT_EQ(kIconWidth, all_options_notification.icon().Width());
 270   EXPECT_EQ(kIconHeight, all_options_notification.icon().Height());
 271 }
 272
 273 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 274                        WebNotificationSiteSettingsButton) {
 275   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 276
 277   std::string script_result;
 278   ASSERT_TRUE(
 279       RunScript("DisplayPersistentAllOptionsNotification()", &script_result));
 280   EXPECT_EQ("ok", script_result);
 281
 282   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 283
 284   const Notification& notification = ui_manager()->GetNotificationAt(0);
 285   const std::vector<message_center::ButtonInfo>& buttons =
 286       notification.buttons();
 287   EXPECT_EQ(1u, buttons.size());
 288   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_NOTIFICATION_SETTINGS),
 289             buttons[0].title);
 290
 291   notification.delegate()->ButtonClick(0);
 292   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 293 }
 294
 295 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 296                        WebNotificationOptionsVibrationPattern) {
 297   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 298
 299   std::string script_result;
 300   ASSERT_TRUE(RunScript("DisplayPersistentNotificationVibrate()",
 301                         &script_result));
 302   EXPECT_EQ("ok", script_result);
 303
 304   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 305
 306   const Notification& notification = ui_manager()->GetNotificationAt(0);
 307   EXPECT_EQ("Title", base::UTF16ToUTF8(notification.title()));
 308   EXPECT_EQ("Contents", base::UTF16ToUTF8(notification.message()));
 309
 310   EXPECT_THAT(notification.vibration_pattern(),
 311       testing::ElementsAreArray(kNotificationVibrationPattern));
 312 }
 313
 314 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 315                        CloseDisplayedPersistentNotification) {
 316   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 317
 318   std::string script_result;
 319   ASSERT_TRUE(RunScript("DisplayPersistentNotification('action_close')",
 320                         &script_result));
 321   EXPECT_EQ("ok", script_result);
 322
 323   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 324
 325   const Notification& notification = ui_manager()->GetNotificationAt(0);
 326   notification.delegate()->Click();
 327
 328   ASSERT_TRUE(RunScript("GetMessageFromWorker()", &script_result));
 329   EXPECT_EQ("action_close", script_result);
 330
 331   ASSERT_EQ(0u, ui_manager()->GetNotificationCount());
 332 }
 333
 334 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 335                        TestDisplayOriginContextMessage) {
 336   RequestAndAcceptPermission();
 337
 338   // Creates a simple notification.
 339   std::string script_result;
 340   ASSERT_TRUE(RunScript("DisplayPersistentNotification()", &script_result));
 341
 342   net::HostPortPair host_port = ServerHostPort();
 343
 344   const Notification& notification = ui_manager()->GetNotificationAt(0);
 345
 346   EXPECT_TRUE(notification.context_message().empty());
 347   EXPECT_EQ("https://" + host_port.ToString() + "/",
 348             notification.origin_url().spec());
 349 }
 350
 351 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 352                        CheckFilePermissionNotGranted) {
 353   // TODO(felt): This DCHECKs when bubbles are enabled, when the file_url is
 354   // persisted. crbug.com/502057
 355   if (PermissionBubbleManager::Enabled())
 356     return;
 357
 358   // TODO(dewittj): It currently isn't possible to get the notification
 359   // permission for a file:// URL. If that changes, this test will fail to
 360   // remind the author that the
 361   // |PlatformNotificationServiceImpl::WebOriginDisplayName| function needs
 362   // to be updated to properly display file:// URL origins.
 363   // See crbug.com/402191.
 364
 365   // This case should succeed because a normal page URL is used.
 366   std::string script_result;
 367
 368   NotificationPermissionContext* permission_context =
 369       NotificationPermissionContextFactory::GetForProfile(browser()->profile());
 370   ASSERT_TRUE(permission_context);
 371
 372   EXPECT_EQ(CONTENT_SETTING_ASK,
 373             permission_context->GetPermissionStatus(TestPageUrl(),
 374                                                     TestPageUrl()));
 375
 376   RequestAndAcceptPermission();
 377   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 378             permission_context->GetPermissionStatus(TestPageUrl(),
 379                                                     TestPageUrl()));
 380
 381   // This case should fail because a file URL is used.
 382   base::FilePath dir_source_root;
 383   EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &dir_source_root));
 384   base::FilePath full_file_path =
 385       dir_source_root.Append(server_root()).AppendASCII(kTestFileName);
 386   GURL file_url(net::FilePathToFileURL(full_file_path));
 387
 388   ui_test_utils::NavigateToURL(browser(), file_url);
 389
 390   EXPECT_EQ(CONTENT_SETTING_ASK,
 391             permission_context->GetPermissionStatus(file_url, file_url));
 392
 393   RequestAndAcceptPermission();
 394   EXPECT_EQ(CONTENT_SETTING_ASK,
 395             permission_context->GetPermissionStatus(file_url, file_url))
 396       << "If this test fails, you may have fixed a bug preventing file origins "
 397       << "from sending their origin from Blink; if so you need to update the "
 398       << "display function for notification origins to show the file path.";
 399 }
 400
 401 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 402                        DataUrlAsNotificationImage) {
 403   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 404
 405   std::string script_result;
 406   ASSERT_TRUE(RunScript("DisplayPersistentNotificationDataUrlImage()",
 407                         &script_result));
 408   EXPECT_EQ("ok", script_result);
 409
 410   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 411
 412   const Notification& notification = ui_manager()->GetNotificationAt(0);
 413   EXPECT_FALSE(notification.icon().IsEmpty());
 414
 415   EXPECT_EQ("Data URL Title", base::UTF16ToUTF8(notification.title()));
 416   EXPECT_EQ(kIconWidth, notification.icon().Width());
 417   EXPECT_EQ(kIconHeight, notification.icon().Height());
 418 }
 419
 420 IN_PROC_BROWSER_TEST_F(PlatformNotificationServiceBrowserTest,
 421                        BlobAsNotificationImage) {
 422   ASSERT_NO_FATAL_FAILURE(GrantNotificationPermissionForTest());
 423
 424   std::string script_result;
 425   ASSERT_TRUE(RunScript("DisplayPersistentNotificationBlobImage()",
 426                         &script_result));
 427   EXPECT_EQ("ok", script_result);
 428
 429   ASSERT_EQ(1u, ui_manager()->GetNotificationCount());
 430
 431   const Notification& notification = ui_manager()->GetNotificationAt(0);
 432   EXPECT_FALSE(notification.icon().IsEmpty());
 433
 434   EXPECT_EQ("Blob Title", base::UTF16ToUTF8(notification.title()));
 435   EXPECT_EQ(kIconWidth, notification.icon().Width());
 436   EXPECT_EQ(kIconHeight, notification.icon().Height());
 437 }