Minimize the delegate dependencies for native extension notifications.

chrome/browser/extensions/api/notifications/notifications_apitest.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 "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
@@ skipping 21 matching lines @@
 #include "extensions/browser/app_window/native_app_window.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/test_util.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "ui/message_center/notifier_settings.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
-#include "ui/base/test/scoped_fake_nswindow_fullscreen.h"
 #endif
 
 using extensions::AppWindow;
 using extensions::AppWindowRegistry;
 using extensions::Extension;
 using extensions::ExtensionNotificationDisplayHelper;
 using extensions::ExtensionNotificationDisplayHelperFactory;
 using extensions::ResultCatcher;
 
 namespace utils = extension_function_test_utils;
@@ skipping 184 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestEvents) {
   ASSERT_TRUE(RunExtensionTest("notifications/api/events")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestCSP) {
   ASSERT_TRUE(RunExtensionTest("notifications/api/csp")) << message_;
 }
 
+// Native notifications don't support (nor use) observers.
+#if !defined(OS_MACOSX)

[dewittj, 2017/05/16 22:07:17]

should this be BUILDFLAG rather than OS?

[Miguel Garcia, 2017/05/20 07:04:10]

We have  BUILDFLAG(ENABLE_NATIVE_NOTIFICATIONS) but both linux and windows
support the flag but are nowhere near shipping native by default. Therefore for
those platforms it's probably better to keep running the tests.

 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestByUser) {
   const extensions::Extension* extension =
       LoadExtensionAndWait("notifications/api/by_user");
   ASSERT_TRUE(extension) << message_;
 
   {
     ResultCatcher catcher;
     const std::string notification_id =
         GetNotificationIdFromDelegateId(extension->id() + "-FOO");
     GetDisplayService()->RemoveNotification(
@@ skipping 16 matching lines @@
                                                 false /* by_user */);
     EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   }
   {
     ResultCatcher catcher;
     GetDisplayService()->RemoveAllNotifications(NotificationCommon::EXTENSION,
                                                 true /* by_user */);
     EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   }
 }
+#endif  // !defined(OS_MACOSX)
 
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestPartialUpdate) {
   ASSERT_TRUE(RunExtensionTest("notifications/api/partial_update")) << message_;
   const extensions::Extension* extension = GetSingleLoadedExtension();
   ASSERT_TRUE(extension) << message_;
 
   const char kNewTitle[] = "Changed!";
   const char kNewMessage[] = "Too late! The show ended yesterday";
   int kNewPriority = 2;
   const char kButtonTitle[] = "NewButton";
@@ skipping 79 matching lines @@
 
     message_center::NotifierId notifier_id(
         message_center::NotifierId::APPLICATION,
         extension->id());
     GetNotifierStateTracker()->SetNotifierEnabled(notifier_id, true);
 
     EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
   }
 }
 
+// Native notifications don't support (nor use) observers.
+#if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestUserGesture) {
   const extensions::Extension* extension =
       LoadExtensionAndWait("notifications/api/user_gesture");
   ASSERT_TRUE(extension) << message_;
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   {
     UserGestureCatcher catcher;
     notification->ButtonClick(0);
     EXPECT_TRUE(catcher.GetNextResult());
     notification->Click();
     EXPECT_TRUE(catcher.GetNextResult());
     notification->Close(true /* by_user */);
     EXPECT_TRUE(catcher.GetNextResult());
 
     // Note that |notification| no longer points to valid memory.
   }
 
   ASSERT_FALSE(GetNotificationForExtension(extension));
 }
+#endif  // !defined(OS_MACOSX)
 
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestRequireInteraction) {
   const extensions::Extension* extension =
       LoadExtensionAndWait("notifications/api/require_interaction");
   ASSERT_TRUE(extension) << message_;
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   EXPECT_TRUE(notification->never_timeout());
@@ skipping 12 matching lines @@
       GetFirstAppWindow(extension->id())->GetNativeWindow()));
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   // If the app hasn't created a fullscreen window, then its notifications
   // shouldn't be displayed when a window is fullscreen.
   ASSERT_FALSE(notification->delegate()->ShouldDisplayOverFullscreen());
 }
 
+// Full screen related tests don't run on Mac as native notifications full
+// screen decisions are done by the OS directly.
+#if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestShouldDisplayFullscreen) {
-#if defined(OS_MACOSX)
-  ui::test::ScopedFakeNSWindowFullscreen fake_fullscreen;
-#endif
   EnableFullscreenNotifications();
   ExtensionTestMessageListener notification_created_listener("created", false);
   const Extension* extension = LoadAppWithWindowState(
       "notifications/api/basic_app", WindowState::FULLSCREEN);
   ASSERT_TRUE(extension) << message_;
   ASSERT_TRUE(notification_created_listener.WaitUntilSatisfied());
 
   // We start by making sure the window is actually focused.
   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
       GetFirstAppWindow(extension->id())->GetNativeWindow()));
 
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->IsFullscreen())
       << "Not Fullscreen";
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->GetBaseWindow()->IsActive())
       << "Not Active";
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   // If the app has created a fullscreen window, then its notifications should
   // be displayed when a window is fullscreen.
   ASSERT_TRUE(notification->delegate()->ShouldDisplayOverFullscreen());
 }
 
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestShouldDisplayFullscreenOff) {
-#if defined(OS_MACOSX)
-  ui::test::ScopedFakeNSWindowFullscreen fake_fullscreen;
-#endif
   DisableFullscreenNotifications();
   ExtensionTestMessageListener notification_created_listener("created", false);
   const Extension* extension = LoadAppWithWindowState(
       "notifications/api/basic_app", WindowState::FULLSCREEN);
   ASSERT_TRUE(extension) << message_;
   ASSERT_TRUE(notification_created_listener.WaitUntilSatisfied());
 
   // We start by making sure the window is actually focused.
   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
       GetFirstAppWindow(extension->id())->GetNativeWindow()));
 
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->IsFullscreen())
       << "Not Fullscreen";
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->GetBaseWindow()->IsActive())
       << "Not Active";
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   // When the experiment flag is off, then ShouldDisplayOverFullscreen should
   // return false.
   ASSERT_FALSE(notification->delegate()->ShouldDisplayOverFullscreen());
 }
 
 // The Fake OSX fullscreen window doesn't like drawing a second fullscreen
 // window when another is visible.
-#if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest, TestShouldDisplayMultiFullscreen) {
   // Start a fullscreen app, and then start another fullscreen app on top of the
   // first. Notifications from the first should not be displayed because it is
   // not the app actually displaying on the screen.
   EnableFullscreenNotifications();
   ExtensionTestMessageListener notification_created_listener("created", false);
   const Extension* extension1 = LoadAppWithWindowState(
       "notifications/api/basic_app", WindowState::FULLSCREEN);
   ASSERT_TRUE(extension1) << message_;
 
   ExtensionTestMessageListener window_visible_listener("visible", false);
   const Extension* extension2 = LoadAppWithWindowState(
       "notifications/api/other_app", WindowState::FULLSCREEN);
   ASSERT_TRUE(extension2) << message_;
 
   ASSERT_TRUE(notification_created_listener.WaitUntilSatisfied());
   ASSERT_TRUE(window_visible_listener.WaitUntilSatisfied());
 
   // We start by making sure the window is actually focused.
   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
       GetFirstAppWindow(extension2->id())->GetNativeWindow()));
 
   Notification* notification = GetNotificationForExtension(extension1);
   ASSERT_TRUE(notification);
 
   // The first app window is superseded by the second window, so its
   // notification shouldn't be displayed.
   ASSERT_FALSE(notification->delegate()->ShouldDisplayOverFullscreen());
 }
-#endif
 
 // Verify that a notification is actually displayed when the app window that
 // creates it is fullscreen with the fullscreen notification flag turned on.
 IN_PROC_BROWSER_TEST_F(NotificationsApiTest,
                        TestShouldDisplayPopupNotification) {
-#if defined(OS_MACOSX)
-  ui::test::ScopedFakeNSWindowFullscreen fake_fullscreen;
-#endif
   EnableFullscreenNotifications();
   ExtensionTestMessageListener notification_created_listener("created", false);
   const Extension* extension = LoadAppWithWindowState(
       "notifications/api/basic_app", WindowState::FULLSCREEN);
   ASSERT_TRUE(extension) << message_;
   ASSERT_TRUE(notification_created_listener.WaitUntilSatisfied());
 
   // We start by making sure the window is actually focused.
   ASSERT_TRUE(ui_test_utils::ShowAndFocusNativeWindow(
       GetFirstAppWindow(extension->id())->GetNativeWindow()));
 
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->IsFullscreen())
       << "Not Fullscreen";
   ASSERT_TRUE(GetFirstAppWindow(extension->id())->GetBaseWindow()->IsActive())
       << "Not Active";
 
   Notification* notification = GetNotificationForExtension(extension);
   ASSERT_TRUE(notification);
 
   // The extension's window is being shown and focused, so its expected that
   // the notification displays on top of it.
   ASSERT_TRUE(notification->delegate()->ShouldDisplayOverFullscreen());
 }
+#endif  // !defined(OS_MACOSX)