Remove ENABLE_MESSAGE_CENTER

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/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/confirm_infobar_delegate.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/notifications/balloon.h"
 #include "chrome/browser/notifications/balloon_collection.h"
@@ skipping 17 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/window_open_disposition.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/message_center_observer.h"
+#include "ui/message_center/message_center_switches.h"
+#include "ui/message_center/message_center_util.h"
 
 // TODO(kbr): remove: http://crbug.com/222296
 #if defined(OS_MACOSX)
 #import "base/mac/mac_util.h"
 #endif
 
-#if defined(ENABLE_MESSAGE_CENTER)
-#include "base/command_line.h"
-#include "ui/message_center/message_center.h"
-#include "ui/message_center/message_center_observer.h"
-#include "ui/message_center/message_center_switches.h"
-#endif
-
-// Mac implementation of message_center is incomplete. The code builds, but
-// the tests do not pass <http://crbug.com/179904>.
-#if defined(ENABLE_MESSAGE_CENTER) && !defined(OS_MACOSX)
-#define ENABLE_MESSAGE_CENTER_TESTING 1
-#else
-#define ENABLE_MESSAGE_CENTER_TESTING 0
-#endif
-
 namespace {
 
 const char kExpectedIconUrl[] = "files/notifications/no_such_file.png";
 
 enum InfobarAction {
   DISMISS = 0,
   ALLOW,
   DENY,
 };
 
-#if ENABLE_MESSAGE_CENTER_TESTING
+class NotificationChangeObserver {
+public:
+  virtual ~NotificationChangeObserver() {}
+  virtual bool Wait() = 0;
+};
+
 class MessageCenterChangeObserver
-    : public message_center::MessageCenterObserver {
+    : public message_center::MessageCenterObserver,
+      public NotificationChangeObserver {
  public:
   MessageCenterChangeObserver()
       : notification_received_(false) {
     message_center::MessageCenter::Get()->AddObserver(this);
   }
 
   virtual ~MessageCenterChangeObserver() {
     message_center::MessageCenter::Get()->RemoveObserver(this);
   }
 
-  bool Wait() {
+  // NotificationChangeObserver:
+  virtual bool Wait() OVERRIDE {
     if (notification_received_)
       return true;
 
     message_loop_runner_ = new content::MessageLoopRunner;
     message_loop_runner_->Run();
     return notification_received_;
   }
 
-  // overridden from message_center::MessageCenterObserver:
+  // message_center::MessageCenterObserver:
   virtual void OnNotificationAdded(
       const std::string& notification_id) OVERRIDE {
     OnMessageCenterChanged();
   }
+
   virtual void OnNotificationRemoved(const std::string& notification_id,
                                      bool by_user) OVERRIDE {
     OnMessageCenterChanged();
   }
+
   virtual void OnNotificationUpdated(
       const std::string& notification_id) OVERRIDE {
     OnMessageCenterChanged();
   }
 
   void OnMessageCenterChanged() {
     notification_received_ = true;
     if (message_loop_runner_)
       message_loop_runner_->Quit();
   }
 
   bool notification_received_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageCenterChangeObserver);
 };
 
-typedef MessageCenterChangeObserver NotificationChangeObserver;
-
-#else
-
-class NotificationBalloonChangeObserver : public content::NotificationObserver {
+class NotificationBalloonChangeObserver
+    : public content::NotificationObserver,
+      public NotificationChangeObserver {
  public:
   NotificationBalloonChangeObserver()
       : collection_(BalloonNotificationUIManager::GetInstanceForTesting()->
             balloon_collection()),
         collection_changed_(false),
         notification_received_(false),
         running_(false),
         done_(false) {
     registrar_.Add(this, chrome::NOTIFICATION_NOTIFY_BALLOON_CONNECTED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_NOTIFY_BALLOON_DISCONNECTED,
                    content::NotificationService::AllSources());
     collection_->set_on_collection_changed_callback(
         base::Bind(&NotificationBalloonChangeObserver::OnCollectionChanged,
                    base::Unretained(this)));
   }
 
   virtual ~NotificationBalloonChangeObserver() {
     collection_->set_on_collection_changed_callback(base::Closure());
   }
 
-  bool Wait() {
+  // NotificationChangeObserver:
+  virtual bool Wait() OVERRIDE {
     if (!Check()) {
       running_ = true;
       message_loop_runner_ = new content::MessageLoopRunner;
       message_loop_runner_->Run();
       EXPECT_TRUE(done_);
     }
     return done_;
   }
 
   bool Check() {
     if (done_)
       return true;
 
     if (collection_changed_ && notification_received_) {
       done_ = true;
       if (running_) {
         message_loop_runner_->Quit();
         running_ = false;
       }
     }
     return done_;
   }
 
   void OnCollectionChanged() {
     collection_changed_ = true;
     Check();
   }
 
-  // Overridden from content::NotificationObserver:
+  // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     DCHECK(type == chrome::NOTIFICATION_NOTIFY_BALLOON_DISCONNECTED ||
            type == chrome::NOTIFICATION_NOTIFY_BALLOON_CONNECTED);
     notification_received_ = true;
     Check();
   }
 
  private:
   content::NotificationRegistrar registrar_;
   BalloonCollection* collection_;
 
   bool collection_changed_;
   bool notification_received_;
   bool running_;
   bool done_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationBalloonChangeObserver);
 };
 
-typedef NotificationBalloonChangeObserver NotificationChangeObserver;
-
-#endif  // ENABLE_MESSAGE_CENTER
-
 }  // namespace
 
 class NotificationsTest : public InProcessBrowserTest {
  public:
   NotificationsTest() {}
 
  protected:
   // Overriden from InProcessBrowserTest:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
 
   int GetNotificationCount();
 
+  NotificationChangeObserver* CreateObserver();
+
   void CloseBrowserWindow(Browser* browser);
   void CrashTab(Browser* browser, int index);
-#if ENABLE_MESSAGE_CENTER_TESTING
-  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
-#else
   const std::deque<Balloon*>& GetActiveBalloons();
   void CrashNotification(Balloon* balloon);
   bool CloseNotificationAndWait(const Notification& notification);
-#endif
 
   void SetDefaultPermissionSetting(ContentSetting setting);
   void DenyOrigin(const GURL& origin);
   void AllowOrigin(const GURL& origin);
   void AllowAllOrigins();
 
   void VerifyInfobar(const Browser* browser, int index);
   std::string CreateNotification(Browser* browser,
                                  bool wait_for_new_balloon,
                                  const char* icon,
@@ skipping 24 matching lines @@
 void NotificationsTest::SetUpInProcessBrowserTestFixture() {
   InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
 
   ASSERT_TRUE(test_server()->Start());
   empty_page_url_ = test_server()->GetURL("files/empty.html");
   test_page_url_ = test_server()->GetURL(
       "files/notifications/notification_tester.html");
 }
 
 int NotificationsTest::GetNotificationCount() {
-#if ENABLE_MESSAGE_CENTER_TESTING
-  return message_center::MessageCenter::Get()->NotificationCount();
-#else
-  return BalloonNotificationUIManager::GetInstanceForTesting()->
-      balloon_collection()->GetActiveBalloons().size();
-#endif  // ENABLE_MESSAGE_CENTER_TESTING
+  if (message_center::IsRichNotificationEnabled()) {
+    return message_center::MessageCenter::Get()->NotificationCount();
+  } else {
+    return BalloonNotificationUIManager::GetInstanceForTesting()->
+           balloon_collection()->GetActiveBalloons().size();
+  }
+}
+
+NotificationChangeObserver* NotificationsTest::CreateObserver() {
+  if (message_center::IsRichNotificationEnabled())
+    return new MessageCenterChangeObserver();
+  else
+    return new NotificationBalloonChangeObserver();
 }
 
 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));
 }
 
-#if ENABLE_MESSAGE_CENTER_TESTING
-// Overriden from InProcessBrowserTest:
-void NotificationsTest::SetUpCommandLine(CommandLine* command_line) {
-  InProcessBrowserTest::SetUpCommandLine(command_line);
-  command_line->AppendSwitch(
-      message_center::switches::kEnableRichNotifications);
-}
-#else
-
 const std::deque<Balloon*>& NotificationsTest::GetActiveBalloons() {
   return BalloonNotificationUIManager::GetInstanceForTesting()->
       balloon_collection()->GetActiveBalloons();
 }
 
 void NotificationsTest::CrashNotification(Balloon* balloon) {
   content::CrashTab(balloon->balloon_view()->GetHost()->web_contents());
 }
 
 bool NotificationsTest::CloseNotificationAndWait(
     const Notification& notification) {
-  NotificationChangeObserver observer;
+  scoped_ptr<NotificationChangeObserver> observer(CreateObserver());
   bool success = g_browser_process->notification_ui_manager()->
       CancelById(notification.notification_id());
   if (success)
-    return observer.Wait();
+    return observer->Wait();
   return false;
 }
 
-#endif  // !ENABLE_MESSAGE_CENTER_TESTING
-
 void NotificationsTest::SetDefaultPermissionSetting(ContentSetting setting) {
   DesktopNotificationService* service = GetDesktopNotificationService();
   service->SetDefaultContentSetting(setting);
 }
 
 void NotificationsTest::DenyOrigin(const GURL& origin) {
   DropOriginPreference(origin);
   GetDesktopNotificationService()->DenyPermission(origin);
 }
 
@@ skipping 25 matching lines @@
     Browser* browser,
     bool wait_for_new_balloon,
     const char* icon,
     const char* title,
     const char* body,
     const char* replace_id) {
   std::string script = base::StringPrintf(
       "createNotification('%s', '%s', '%s', '%s');",
       icon, title, body, replace_id);
 
-  NotificationChangeObserver observer;
+  scoped_ptr<NotificationChangeObserver> observer(CreateObserver());
   std::string result;
   bool success = content::ExecuteScriptAndExtractString(
       browser->tab_strip_model()->GetActiveWebContents(),
       script,
       &result);
   if (success && result != "-1" && wait_for_new_balloon)
-    success = observer.Wait();
+    success = observer->Wait();
   EXPECT_TRUE(success);
 
   return result;
 }
 
 std::string NotificationsTest::CreateSimpleNotification(
     Browser* browser,
     bool wait_for_new_balloon) {
   return CreateNotification(
       browser, wait_for_new_balloon,
@@ skipping 17 matching lines @@
   return true;
 }
 
 bool NotificationsTest::CancelNotification(
     const char* notification_id,
     Browser* browser) {
   std::string script = base::StringPrintf(
       "cancelNotification('%s');",
       notification_id);
 
-  NotificationChangeObserver observer;
+  scoped_ptr<NotificationChangeObserver> observer(CreateObserver());
   std::string result;
   bool success = content::ExecuteScriptAndExtractString(
       browser->tab_strip_model()->GetActiveWebContents(),
       script,
       &result);
   if (!success || result != "1")
     return false;
-  return observer.Wait();
+  return observer->Wait();
 }
 
 bool NotificationsTest::PerformActionOnInfobar(
     Browser* browser,
     InfobarAction action,
     int infobar_index,
     int tab_index) {
   InfoBarService* infobar_service = InfoBarService::FromWebContents(
       browser->tab_strip_model()->GetWebContentsAt(tab_index));
 
@@ skipping 103 matching lines @@
 
   // Creates a simple notification.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), test_page_url_);
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
 
   GURL EXPECTED_ICON_URL = test_server()->GetURL(kExpectedIconUrl);
   ASSERT_EQ(1, GetNotificationCount());
-#if ENABLE_MESSAGE_CENTER_TESTING
-  message_center::NotificationList::Notifications notifications =
-      message_center::MessageCenter::Get()->GetNotifications();
-  EXPECT_EQ(ASCIIToUTF16("My Title"), (*notifications.rbegin())->title());
-  EXPECT_EQ(ASCIIToUTF16("My Body"), (*notifications.rbegin())->message());
-#else
-  const std::deque<Balloon*>& balloons = GetActiveBalloons();
-  ASSERT_EQ(1U, balloons.size());
-  Balloon* balloon = balloons[0];
-  const Notification& notification = balloon->notification();
-  EXPECT_EQ(EXPECTED_ICON_URL, notification.icon_url());
-  EXPECT_EQ(ASCIIToUTF16("My Title"), notification.title());
-  EXPECT_EQ(ASCIIToUTF16("My Body"), notification.body());
-#endif
+  if (message_center::IsRichNotificationEnabled()) {
+    message_center::NotificationList::Notifications notifications =
+        message_center::MessageCenter::Get()->GetNotifications();
+    EXPECT_EQ(ASCIIToUTF16("My Title"), (*notifications.rbegin())->title());
+    EXPECT_EQ(ASCIIToUTF16("My Body"), (*notifications.rbegin())->message());
+  } else {
+    const std::deque<Balloon*>& balloons = GetActiveBalloons();
+    ASSERT_EQ(1U, balloons.size());
+    Balloon* balloon = balloons[0];
+    const Notification& notification = balloon->notification();
+    EXPECT_EQ(EXPECTED_ICON_URL, notification.icon_url());
+    EXPECT_EQ(ASCIIToUTF16("My Title"), notification.title());
+    EXPECT_EQ(ASCIIToUTF16("My Body"), notification.body());
+  }
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCloseNotification) {
 #if defined(OS_MACOSX)
   // TODO(kbr): re-enable: http://crbug.com/222296
   if (base::mac::IsOSMountainLionOrLater())
     return;
 #endif
 
   // Creates a notification and closes it.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), test_page_url_);
 
   std::string result = CreateSimpleNotification(browser(), true);
   EXPECT_NE("-1", result);
   ASSERT_EQ(1, GetNotificationCount());
 
-#if ENABLE_MESSAGE_CENTER_TESTING
-  message_center::NotificationList::Notifications notifications =
-      message_center::MessageCenter::Get()->GetNotifications();
-  message_center::MessageCenter::Get()->RemoveNotification(
-      (*notifications.rbegin())->id(),
-      true);  // by_user
-#else
-  const std::deque<Balloon*>& balloons = GetActiveBalloons();
-  EXPECT_TRUE(CloseNotificationAndWait(balloons[0]->notification()));
-#endif  // ENABLE_MESSAGE_CENTER_TESTING
+  if (message_center::IsRichNotificationEnabled()) {
+    message_center::NotificationList::Notifications notifications =
+        message_center::MessageCenter::Get()->GetNotifications();
+    message_center::MessageCenter::Get()->RemoveNotification(
+        (*notifications.rbegin())->id(),
+        true);  // by_user
+  } else {
+    const std::deque<Balloon*>& balloons = GetActiveBalloons();
+    EXPECT_TRUE(CloseNotificationAndWait(balloons[0]->notification()));
+  }
 
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestCancelNotification) {
 #if defined(OS_MACOSX)
   // TODO(kbr): re-enable: http://crbug.com/222296
   if (base::mac::IsOSMountainLionOrLater())
     return;
 #endif
@@ skipping 162 matching lines @@
   ui_test_utils::NavigateToURL(browser(), test_page_url_);
   CreateSimpleNotification(browser(), true);
   ASSERT_EQ(1, GetNotificationCount());
 
   DenyOrigin(test_page_url_.GetOrigin());
   ContentSettingsForOneType settings;
   GetPrefsByContentSetting(CONTENT_SETTING_BLOCK, &settings);
   ASSERT_TRUE(CheckOriginInSetting(settings, test_page_url_.GetOrigin()));
 
   EXPECT_EQ(1, GetNotificationCount());
-#if ENABLE_MESSAGE_CENTER_TESTING
-  message_center::NotificationList::Notifications notifications =
-      message_center::MessageCenter::Get()->GetNotifications();
-  message_center::MessageCenter::Get()->RemoveNotification(
-      (*notifications.rbegin())->id(),
-      true);  // by_user
-#else
-  const std::deque<Balloon*>& balloons = GetActiveBalloons();
-  ASSERT_TRUE(CloseNotificationAndWait(balloons[0]->notification()));
-#endif  // ENABLE_MESSAGE_CENTER_TESTING
+  if (message_center::IsRichNotificationEnabled()) {
+    message_center::NotificationList::Notifications notifications =
+        message_center::MessageCenter::Get()->GetNotifications();
+    message_center::MessageCenter::Get()->RemoveNotification(
+        (*notifications.rbegin())->id(),
+        true);  // by_user
+  } else {
+    const std::deque<Balloon*>& balloons = GetActiveBalloons();
+    ASSERT_TRUE(CloseNotificationAndWait(balloons[0]->notification()));
+  }
   ASSERT_EQ(0, GetNotificationCount());
 }
 
 // Crashes on Linux/Win. See http://crbug.com/160657.
 IN_PROC_BROWSER_TEST_F(
     NotificationsTest,
     DISABLED_TestOriginPrefsNotSavedInIncognito) {
   // Verify that allow/deny origin preferences are not saved in incognito.
   Browser* incognito = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(incognito, test_page_url_);
@@ skipping 41 matching lines @@
       browser(),
       empty_page_url_,
       NEW_BACKGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
   browser()->tab_strip_model()->ActivateTabAt(0, true);
   ui_test_utils::NavigateToURL(browser(), test_page_url_);
   ASSERT_TRUE(RequestPermissionAndWait(browser()));
   CrashTab(browser(), 0);
 }
 
-// Notifications don't have their own process with the message center.
-#if !ENABLE_MESSAGE_CENTER_TESTING
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestKillNotificationProcess) {
+  // Notifications don't have their own process with the message center.
+  if (message_center::IsRichNotificationEnabled())
+    return;
+
 #if defined(OS_MACOSX)
   // TODO(kbr): re-enable: http://crbug.com/222296
   if (base::mac::IsOSMountainLionOrLater())
     return;
 #endif
   // Test killing a notification doesn't crash Chrome.
   AllowAllOrigins();
   ui_test_utils::NavigateToURL(browser(), test_page_url_);
   CreateSimpleNotification(browser(), true);
   ASSERT_EQ(1, GetNotificationCount());
 
   const std::deque<Balloon*>& balloons = GetActiveBalloons();
   ASSERT_EQ(1U, balloons.size());
   CrashNotification(balloons[0]);
   ASSERT_EQ(0, GetNotificationCount());
 }
-#endif
 
 IN_PROC_BROWSER_TEST_F(NotificationsTest, TestIncognitoNotification) {
 #if defined(OS_MACOSX)
   // TODO(kbr): re-enable: http://crbug.com/222296
   if (base::mac::IsOSMountainLionOrLater())
     return;
 #endif
   // Test notifications in incognito window.
   Browser* browser = CreateIncognitoBrowser();
   ui_test_utils::NavigateToURL(browser, test_page_url_);
@@ skipping 82 matching lines @@
   std::string result = CreateNotification(
       browser(), true, "abc.png", "Title1", "Body1", "chat");
   EXPECT_NE("-1", result);
 
   ASSERT_EQ(1, GetNotificationCount());
 
   result = CreateNotification(
       browser(), false, "no_such_file.png", "Title2", "Body2", "chat");
   EXPECT_NE("-1", result);
 
-#if ENABLE_MESSAGE_CENTER_TESTING
-  ASSERT_EQ(1, GetNotificationCount());
-  message_center::NotificationList::Notifications notifications =
-      message_center::MessageCenter::Get()->GetNotifications();
-  EXPECT_EQ(ASCIIToUTF16("Title2"), (*notifications.rbegin())->title());
-  EXPECT_EQ(ASCIIToUTF16("Body2"), (*notifications.rbegin())->message());
-#else
-  const std::deque<Balloon*>& balloons = GetActiveBalloons();
-  ASSERT_EQ(1U, balloons.size());
-  Balloon* balloon = balloons[0];
-  const Notification& notification = balloon->notification();
-  GURL EXPECTED_ICON_URL = test_server()->GetURL(kExpectedIconUrl);
-  EXPECT_EQ(EXPECTED_ICON_URL, notification.icon_url());
-  EXPECT_EQ(ASCIIToUTF16("Title2"), notification.title());
-  EXPECT_EQ(ASCIIToUTF16("Body2"), notification.body());
-#endif
+  if (message_center::IsRichNotificationEnabled()) {
+    ASSERT_EQ(1, GetNotificationCount());
+    message_center::NotificationList::Notifications notifications =
+        message_center::MessageCenter::Get()->GetNotifications();
+    EXPECT_EQ(ASCIIToUTF16("Title2"), (*notifications.rbegin())->title());
+    EXPECT_EQ(ASCIIToUTF16("Body2"), (*notifications.rbegin())->message());
+  } else {
+    const std::deque<Balloon*>& balloons = GetActiveBalloons();
+    ASSERT_EQ(1U, balloons.size());
+    Balloon* balloon = balloons[0];
+    const Notification& notification = balloon->notification();
+    GURL EXPECTED_ICON_URL = test_server()->GetURL(kExpectedIconUrl);
+    EXPECT_EQ(EXPECTED_ICON_URL, notification.icon_url());
+    EXPECT_EQ(ASCIIToUTF16("Title2"), notification.title());
+    EXPECT_EQ(ASCIIToUTF16("Body2"), notification.body());
+  }
 }