Make GetDisplayedNotifications asynchronous.

chrome/browser/notifications/notification_platform_bridge_mac_unittest.mm

 // Copyright 2016 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.
 
 #import <AppKit/AppKit.h>
 #import <objc/runtime.h>
 
+#include "base/bind.h"
 #include "base/mac/scoped_nsobject.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_platform_bridge_mac.h"
 #include "chrome/browser/notifications/notification_test_util.h"
 #include "chrome/browser/notifications/stub_alert_dispatcher_mac.h"
 #include "chrome/browser/notifications/stub_notification_center_mac.h"
 #include "chrome/browser/ui/cocoa/notifications/notification_builder_mac.h"
 #include "chrome/browser/ui/cocoa/notifications/notification_constants_mac.h"
 #include "chrome/browser/ui/cocoa/notifications/notification_response_builder_mac.h"
 #include "chrome/common/features.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gtest_mac.h"
 #include "url/gurl.h"
 
 class NotificationPlatformBridgeMacTest : public testing::Test {
  public:
+  NotificationPlatformBridgeMacTest()
+      : thread_bundle_(content::TestBrowserThreadBundle::DEFAULT) {}
   void SetUp() override {
     notification_center_.reset([[StubNotificationCenter alloc] init]);
     alert_dispatcher_.reset([[StubAlertDispatcher alloc] init]);
   }
 
   void TearDown() override {
     [notification_center_ removeAllDeliveredNotifications];
     [alert_dispatcher_ closeAllNotifications];
   }
 
@@ skipping 11 matching lines @@
     [builder setTag:@"tag1"];
     [builder setIcon:[NSImage imageNamed:@"NSApplicationIcon"]];
     [builder setNotificationId:@"notification_id"];
     [builder setProfileId:@"profile_id"];
     [builder setIncognito:false];
     [builder setNotificationType:@(NotificationCommon::PERSISTENT)];
 
     return [builder buildUserNotification];
   }
 
+  static void StoreNotificationCount(
+      int* out_notification_count,
+      std::unique_ptr<std::set<std::string>> notifications,
+      bool supports_synchronization) {
+    DCHECK(out_notification_count);
+    DCHECK(notifications);
+    *out_notification_count = notifications->size();
+  }
+
   std::unique_ptr<Notification> CreateBanner(const char* title,
                                              const char* subtitle,
                                              const char* origin,
                                              const char* button1,
                                              const char* button2) {
     return CreateNotification(title, subtitle, origin, button1, button2,
                               false /* require_interaction */);
   }
 
   std::unique_ptr<Notification> CreateAlert(const char* title,
@@ skipping 43 matching lines @@
 
   NSUserNotificationCenter* notification_center() {
     return notification_center_.get();
   }
 
   StubAlertDispatcher* alert_dispatcher() { return alert_dispatcher_.get(); }
 
  private:
   base::scoped_nsobject<StubNotificationCenter> notification_center_;
   base::scoped_nsobject<StubAlertDispatcher> alert_dispatcher_;
+  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(NotificationPlatformBridgeMacTest, TestNotificationVerifyValidResponse) {
   NSDictionary* response = BuildDefaultNotificationResponse();
   EXPECT_TRUE(NotificationPlatformBridgeMac::VerifyNotificationData(response));
 }
 
 TEST_F(NotificationPlatformBridgeMacTest, TestNotificationUnknownType) {
   NSMutableDictionary* response = BuildDefaultNotificationResponse();
   [response setValue:[NSNumber numberWithInt:210581]
@@ skipping 127 matching lines @@
 TEST_F(NotificationPlatformBridgeMacTest, TestGetDisplayed) {
   std::unique_ptr<Notification> notification = CreateBanner(
       "Title", "Context", "https://gmail.com", "Button 1", nullptr);
   std::unique_ptr<NotificationPlatformBridgeMac> bridge(
       new NotificationPlatformBridgeMac(notification_center(), nil));
   EXPECT_EQ(0u, [[notification_center() deliveredNotifications] count]);
   bridge->Display(NotificationCommon::PERSISTENT, "notification_id",
                   "profile_id", false, *notification);
   EXPECT_EQ(1u, [[notification_center() deliveredNotifications] count]);
 
-  std::set<std::string> notifications;
-  EXPECT_TRUE(bridge->GetDisplayed("profile_id", false, &notifications));
-  EXPECT_EQ(1u, notifications.size());
+  int notification_count = -1;
+  bridge->GetDisplayed(
+      "profile_id", false /* incognito */,
+      base::Bind(&StoreNotificationCount, &notification_count));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(1, notification_count);
 }
 
 TEST_F(NotificationPlatformBridgeMacTest, TestGetDisplayedUnknownProfile) {
   std::unique_ptr<Notification> notification = CreateBanner(
       "Title", "Context", "https://gmail.com", "Button 1", nullptr);
   std::unique_ptr<NotificationPlatformBridgeMac> bridge(
       new NotificationPlatformBridgeMac(notification_center(), nil));
   EXPECT_EQ(0u, [[notification_center() deliveredNotifications] count]);
   bridge->Display(NotificationCommon::PERSISTENT, "notification_id",
                   "profile_id", false, *notification);
   EXPECT_EQ(1u, [[notification_center() deliveredNotifications] count]);
-
-  std::set<std::string> notifications;
-  EXPECT_TRUE(
-      bridge->GetDisplayed("unknown_profile_id", false, &notifications));
-  EXPECT_EQ(0u, notifications.size());
+  int notification_count = -1;
+  bridge->GetDisplayed(
+      "unknown_profile_id", false /* incognito */,
+      base::Bind(&StoreNotificationCount, &notification_count));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(0, notification_count);
 }
 
 TEST_F(NotificationPlatformBridgeMacTest, TestQuitRemovesNotifications) {
   std::unique_ptr<Notification> notification = CreateBanner(
       "Title", "Context", "https://gmail.com", "Button 1", nullptr);
   {
     std::unique_ptr<NotificationPlatformBridgeMac> bridge(
         new NotificationPlatformBridgeMac(notification_center(), nil));
     EXPECT_EQ(0u, [[notification_center() deliveredNotifications] count]);
     bridge->Display(NotificationCommon::PERSISTENT, "notification_id",
@@ skipping 69 matching lines @@
     EXPECT_EQ(1u, [[notification_center() deliveredNotifications] count]);
     EXPECT_EQ(1u, [[alert_dispatcher() alerts] count]);
   }
 
   // The destructor of the bridge should close all notifications.
   EXPECT_EQ(0u, [[notification_center() deliveredNotifications] count]);
   EXPECT_EQ(0u, [[alert_dispatcher() alerts] count]);
 }
 
 #endif