chrome/browser/notifications/notification_browsertest.cc

   1 // Copyright (c) 2012 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 <deque>
   6 #include <string>
   7
   8 #include "base/bind.h"
   9 #include "base/callback.h"
  10 #include "base/command_line.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/test/simple_test_clock.h"
  17 #include "base/time/clock.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #include "chrome/browser/infobars/infobar_service.h"
  21 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
  22 #include "chrome/browser/notifications/notification.h"
  23 #include "chrome/browser/profiles/profile.h"
  24 #include "chrome/browser/ui/browser.h"
  25 #include "chrome/browser/ui/browser_tabstrip.h"
  26 #include "chrome/browser/ui/browser_window.h"
  27 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  28 #include "chrome/test/base/in_process_browser_test.h"
  29 #include "chrome/test/base/ui_test_utils.h"
  30 #include "components/content_settings/core/browser/host_content_settings_map.h"
  31 #include "components/content_settings/core/common/content_settings.h"
  32 #include "components/content_settings/core/common/content_settings_pattern.h"
  33 #include "components/infobars/core/confirm_infobar_delegate.h"
  34 #include "components/infobars/core/infobar.h"
  35 #include "content/public/browser/notification_service.h"
  36 #include "content/public/browser/notification_source.h"
  37 #include "content/public/browser/notification_types.h"
  38 #include "content/public/browser/render_view_host.h"
  39 #include "content/public/browser/web_contents.h"
  40 #include "content/public/test/browser_test_utils.h"
  41 #include "content/public/test/test_utils.h"
  42 #include "net/base/net_util.h"
  43 #include "net/test/embedded_test_server/embedded_test_server.h"
  44 #include "testing/gtest/include/gtest/gtest.h"
  45 #include "ui/base/window_open_disposition.h"
  46 #include "ui/message_center/message_center.h"
  47 #include "ui/message_center/message_center_observer.h"
  48 #include "url/gurl.h"
  49
  50 namespace {
  51
  52 const char kExpectedIconUrl[] = "/notifications/no_such_file.png";
  53
  54 enum InfobarAction {
  55   DISMISS = 0,
  56   ALLOW,
  57   DENY,
  58 };
  59
  60 class NotificationChangeObserver {
  61 public:
  62   virtual ~NotificationChangeObserver() {}
  63   virtual bool Wait() = 0;
  64 };
  65
  66 class MessageCenterChangeObserver
  67     : public message_center::MessageCenterObserver,
  68       public NotificationChangeObserver {
  69  public:
  70   MessageCenterChangeObserver()
  71       : notification_received_(false) {
  72     message_center::MessageCenter::Get()->AddObserver(this);
  73   }
  74
  75   ~MessageCenterChangeObserver() override {
  76     message_center::MessageCenter::Get()->RemoveObserver(this);
  77   }
  78
  79   // NotificationChangeObserver:
  80   bool Wait() override {
  81     if (notification_received_)
  82       return true;
  83
  84     message_loop_runner_ = new content::MessageLoopRunner;
  85     message_loop_runner_->Run();
  86     return notification_received_;
  87   }
  88
  89   // message_center::MessageCenterObserver:
  90   void OnNotificationAdded(const std::string& notification_id) override {
  91     OnMessageCenterChanged();
  92   }
  93
  94   void OnNotificationRemoved(const std::string& notification_id,
  95                              bool by_user) override {
  96     OnMessageCenterChanged();
  97   }
  98
  99   void OnNotificationUpdated(const std::string& notification_id) override {
 100     OnMessageCenterChanged();
 101   }
 102
 103   void OnMessageCenterChanged() {
 104     notification_received_ = true;
 105     if (message_loop_runner_.get())
 106       message_loop_runner_->Quit();
 107   }
 108
 109   bool notification_received_;
 110   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(MessageCenterChangeObserver);
 113 };
 114
 115 }  // namespace
 116
 117 class NotificationsTest : public InProcessBrowserTest {
 118  public:
 119   NotificationsTest() {}
 120
 121  protected:
 122   int GetNotificationCount();
 123   int GetNotificationPopupCount();
 124
 125   void CloseBrowserWindow(Browser* browser);
 126   void CrashTab(Browser* browser, int index);
 127
 128   void DenyOrigin(const GURL& origin);
 129   void AllowOrigin(const GURL& origin);
 130   void AllowAllOrigins();
 131   void SetDefaultContentSetting(ContentSetting setting);
 132
 133   void VerifyInfoBar(const Browser* browser, int index);
 134   std::string CreateNotification(Browser* browser,
 135                                  bool wait_for_new_balloon,
 136                                  const char* icon,
 137                                  const char* title,
 138                                  const char* body,
 139                                  const char* replace_id);
 140   std::string CreateSimpleNotification(Browser* browser,
 141                                        bool wait_for_new_balloon);
 142   bool RequestPermissionAndWait(Browser* browser);
 143   bool CancelNotification(const char* notification_id, Browser* browser);
 144   bool PerformActionOnInfoBar(Browser* browser,
 145                               InfobarAction action,
 146                               size_t infobar_index,
 147                               int tab_index);
 148   void GetPrefsByContentSetting(ContentSetting setting,
 149                                 ContentSettingsForOneType* settings);
 150   bool CheckOriginInSetting(const ContentSettingsForOneType& settings,
 151                             const GURL& origin);
 152
 153   GURL GetTestPageURLForFile(const std::string& file) const {
 154     return embedded_test_server()->GetURL(
 155       std::string("/notifications/") + file);
 156   }
 157
 158   GURL GetTestPageURL() const {
 159     return GetTestPageURLForFile("notification_tester.html");
 160   }
 161
 162  private:
 163   void DropOriginPreference(const GURL& origin);
 164 };
 165
 166 int NotificationsTest::GetNotificationCount() {
 167   return message_center::MessageCenter::Get()->NotificationCount();
 168 }
 169
 170 int NotificationsTest::GetNotificationPopupCount() {
 171   return message_center::MessageCenter::Get()->GetPopupNotifications().size();
 172 }
 173
 174 void NotificationsTest::CloseBrowserWindow(Browser* browser) {
 175   content::WindowedNotificationObserver observer(
 176       chrome::NOTIFICATION_BROWSER_CLOSED,
 177       content::Source<Browser>(browser));
 178   browser->window()->Close();
 179   observer.Wait();
 180 }
 181
 182 void NotificationsTest::CrashTab(Browser* browser, int index) {
 183   content::CrashTab(browser->tab_strip_model()->GetWebContentsAt(index));
 184 }
 185
 186 void NotificationsTest::DenyOrigin(const GURL& origin) {
 187   DropOriginPreference(origin);
 188   DesktopNotificationProfileUtil::DenyPermission(browser()->profile(), origin);
 189 }
 190
 191 void NotificationsTest::AllowOrigin(const GURL& origin) {
 192   DropOriginPreference(origin);
 193   DesktopNotificationProfileUtil::GrantPermission(browser()->profile(), origin);
 194 }
 195
 196 void NotificationsTest::AllowAllOrigins() {
 197   // Reset all origins
 198   browser()->profile()->GetHostContentSettingsMap()->ClearSettingsForOneType(
 199        CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 200   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
 201  }
 202
 203 void NotificationsTest::SetDefaultContentSetting(ContentSetting setting) {
 204   browser()->profile()->GetHostContentSettingsMap()->SetDefaultContentSetting(
 205       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
 206 }
 207
 208 void NotificationsTest::VerifyInfoBar(const Browser* browser, int index) {
 209   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 210       browser->tab_strip_model()->GetWebContentsAt(index));
 211
 212   ASSERT_EQ(1U, infobar_service->infobar_count());
 213   ConfirmInfoBarDelegate* confirm_infobar =
 214       infobar_service->infobar_at(0)->delegate()->AsConfirmInfoBarDelegate();
 215   ASSERT_TRUE(confirm_infobar);
 216   int buttons = confirm_infobar->GetButtons();
 217   EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_OK);
 218   EXPECT_TRUE(buttons & ConfirmInfoBarDelegate::BUTTON_CANCEL);
 219 }
 220
 221 std::string NotificationsTest::CreateNotification(
 222     Browser* browser,
 223     bool wait_for_new_balloon,
 224     const char* icon,
 225     const char* title,
 226     const char* body,
 227     const char* replace_id) {
 228   std::string script = base::StringPrintf(
 229       "createNotification('%s', '%s', '%s', '%s');",
 230       icon, title, body, replace_id);
 231
 232   MessageCenterChangeObserver observer;
 233   std::string result;
 234   bool success = content::ExecuteScriptAndExtractString(
 235       browser->tab_strip_model()->GetActiveWebContents(),
 236       script,
 237       &result);
 238   if (success && result != "-1" && wait_for_new_balloon)
 239     success = observer.Wait();
 240   EXPECT_TRUE(success);
 241
 242   return result;
 243 }
 244
 245 std::string NotificationsTest::CreateSimpleNotification(
 246     Browser* browser,
 247     bool wait_for_new_balloon) {
 248   return CreateNotification(
 249       browser, wait_for_new_balloon,
 250       "no_such_file.png", "My Title", "My Body", "");
 251 }
 252
 253 bool NotificationsTest::RequestPermissionAndWait(Browser* browser) {
 254   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 255       browser->tab_strip_model()->GetActiveWebContents());
 256   content::WindowedNotificationObserver observer(
 257       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
 258       content::Source<InfoBarService>(infobar_service));
 259   std::string result;
 260   bool success = content::ExecuteScriptAndExtractString(
 261       browser->tab_strip_model()->GetActiveWebContents(),
 262       "requestPermission();",
 263       &result);
 264   if (!success || result != "1")
 265     return false;
 266   observer.Wait();
 267   return true;
 268 }
 269
 270 bool NotificationsTest::CancelNotification(
 271     const char* notification_id,
 272     Browser* browser) {
 273   std::string script = base::StringPrintf(
 274       "cancelNotification('%s');",
 275       notification_id);
 276
 277   MessageCenterChangeObserver observer;
 278   std::string result;
 279   bool success = content::ExecuteScriptAndExtractString(
 280       browser->tab_strip_model()->GetActiveWebContents(),
 281       script,
 282       &result);
 283   if (!success || result != "1")
 284     return false;
 285   return observer.Wait();
 286 }
 287
 288 bool NotificationsTest::PerformActionOnInfoBar(
 289     Browser* browser,
 290     InfobarAction action,
 291     size_t infobar_index,
 292     int tab_index) {
 293   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 294       browser->tab_strip_model()->GetWebContentsAt(tab_index));
 295   if (infobar_index >= infobar_service->infobar_count()) {
 296     ADD_FAILURE();
 297     return false;
 298   }
 299
 300   infobars::InfoBar* infobar = infobar_service->infobar_at(infobar_index);
 301   infobars::InfoBarDelegate* infobar_delegate = infobar->delegate();
 302   switch (action) {
 303     case DISMISS:
 304       infobar_delegate->InfoBarDismissed();
 305       infobar_service->RemoveInfoBar(infobar);
 306       return true;
 307
 308     case ALLOW: {
 309       ConfirmInfoBarDelegate* confirm_infobar_delegate =
 310           infobar_delegate->AsConfirmInfoBarDelegate();
 311       if (!confirm_infobar_delegate) {
 312         ADD_FAILURE();
 313       } else if (confirm_infobar_delegate->Accept()) {
 314         infobar_service->RemoveInfoBar(infobar);
 315         return true;
 316       }
 317     }
 318
 319     case DENY: {
 320       ConfirmInfoBarDelegate* confirm_infobar_delegate =
 321           infobar_delegate->AsConfirmInfoBarDelegate();
 322       if (!confirm_infobar_delegate) {
 323         ADD_FAILURE();
 324       } else if (confirm_infobar_delegate->Cancel()) {
 325         infobar_service->RemoveInfoBar(infobar);
 326         return true;
 327       }
 328     }
 329   }
 330
 331   return false;
 332 }
 333
 334 void NotificationsTest::GetPrefsByContentSetting(
 335     ContentSetting setting,
 336     ContentSettingsForOneType* settings) {
 337   DesktopNotificationProfileUtil::GetNotificationsSettings(
 338       browser()->profile(), settings);
 339   for (ContentSettingsForOneType::iterator it = settings->begin();
 340        it != settings->end(); ) {
 341     if (it->setting != setting || it->source.compare("preference") != 0)
 342       it = settings->erase(it);
 343     else
 344       ++it;
 345   }
 346 }
 347
 348 bool NotificationsTest::CheckOriginInSetting(
 349     const ContentSettingsForOneType& settings,
 350     const GURL& origin) {
 351   ContentSettingsPattern pattern =
 352       ContentSettingsPattern::FromURLNoWildcard(origin);
 353   for (ContentSettingsForOneType::const_iterator it = settings.begin();
 354        it != settings.end(); ++it) {
 355     if (it->primary_pattern == pattern)
 356       return true;
 357   }
 358   return false;
 359 }
 360
 361 void NotificationsTest::DropOriginPreference(const GURL& origin) {
 362   DesktopNotificationProfileUtil::ClearSetting(browser()->profile(),
 363       ContentSettingsPattern::FromURLNoWildcard(origin));
 364 }
 365
 366 // If this flakes, use http://crbug.com/62311 and http://crbug.com/74428.
 367 // Flaky on Windows: http://crbug.com/437414.
 368 #if defined(OS_WIN)
 369 #define MAYBE_TestUserGestureInfobar DISABLED_TestUserGestureInfobar
 370 #else
 371 #define MAYBE_TestUserGestureInfobar TestUserGestureInfobar
 372 #endif
 373
 374 IN_PROC_BROWSER_TEST_F(NotificationsTest, MAYBE_TestUserGestureInfobar) {
 375   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 376
 377   ui_test_utils::NavigateToURL(
 378       browser(),
 379       embedded_test_server()->GetURL(
 380           "/notifications/notifications_request_function.html"));
 381
 382   // Request permission by calling request() while eval'ing an inline script;
 383   // That's considered a user gesture to webkit, and should produce an infobar.
 384   bool result;
 385   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 386       browser()->tab_strip_model()->GetActiveWebContents(),
 387       "window.domAutomationController.send(request());",
 388       &result));
 389   EXPECT_TRUE(result);
 390
 391   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 392       browser()->tab_strip_model()->GetWebContentsAt(0));
 393   EXPECT_EQ(1U, infobar_service->infobar_count());
 394 }
 395
 396 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCreateSimpleNotification) {
 397   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 398
 399   // Creates a simple notification.
 400   AllowAllOrigins();
 401   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 402
 403   std::string result = CreateSimpleNotification(browser(), true);
 404   EXPECT_NE("-1", result);
 405
 406   GURL EXPECTED_ICON_URL = embedded_test_server()->GetURL(kExpectedIconUrl);
 407   ASSERT_EQ(1, GetNotificationCount());
 408   message_center::NotificationList::Notifications notifications =
 409       message_center::MessageCenter::Get()->GetVisibleNotifications();
 410   EXPECT_EQ(base::ASCIIToUTF16("My Title"),
 411             (*notifications.rbegin())->title());
 412   EXPECT_EQ(base::ASCIIToUTF16("My Body"),
 413             (*notifications.rbegin())->message());
 414 }
 415
 416 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseNotification) {
 417   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 418
 419   // Creates a notification and closes it.
 420   AllowAllOrigins();
 421   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 422
 423   std::string result = CreateSimpleNotification(browser(), true);
 424   EXPECT_NE("-1", result);
 425   ASSERT_EQ(1, GetNotificationCount());
 426
 427   message_center::NotificationList::Notifications notifications =
 428       message_center::MessageCenter::Get()->GetVisibleNotifications();
 429   message_center::MessageCenter::Get()->RemoveNotification(
 430       (*notifications.rbegin())->id(),
 431       true);  // by_user
 432
 433   ASSERT_EQ(0, GetNotificationCount());
 434 }
 435
 436 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCancelNotification) {
 437   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 438
 439   // Creates a notification and cancels it in the origin page.
 440   AllowAllOrigins();
 441   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 442
 443   std::string note_id = CreateSimpleNotification(browser(), true);
 444   EXPECT_NE(note_id, "-1");
 445
 446   ASSERT_EQ(1, GetNotificationCount());
 447   ASSERT_TRUE(CancelNotification(note_id.c_str(), browser()));
 448   ASSERT_EQ(0, GetNotificationCount());
 449 }
 450
 451 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestPermissionInfobarAppears) {
 452   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 453
 454   // Requests notification privileges and verifies the infobar appears.
 455   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 456   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 457
 458   ASSERT_EQ(0, GetNotificationCount());
 459   ASSERT_NO_FATAL_FAILURE(VerifyInfoBar(browser(), 0));
 460 }
 461
 462 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowOnPermissionInfobar) {
 463   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 464
 465   // Tries to create a notification and clicks allow on the infobar.
 466   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 467   // This notification should not be shown because we do not have permission.
 468   CreateSimpleNotification(browser(), false);
 469   ASSERT_EQ(0, GetNotificationCount());
 470
 471   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 472   ASSERT_TRUE(PerformActionOnInfoBar(browser(), ALLOW, 0, 0));
 473
 474   CreateSimpleNotification(browser(), true);
 475   EXPECT_EQ(1, GetNotificationCount());
 476 }
 477
 478 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyOnPermissionInfobar) {
 479   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 480
 481   // Test that no notification is created
 482   // when Deny is chosen from permission infobar.
 483   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 484   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 485   PerformActionOnInfoBar(browser(), DENY, 0, 0);
 486   CreateSimpleNotification(browser(), false);
 487   ASSERT_EQ(0, GetNotificationCount());
 488   ContentSettingsForOneType settings;
 489   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
 490   EXPECT_TRUE(CheckOriginInSetting(settings, GetTestPageURL()));
 491 }
 492
 493 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestClosePermissionInfobar) {
 494   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 495
 496   // Test that no notification is created when permission infobar is dismissed.
 497   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 498   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 499   PerformActionOnInfoBar(browser(), DISMISS, 0, 0);
 500   CreateSimpleNotification(browser(), false);
 501   ASSERT_EQ(0, GetNotificationCount());
 502   ContentSettingsForOneType settings;
 503   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
 504   EXPECT_EQ(0U, settings.size());
 505 }
 506
 507 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowNotificationsFromAllSites) {
 508   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 509
 510   // Verify that all domains can be allowed to show notifications.
 511   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
 512   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 513
 514   std::string result = CreateSimpleNotification(browser(), true);
 515   EXPECT_NE("-1", result);
 516
 517   ASSERT_EQ(1, GetNotificationCount());
 518   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 519       browser()->tab_strip_model()->GetWebContentsAt(0));
 520   EXPECT_EQ(0U, infobar_service->infobar_count());
 521 }
 522
 523 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyNotificationsFromAllSites) {
 524   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 525
 526   // Verify that no domain can show notifications.
 527   SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
 528   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 529
 530   std::string result = CreateSimpleNotification(browser(), false);
 531   EXPECT_EQ("-1", result);
 532
 533   ASSERT_EQ(0, GetNotificationCount());
 534 }
 535
 536 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyDomainAndAllowAll) {
 537   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 538
 539   // Verify that denying a domain and allowing all shouldn't show
 540   // notifications from the denied domain.
 541   DenyOrigin(GetTestPageURL().GetOrigin());
 542   SetDefaultContentSetting(CONTENT_SETTING_ALLOW);
 543
 544   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 545
 546   std::string result = CreateSimpleNotification(browser(), false);
 547   EXPECT_EQ("-1", result);
 548
 549   ASSERT_EQ(0, GetNotificationCount());
 550 }
 551
 552 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestAllowDomainAndDenyAll) {
 553   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 554
 555   // Verify that allowing a domain and denying all others should show
 556   // notifications from the allowed domain.
 557   AllowOrigin(GetTestPageURL().GetOrigin());
 558   SetDefaultContentSetting(CONTENT_SETTING_BLOCK);
 559
 560   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 561
 562   std::string result = CreateSimpleNotification(browser(), true);
 563   EXPECT_NE("-1", result);
 564
 565   ASSERT_EQ(1, GetNotificationCount());
 566 }
 567
 568 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestDenyAndThenAllowDomain) {
 569   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 570
 571   // Verify that denying and again allowing should show notifications.
 572   DenyOrigin(GetTestPageURL().GetOrigin());
 573
 574   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 575
 576   std::string result = CreateSimpleNotification(browser(), false);
 577   EXPECT_EQ("-1", result);
 578
 579   ASSERT_EQ(0, GetNotificationCount());
 580
 581   AllowOrigin(GetTestPageURL().GetOrigin());
 582   result = CreateSimpleNotification(browser(), true);
 583   EXPECT_NE("-1", result);
 584
 585   ASSERT_EQ(1, GetNotificationCount());
 586   InfoBarService* infobar_service = InfoBarService::FromWebContents(
 587       browser()->tab_strip_model()->GetWebContentsAt(0));
 588   EXPECT_EQ(0U, infobar_service->infobar_count());
 589 }
 590
 591 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCreateDenyCloseNotifications) {
 592   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 593
 594   // Verify able to create, deny, and close the notification.
 595   AllowAllOrigins();
 596   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 597   CreateSimpleNotification(browser(), true);
 598   ASSERT_EQ(1, GetNotificationCount());
 599
 600   DenyOrigin(GetTestPageURL().GetOrigin());
 601   ContentSettingsForOneType settings;
 602   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
 603   ASSERT_TRUE(CheckOriginInSetting(settings, GetTestPageURL().GetOrigin()));
 604
 605   EXPECT_EQ(1, GetNotificationCount());
 606   message_center::NotificationList::Notifications notifications =
 607       message_center::MessageCenter::Get()->GetVisibleNotifications();
 608   message_center::MessageCenter::Get()->RemoveNotification(
 609       (*notifications.rbegin())->id(),
 610       true);  // by_user
 611   ASSERT_EQ(0, GetNotificationCount());
 612 }
 613
 614 // Crashes on Linux/Win. See http://crbug.com/160657.
 615 IN_PROC_BROWSER_TEST_F(
 616     NotificationsTest,
 617     DISABLED_TestOriginPrefsNotSavedInIncognito) {
 618   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 619
 620   // Verify that allow/deny origin preferences are not saved in incognito.
 621   Browser* incognito = CreateIncognitoBrowser();
 622   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
 623   ASSERT_TRUE(RequestPermissionAndWait(incognito));
 624   PerformActionOnInfoBar(incognito, DENY, 0, 0);
 625   CloseBrowserWindow(incognito);
 626
 627   incognito = CreateIncognitoBrowser();
 628   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
 629   ASSERT_TRUE(RequestPermissionAndWait(incognito));
 630   PerformActionOnInfoBar(incognito, ALLOW, 0, 0);
 631   CreateSimpleNotification(incognito, true);
 632   ASSERT_EQ(1, GetNotificationCount());
 633   CloseBrowserWindow(incognito);
 634
 635   incognito = CreateIncognitoBrowser();
 636   ui_test_utils::NavigateToURL(incognito, GetTestPageURL());
 637   ASSERT_TRUE(RequestPermissionAndWait(incognito));
 638
 639   ContentSettingsForOneType settings;
 640   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
 641   EXPECT_EQ(0U, settings.size());
 642   GetPrefsByContentSetting(CONTENT_SETTING_ALLOW, &settings);
 643   EXPECT_EQ(0U, settings.size());
 644 }
 645
 646 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestExitBrowserWithInfobar) {
 647   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 648
 649   // Exit the browser window, when the infobar appears.
 650   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 651   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 652 }
 653
 654 // Times out on Windows and Linux. http://crbug.com/168976
 655 #if defined(OS_WIN) || defined(OS_LINUX)
 656 #define MAYBE_TestCrashTabWithPermissionInfobar \
 657     DISABLED_TestCrashTabWithPermissionInfobar
 658 #else
 659 #define MAYBE_TestCrashTabWithPermissionInfobar \
 660     TestCrashTabWithPermissionInfobar
 661 #endif
 662 IN_PROC_BROWSER_TEST_F(NotificationsTest,
 663                        MAYBE_TestCrashTabWithPermissionInfobar) {
 664   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 665
 666   // Test crashing the tab with permission infobar doesn't crash Chrome.
 667   ui_test_utils::NavigateToURLWithDisposition(
 668       browser(),
 669       embedded_test_server()->GetURL("/empty.html"),
 670       NEW_BACKGROUND_TAB,
 671       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 672   browser()->tab_strip_model()->ActivateTabAt(0, true);
 673   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 674   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 675   CrashTab(browser(), 0);
 676 }
 677
 678 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestIncognitoNotification) {
 679   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 680
 681   // Test notifications in incognito window.
 682   Browser* browser = CreateIncognitoBrowser();
 683   ui_test_utils::NavigateToURL(browser, GetTestPageURL());
 684   browser->tab_strip_model()->ActivateTabAt(0, true);
 685   ASSERT_TRUE(RequestPermissionAndWait(browser));
 686   PerformActionOnInfoBar(browser, ALLOW, 0, 0);
 687   CreateSimpleNotification(browser, true);
 688   ASSERT_EQ(1, GetNotificationCount());
 689 }
 690
 691 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseTabWithPermissionInfobar) {
 692   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 693
 694   // Test that user can close tab when infobar present.
 695   ui_test_utils::NavigateToURLWithDisposition(
 696       browser(),
 697       GURL("about:blank"),
 698       NEW_BACKGROUND_TAB,
 699       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 700   browser()->tab_strip_model()->ActivateTabAt(0, true);
 701   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 702   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 703   content::WebContentsDestroyedWatcher destroyed_watcher(
 704       browser()->tab_strip_model()->GetWebContentsAt(0));
 705   browser()->tab_strip_model()->CloseWebContentsAt(0,
 706                                                    TabStripModel::CLOSE_NONE);
 707   destroyed_watcher.Wait();
 708 }
 709
 710 IN_PROC_BROWSER_TEST_F(
 711     NotificationsTest,
 712     TestNavigateAwayWithPermissionInfobar) {
 713   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 714
 715   // Test navigating away when an infobar is present,
 716   // then trying to create a notification from the same page.
 717   ui_test_utils::NavigateToURLWithDisposition(
 718       browser(),
 719       GURL("about:blank"),
 720       NEW_BACKGROUND_TAB,
 721       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 722   browser()->tab_strip_model()->ActivateTabAt(0, true);
 723   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 724   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 725   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 726   ASSERT_TRUE(RequestPermissionAndWait(browser()));
 727   PerformActionOnInfoBar(browser(), ALLOW, 0, 0);
 728   CreateSimpleNotification(browser(), true);
 729   ASSERT_EQ(1, GetNotificationCount());
 730 }
 731
 732 // See crbug.com/248470
 733 #if defined(OS_LINUX)
 734 #define MAYBE_TestCrashRendererNotificationRemain \
 735     DISABLED_TestCrashRendererNotificationRemain
 736 #else
 737 #define MAYBE_TestCrashRendererNotificationRemain \
 738     TestCrashRendererNotificationRemain
 739 #endif
 740
 741 IN_PROC_BROWSER_TEST_F(NotificationsTest,
 742                        MAYBE_TestCrashRendererNotificationRemain) {
 743   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 744
 745   // Test crashing renderer does not close or crash notification.
 746   AllowAllOrigins();
 747   ui_test_utils::NavigateToURLWithDisposition(
 748       browser(),
 749       GURL("about:blank"),
 750       NEW_BACKGROUND_TAB,
 751       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
 752   browser()->tab_strip_model()->ActivateTabAt(0, true);
 753   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 754   CreateSimpleNotification(browser(), true);
 755   ASSERT_EQ(1, GetNotificationCount());
 756   CrashTab(browser(), 0);
 757   ASSERT_EQ(1, GetNotificationCount());
 758 }
 759
 760 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationReplacement) {
 761   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 762
 763   // Test that we can replace a notification using the replaceId.
 764   AllowAllOrigins();
 765
 766   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 767
 768   std::string result = CreateNotification(
 769       browser(), true, "abc.png", "Title1", "Body1", "chat");
 770   EXPECT_NE("-1", result);
 771
 772   ASSERT_EQ(1, GetNotificationCount());
 773
 774   result = CreateNotification(
 775       browser(), false, "no_such_file.png", "Title2", "Body2", "chat");
 776   EXPECT_NE("-1", result);
 777
 778   ASSERT_EQ(1, GetNotificationCount());
 779   message_center::NotificationList::Notifications notifications =
 780       message_center::MessageCenter::Get()->GetVisibleNotifications();
 781   EXPECT_EQ(base::ASCIIToUTF16("Title2"), (*notifications.rbegin())->title());
 782   EXPECT_EQ(base::ASCIIToUTF16("Body2"),
 783             (*notifications.rbegin())->message());
 784 }
 785
 786 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestLastUsage) {
 787   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 788
 789   HostContentSettingsMap* settings_map =
 790       browser()->profile()->GetHostContentSettingsMap();
 791   base::SimpleTestClock* clock = new base::SimpleTestClock();
 792   settings_map->SetPrefClockForTesting(scoped_ptr<base::Clock>(clock));
 793   clock->SetNow(base::Time::UnixEpoch() + base::TimeDelta::FromSeconds(10));
 794
 795   // Creates a simple notification.
 796   AllowAllOrigins();
 797   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 798
 799   std::string result = CreateSimpleNotification(browser(), true);
 800   EXPECT_NE("-1", result);
 801
 802   EXPECT_EQ(settings_map->GetLastUsage(GetTestPageURL().GetOrigin(),
 803                                        GetTestPageURL().GetOrigin(),
 804                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
 805                 .ToDoubleT(),
 806             10);
 807
 808   clock->Advance(base::TimeDelta::FromSeconds(3));
 809
 810   result = CreateSimpleNotification(browser(), true);
 811   EXPECT_NE("-1", result);
 812
 813   EXPECT_EQ(settings_map->GetLastUsage(GetTestPageURL().GetOrigin(),
 814                                        GetTestPageURL().GetOrigin(),
 815                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
 816                 .ToDoubleT(),
 817             13);
 818 }
 819
 820 IN_PROC_BROWSER_TEST_F(NotificationsTest,
 821                        TestNotificationReplacementReappearance) {
 822   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 823
 824   // Test that we can replace a notification using the tag, and that it will
 825   // cause the notification to reappear as a popup again.
 826   AllowAllOrigins();
 827
 828   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 829
 830   ASSERT_EQ(0, GetNotificationPopupCount());
 831
 832   std::string result = CreateNotification(
 833       browser(), true, "abc.png", "Title1", "Body1", "chat");
 834   EXPECT_NE("-1", result);
 835
 836   ASSERT_EQ(1, GetNotificationPopupCount());
 837
 838   message_center::NotificationList::Notifications notifications =
 839       message_center::MessageCenter::Get()->GetVisibleNotifications();
 840   message_center::MessageCenter::Get()->ClickOnNotification(
 841       (*notifications.rbegin())->id());
 842
 843   ASSERT_EQ(0, GetNotificationPopupCount());
 844
 845   result = CreateNotification(
 846       browser(), true, "abc.png", "Title2", "Body2", "chat");
 847   EXPECT_NE("-1", result);
 848
 849   ASSERT_EQ(1, GetNotificationPopupCount());
 850 }
 851
 852 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationValidIcon) {
 853   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 854   AllowAllOrigins();
 855
 856   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 857   ASSERT_EQ(0, GetNotificationPopupCount());
 858
 859   std::string result = CreateNotification(
 860       browser(), true, "icon.png", "Title1", "Body1", "chat");
 861   EXPECT_NE("-1", result);
 862
 863   message_center::NotificationList::PopupNotifications notifications =
 864       message_center::MessageCenter::Get()->GetPopupNotifications();
 865   ASSERT_EQ(1u, notifications.size());
 866
 867   auto* notification = *notifications.rbegin();
 868
 869   EXPECT_EQ(100, notification->icon().Width());
 870   EXPECT_EQ(100, notification->icon().Height());
 871 }
 872
 873 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationInvalidIcon) {
 874   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 875   AllowAllOrigins();
 876
 877   ui_test_utils::NavigateToURL(browser(), GetTestPageURL());
 878   ASSERT_EQ(0, GetNotificationPopupCount());
 879
 880   // Not supplying an icon URL.
 881   std::string result = CreateNotification(
 882       browser(), true, "", "Title1", "Body1", "chat");
 883   EXPECT_NE("-1", result);
 884
 885   message_center::NotificationList::PopupNotifications notifications =
 886       message_center::MessageCenter::Get()->GetPopupNotifications();
 887   ASSERT_EQ(1u, notifications.size());
 888
 889   auto* notification = *notifications.rbegin();
 890   EXPECT_TRUE(notification->icon().IsEmpty());
 891
 892   // Supplying an invalid icon URL.
 893   result = CreateNotification(
 894       browser(), true, "invalid.png", "Title1", "Body1", "chat");
 895   EXPECT_NE("-1", result);
 896
 897   notifications = message_center::MessageCenter::Get()->GetPopupNotifications();
 898   ASSERT_EQ(1u, notifications.size());
 899
 900   notification = *notifications.rbegin();
 901   EXPECT_TRUE(notification->icon().IsEmpty());
 902 }
 903
 904 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestNotificationDoubleClose) {
 905   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 906   AllowAllOrigins();
 907
 908   ui_test_utils::NavigateToURL(
 909       browser(), GetTestPageURLForFile("notification-double-close.html"));
 910   ASSERT_EQ(0, GetNotificationPopupCount());
 911
 912   std::string result = CreateNotification(
 913       browser(), true, "", "Title1", "Body1", "chat");
 914   EXPECT_NE("-1", result);
 915
 916   ASSERT_EQ(1, GetNotificationCount());
 917   message_center::NotificationList::Notifications notifications =
 918       message_center::MessageCenter::Get()->GetVisibleNotifications();
 919   message_center::MessageCenter::Get()->RemoveNotification(
 920       (*notifications.rbegin())->id(),
 921       true);  // by_user
 922
 923   ASSERT_EQ(0, GetNotificationCount());
 924
 925   // Calling WebContents::IsCrashed() will return FALSE here, even if the WC did
 926   // crash. Work around this timing issue by creating another notification,
 927   // which requires interaction with the renderer process.
 928   result = CreateNotification(browser(), true, "", "Title1", "Body1", "chat");
 929   EXPECT_NE("-1", result);
 930 }