[Mac] Delete old balloon and Notification Center notification implementations.

chrome/browser/notifications/desktop_notifications_unittest.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 "chrome/browser/notifications/desktop_notifications_unittest.h"
 
 #include "base/prefs/testing_pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/notifications/balloon_notification_ui_manager.h"
 #include "chrome/browser/notifications/fake_balloon_view.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "content/public/common/show_desktop_notification_params.h"
 #include "ui/base/ime/input_method_initializer.h"
 #include "ui/message_center/message_center.h"
 
-#if defined(USE_ASH)
-#include "ash/shell.h"
-#include "ash/test/test_shell_delegate.h"
-#include "ui/aura/env.h"
-#include "ui/aura/root_window.h"
-#include "ui/compositor/scoped_animation_duration_scale_mode.h"
+#if defined(RUN_MESSAGE_CENTER_TESTS)
+#include "chrome/browser/notifications/message_center_notification_manager.h"
+#include "chrome/browser/notifications/message_center_settings_controller.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #endif
 
-
 using content::BrowserThread;
 
 // static
-const int MockBalloonCollection::kMockBalloonSpace = 5;
+std::string DesktopNotificationsTest::log_output_;
+
+#if !defined(RUN_MESSAGE_CENTER_TESTS)
 
 // static
-std::string DesktopNotificationsTest::log_output_;
+const int MockBalloonCollection::kMockBalloonSpace = 5;
 
 MockBalloonCollection::MockBalloonCollection() {}
 
 MockBalloonCollection::~MockBalloonCollection() {}
 
 void MockBalloonCollection::Add(const Notification& notification,
                                 Profile* profile) {
   // Swap in a logging proxy for the purpose of logging calls that
   // would be made into javascript, then pass this down to the
   // balloon collection.
@@ skipping 38 matching lines @@
   int min = 0;
   std::deque<Balloon*>::iterator iter;
   for (iter = balloons_.begin(); iter != balloons_.end(); ++iter) {
     int pos = (*iter)->GetPosition().y();
     if (iter == balloons_.begin() || pos < min)
       min = pos;
   }
   return min;
 }
 
+#else
+
+class TestMessageCenterNotificationManager :
+    public MessageCenterNotificationManager {
+ public:
+  TestMessageCenterNotificationManager(
+      message_center::MessageCenter* message_center,
+      PrefService* local_state,
+      scoped_ptr<message_center::NotifierSettingsProvider> settings_provider)
+      : MessageCenterNotificationManager(message_center,
+                                         local_state,
+                                         settings_provider.Pass()) {
+  }
+  virtual ~TestMessageCenterNotificationManager() {}
+
+  virtual bool ShowNotification(const Notification& notification,
+                                Profile* profile) OVERRIDE {
+    // Swap in a logging proxy for the purpose of logging calls that
+    // would be made into javascript, then pass this down.
+    Notification test_notification(
+        notification.origin_url(),
+        notification.content_url(),
+        notification.display_source(),
+        notification.replace_id(),
+        new LoggingNotificationProxy(notification.notification_id()));
+    return MessageCenterNotificationManager::ShowNotification(
+        test_notification, profile);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestMessageCenterNotificationManager);
+};
+
+#endif  // !defined(RUN_MESSAGE_CENTER_TESTS)
+
 DesktopNotificationsTest::DesktopNotificationsTest()
-    : ui_thread_(BrowserThread::UI, &message_loop_) {
+    : ui_thread_(BrowserThread::UI, &message_loop_),
+      aura_test_helper_(&message_loop_) {
 }
 
 DesktopNotificationsTest::~DesktopNotificationsTest() {
 }
 
+// static
+void DesktopNotificationsTest::log(const std::string& message) {
+  log_output_.append(message);
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+      base::MessageLoop::current()->QuitClosure());
+}
+
 void DesktopNotificationsTest::SetUp() {
   ui::InitializeInputMethodForTesting();
-#if defined(USE_ASH)
-  ui::ScopedAnimationDurationScaleMode normal_duration_mode(
-      ui::ScopedAnimationDurationScaleMode::ZERO_DURATION);
+
+#if defined(USE_AURA)
+  aura_test_helper_.SetUp();
+#endif
+
+  chrome::RegisterLocalState(local_state_.registry());
+
+  profile_manager_.reset(
+      new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
+  ASSERT_TRUE(profile_manager_->SetUp());
+  profile_ = profile_manager_->CreateTestingProfile("notifications_test");
+
+#if defined(RUN_MESSAGE_CENTER_TESTS)
   // The message center is notmally initialized on |g_browser_process| which
   // is not created for these tests.
   message_center::MessageCenter::Initialize();
-  // MockBalloonCollection retrieves information about the screen on creation.
-  // So it is necessary to make sure the desktop gets created first.
-  ash::Shell::CreateInstance(new ash::test::TestShellDelegate);
+  scoped_ptr<message_center::NotifierSettingsProvider> settings_provider(
+      new MessageCenterSettingsController(
+          profile_manager_->profile_info_cache()));
+  ui_manager_.reset(
+      new TestMessageCenterNotificationManager(
+          message_center::MessageCenter::Get(), &local_state_,
+          settings_provider.Pass()));
+#else
+  BalloonNotificationUIManager* balloon_ui_manager =
+      new BalloonNotificationUIManager(&local_state_);
+  ui_manager_.reset(balloon_ui_manager);
+  balloon_collection_ = new MockBalloonCollection();
+  balloon_ui_manager->SetBalloonCollection(balloon_collection_);
 #endif
 
-  chrome::RegisterLocalState(local_state_.registry());
-  profile_.reset(new TestingProfile());
-  ui_manager_.reset(new BalloonNotificationUIManager(&local_state_));
-  balloon_collection_ = new MockBalloonCollection();
-  ui_manager_->SetBalloonCollection(balloon_collection_);
   service_.reset(new DesktopNotificationService(profile(), ui_manager_.get()));
   log_output_.clear();
 }
 
 void DesktopNotificationsTest::TearDown() {
-  service_.reset(NULL);
-  ui_manager_.reset(NULL);
-  profile_.reset(NULL);
-#if defined(USE_ASH)
-  ash::Shell::DeleteInstance();
-  // The message center is notmally shutdown on |g_browser_process| which
-  // is not created for these tests.
+  service_.reset();
+  ui_manager_.reset();
+  profile_ = NULL;
+  profile_manager_.reset();
+#if defined(RUN_MESSAGE_CENTER_TESTS)
   message_center::MessageCenter::Shutdown();
-  aura::Env::DeleteInstance();
+#endif
+#if defined(USE_AURA)
+  aura_test_helper_.TearDown();
 #endif
   ui::ShutdownInputMethodForTesting();
 }
 
+int DesktopNotificationsTest::GetNotificationCount() {
+#if defined(RUN_MESSAGE_CENTER_TESTS)
+  return message_center::MessageCenter::Get()->GetNotifications().size();
+#else
+  return balloon_collection_->count();
+#endif
+}
+
 content::ShowDesktopNotificationHostMsgParams
 DesktopNotificationsTest::StandardTestNotification() {
   content::ShowDesktopNotificationHostMsgParams params;
   params.notification_id = 0;
   params.origin = GURL("http://www.google.com");
   params.is_html = false;
   params.icon_url = GURL("/icon.png");
   params.title = ASCIIToUTF16("Title");
   params.body = ASCIIToUTF16("Text");
   params.direction = WebKit::WebTextDirectionDefault;
   return params;
 }
 
 TEST_F(DesktopNotificationsTest, TestShow) {
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   params.notification_id = 1;
 
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params, 0, 0, DesktopNotificationService::PageNotification));
-  base::MessageLoopForUI::current()->RunUntilIdle();
-  EXPECT_EQ(1, balloon_collection_->count());
+  base::MessageLoopForUI::current()->Run();
+  EXPECT_EQ(1, GetNotificationCount());
 
   content::ShowDesktopNotificationHostMsgParams params2;
   params2.origin = GURL("http://www.google.com");
   params2.is_html = true;
   params2.contents_url = GURL("http://www.google.com/notification.html");
   params2.notification_id = 2;
 
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params2, 0, 0, DesktopNotificationService::PageNotification));
-  base::MessageLoopForUI::current()->RunUntilIdle();
-  EXPECT_EQ(2, balloon_collection_->count());
+  base::MessageLoopForUI::current()->Run();
+  EXPECT_EQ(2, GetNotificationCount());
 
   EXPECT_EQ("notification displayed\n"
             "notification displayed\n",
             log_output_);
 }
 
+#if !defined(RUN_MESSAGE_CENTER_TESTS)
 TEST_F(DesktopNotificationsTest, TestClose) {
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   params.notification_id = 1;
 
   // Request a notification; should open a balloon.
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params, 0, 0, DesktopNotificationService::PageNotification));
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
   EXPECT_EQ(1, balloon_collection_->count());
 
   // Close all the open balloons.
   while (balloon_collection_->count() > 0) {
     (*(balloon_collection_->GetActiveBalloons().begin()))->OnClose(true);
   }
 
   EXPECT_EQ("notification displayed\n"
             "notification closed by user\n",
             log_output_);
 }
+#endif  // !defined(RUN_MESSAGE_CENTER_TESTS)
 
 TEST_F(DesktopNotificationsTest, TestCancel) {
   int process_id = 0;
   int route_id = 0;
   int notification_id = 1;
 
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   params.notification_id = notification_id;
 
   // Request a notification; should open a balloon.
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params, process_id, route_id,
       DesktopNotificationService::PageNotification));
-  base::MessageLoopForUI::current()->RunUntilIdle();
-  EXPECT_EQ(1, balloon_collection_->count());
+  base::MessageLoopForUI::current()->Run();
+  EXPECT_EQ(1, GetNotificationCount());
 
   // Cancel the same notification
   service_->CancelDesktopNotification(process_id,
                                       route_id,
                                       notification_id);
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
   // Verify that the balloon collection is now empty.
-  EXPECT_EQ(0, balloon_collection_->count());
+  EXPECT_EQ(0, GetNotificationCount());
 
   EXPECT_EQ("notification displayed\n"
             "notification closed by script\n",
             log_output_);
 }
 
-#if defined(OS_WIN) || defined(TOOLKIT_VIEWS)
+#if (defined(OS_WIN) || defined(TOOLKIT_VIEWS)) && \
+    !defined(RUN_MESSAGE_CENTER_TESTS)
 TEST_F(DesktopNotificationsTest, TestPositioning) {
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   std::string expected_log;
   // Create some toasts.  After each but the first, make sure there
   // is a minimum separation between the toasts.
   int last_top = 0;
   for (int id = 0; id <= 3; ++id) {
     params.notification_id = id;
     EXPECT_TRUE(service_->ShowDesktopNotification(
@@ skipping 48 matching lines @@
     }
   }
   EXPECT_EQ(expected_log, log_output_);
 }
 #endif
 
 TEST_F(DesktopNotificationsTest, TestCancelByProfile) {
   int process_id = 0;
   int route_id = 0;
 
-  TestingBrowserProcess* browser_process =
-      TestingBrowserProcess::GetGlobal();
-  TestingProfileManager profile_manager(browser_process);
-  ASSERT_TRUE(profile_manager.SetUp());
-
   TestingProfile* second_profile =
-      profile_manager.CreateTestingProfile("SecondTestingProfile");
+      profile_manager_->CreateTestingProfile("SecondTestingProfile");
 
   scoped_ptr<DesktopNotificationService> second_service(
       new DesktopNotificationService(second_profile, ui_manager_.get()));
 
   // Request lots of identical notifications.
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   params.notification_id = 1;
   // Notice that the first one is the only one that doesn't use
   // the second profile.
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params, process_id, route_id,
       DesktopNotificationService::PageNotification));
 
   // |kLotsOfToasts| must be large enough to trigger a resize of the underlying
   // std::deque while we're clearing it.
   const int kLotsOfToasts = 20;
   for (int id = 2; id <= kLotsOfToasts; ++id) {
     params.notification_id = id;
     EXPECT_TRUE(second_service->ShowDesktopNotification(
         params, process_id, route_id,
         DesktopNotificationService::PageNotification));
   }
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
 
   ui_manager_->CancelAllByProfile(second_profile);
 
   // Verify that the balloon collection only contains the single
   // notification from the first profile.
-  EXPECT_EQ(1, balloon_collection_->count());
+  EXPECT_EQ(1, GetNotificationCount());
 }
 
 TEST_F(DesktopNotificationsTest, TestCancelBySourceOrigin) {
   int process_id = 0;
   int route_id = 0;
 
   // Request lots of identical notifications.
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
 
@@ skipping 10 matching lines @@
 
   // |kLotsOfToasts| must be large enough to trigger a resize of the underlying
   // std::deque while we're clearing it.
   const int kLotsOfToasts = 20;
   for (int id = 2; id <= kLotsOfToasts; ++id) {
     odd_params.notification_id = id;
     EXPECT_TRUE(service_->ShowDesktopNotification(
         odd_params, process_id, route_id,
         DesktopNotificationService::PageNotification));
   }
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
 
   ui_manager_->CancelAllBySourceOrigin(odd_params.origin);
 
   // Verify that the balloon collection only contains the single
   // notification which is not from the canceled origin.
-  EXPECT_EQ(1, balloon_collection_->count());
+  EXPECT_EQ(1, GetNotificationCount());
 }
 
+#if !defined(RUN_MESSAGE_CENTER_TESTS)
 TEST_F(DesktopNotificationsTest, TestQueueing) {
   int process_id = 0;
   int route_id = 0;
 
   // Request lots of identical notifications.
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   const int kLotsOfToasts = 20;
   for (int id = 1; id <= kLotsOfToasts; ++id) {
     params.notification_id = id;
     EXPECT_TRUE(service_->ShowDesktopNotification(
         params, process_id, route_id,
         DesktopNotificationService::PageNotification));
   }
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
 
   // Build up an expected log of what should be happening.
   std::string expected_log;
   for (int i = 0; i < balloon_collection_->max_balloon_count(); ++i) {
     expected_log.append("notification displayed\n");
   }
 
   // The max number that our balloon collection can hold should be
   // shown.
   EXPECT_EQ(balloon_collection_->max_balloon_count(),
             balloon_collection_->count());
   EXPECT_EQ(expected_log, log_output_);
 
   // Cancel the notifications from the start; the balloon space should
   // remain full.
   {
     int id;
     for (id = 1;
          id <= kLotsOfToasts - balloon_collection_->max_balloon_count();
          ++id) {
       service_->CancelDesktopNotification(process_id, route_id, id);
-      base::MessageLoopForUI::current()->RunUntilIdle();
+      base::MessageLoopForUI::current()->Run();
       expected_log.append("notification closed by script\n");
       expected_log.append("notification displayed\n");
       EXPECT_EQ(balloon_collection_->max_balloon_count(),
                 balloon_collection_->count());
       EXPECT_EQ(expected_log, log_output_);
     }
 
     // Now cancel the rest.  It should empty the balloon space.
     for (; id <= kLotsOfToasts; ++id) {
       service_->CancelDesktopNotification(process_id, route_id, id);
       expected_log.append("notification closed by script\n");
-      base::MessageLoopForUI::current()->RunUntilIdle();
+      base::MessageLoopForUI::current()->Run();
       EXPECT_EQ(expected_log, log_output_);
     }
   }
 
   // Verify that the balloon collection is now empty.
   EXPECT_EQ(0, balloon_collection_->count());
 }
+#endif  // !defined(RUN_MESSAGE_CENTER_TESTS)
 
 TEST_F(DesktopNotificationsTest, TestEarlyDestruction) {
   // Create some toasts and then prematurely delete the notification service,
   // just to make sure nothing crashes/leaks.
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   for (int id = 0; id <= 3; ++id) {
     params.notification_id = id;
     EXPECT_TRUE(service_->ShowDesktopNotification(
         params, 0, 0, DesktopNotificationService::PageNotification));
   }
   service_.reset(NULL);
 }
 
+#if !defined(RUN_MESSAGE_CENTER_TESTS)
+
 TEST_F(DesktopNotificationsTest, TestUserInputEscaping) {
   // Create a test script with some HTML; assert that it doesn't get into the
   // data:// URL that's produced for the balloon.
   content::ShowDesktopNotificationHostMsgParams params =
       StandardTestNotification();
   params.title = ASCIIToUTF16("<script>window.alert('uh oh');</script>");
   params.body = ASCIIToUTF16("<i>this text is in italics</i>");
   params.notification_id = 1;
   EXPECT_TRUE(service_->ShowDesktopNotification(
       params, 0, 0, DesktopNotificationService::PageNotification));
 
-  base::MessageLoopForUI::current()->RunUntilIdle();
+  base::MessageLoopForUI::current()->Run();
   EXPECT_EQ(1, balloon_collection_->count());
   Balloon* balloon = (*balloon_collection_->balloons().begin());
   GURL data_url = balloon->notification().content_url();
   EXPECT_EQ(std::string::npos, data_url.spec().find("<script>"));
   EXPECT_EQ(std::string::npos, data_url.spec().find("<i>"));
   // URL-encoded versions of tags should also not be found.
   EXPECT_EQ(std::string::npos, data_url.spec().find("%3cscript%3e"));
   EXPECT_EQ(std::string::npos, data_url.spec().find("%3ci%3e"));
 }
 
@@ skipping 98 matching lines @@
   }
 
   // Now change the position to upper left.  Confirm that the X value for the
   // balloons gets smaller.
   local_state_.SetInteger(prefs::kDesktopNotificationPosition,
                           BalloonCollection::UPPER_LEFT);
 
   int current_x = (*balloons.begin())->GetPosition().x();
   EXPECT_LT(current_x, last_x);
 }
+
+#endif  // !defined(RUN_MESSAGE_CENTER_TESTS)