Push API: Deflake PushEventEnforcesUserVisibleNotification

chrome/browser/push_messaging/push_messaging_service_impl.cc

 // Copyright 2014 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/push_messaging/push_messaging_service_impl.h"
 
 #include <bitset>
 #include <vector>
 
 #include "base/barrier_closure.h"
@@ skipping 166 matching lines @@
   // Shutdown() should come before and it removes us from the list of app
   // handlers of gcm::GCMDriver so this shouldn't ever been called.
   NOTREACHED();
 }
 
 // OnMessage methods -----------------------------------------------------------
 
 void PushMessagingServiceImpl::OnMessage(
     const std::string& app_id,
     const gcm::GCMClient::IncomingMessage& message) {
+  base::Closure message_handled_closure =
+      message_callback_for_testing_.is_null() ? base::Bind(&base::DoNothing)
+                                              : message_callback_for_testing_;
   PushMessagingApplicationId application_id =
       PushMessagingApplicationId::Get(profile_, app_id);
   // Drop message and unregister if app id was unknown (maybe recently deleted).
   if (!application_id.IsValid()) {
     DeliverMessageCallback(app_id, GURL::EmptyGURL(), -1, message,
+                           message_handled_closure,
                            content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID);
     return;
   }
   // Drop message and unregister if |origin| has lost push permission.
   if (!HasPermission(application_id.origin())) {
     DeliverMessageCallback(app_id, application_id.origin(),
                            application_id.service_worker_registration_id(),
-                           message,
+                           message, message_handled_closure,
                            content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED);
     return;
   }
 
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(),
       "PushMessaging.MessageReceived.Origin",
       application_id.origin());
 
   // The Push API only exposes a single string of data in the push event fired
@@ skipping 21 matching lines @@
   }
 
   content::BrowserContext::DeliverPushMessage(
       profile_,
       application_id.origin(),
       application_id.service_worker_registration_id(),
       data,
       base::Bind(&PushMessagingServiceImpl::DeliverMessageCallback,
                  weak_factory_.GetWeakPtr(),
                  application_id.app_id_guid(), application_id.origin(),
-                 application_id.service_worker_registration_id(), message));
+                 application_id.service_worker_registration_id(), message,
+                 message_handled_closure));
 }
 
 void PushMessagingServiceImpl::DeliverMessageCallback(
     const std::string& app_id_guid,
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const gcm::GCMClient::IncomingMessage& message,
+    const base::Closure& message_handled_closure,
     content::PushDeliveryStatus status) {
   // TODO(mvanouwerkerk): Show a warning in the developer console of the
   // Service Worker corresponding to app_id (and/or on an internals page).
   // TODO(mvanouwerkerk): Is there a way to recover from failure?
   switch (status) {
     // Call RequireUserVisibleUX if the message was delivered to the Service
     // Worker JS, even if the website's event handler failed (to prevent sites
     // deliberately failing in order to avoid having to show notifications).
     case content::PUSH_DELIVERY_STATUS_SUCCESS:
     case content::PUSH_DELIVERY_STATUS_EVENT_WAITUNTIL_REJECTED:
-      RequireUserVisibleUX(requesting_origin, service_worker_registration_id);
+      RequireUserVisibleUX(requesting_origin, service_worker_registration_id,
+                           message_handled_closure);
       break;
     case content::PUSH_DELIVERY_STATUS_INVALID_MESSAGE:
     case content::PUSH_DELIVERY_STATUS_SERVICE_WORKER_ERROR:
+      message_handled_closure.Run();
       break;
     case content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID:
     case content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED:
     case content::PUSH_DELIVERY_STATUS_NO_SERVICE_WORKER:
-      Unregister(app_id_guid, message.sender_id, UnregisterCallback());
+      Unregister(app_id_guid, message.sender_id,
+                 base::Bind(&UnregisterCallbackToClosure,
+                 message_handled_closure));
       break;
   }
   RecordDeliveryStatus(status);
 }
 
 void PushMessagingServiceImpl::RequireUserVisibleUX(
-    const GURL& requesting_origin, int64 service_worker_registration_id) {
+    const GURL& requesting_origin, int64 service_worker_registration_id,
+    const base::Closure& message_handled_closure) {
 #if defined(ENABLE_NOTIFICATIONS)
   // TODO(johnme): Relax this heuristic slightly.
   PlatformNotificationServiceImpl* notification_service =
       PlatformNotificationServiceImpl::GetInstance();
   // Can't use g_browser_process->notification_ui_manager(), since the test uses
   // PlatformNotificationServiceImpl::SetNotificationUIManagerForTesting.
   // TODO(peter): Remove the need to use both APIs here once Notification.get()
   // is supported.
   int notification_count = notification_service->GetNotificationUIManager()->
       GetAllIdsByProfileAndSourceOrigin(profile_, requesting_origin).size();
@@ skipping 50 matching lines @@
   if (notification_shown || notification_needed) {
     content::ServiceWorkerContext* service_worker_context =
         content::BrowserContext::GetStoragePartitionForSite(
             profile_, requesting_origin)->GetServiceWorkerContext();
 
     GetNotificationsShownByLastFewPushes(
         service_worker_context, service_worker_registration_id,
         base::Bind(&PushMessagingServiceImpl::DidGetNotificationsShown,
                    weak_factory_.GetWeakPtr(),
                    requesting_origin, service_worker_registration_id,
-                   notification_shown, notification_needed));
+                   notification_shown, notification_needed,
+                   message_handled_closure));
   } else {
     RecordUserVisibleStatus(
         content::PUSH_USER_VISIBLE_STATUS_NOT_REQUIRED_AND_NOT_SHOWN);
+    message_handled_closure.Run();
   }
+#else
+  message_handled_closure.Run();
 #endif  // defined(ENABLE_NOTIFICATIONS)
 }
 
 static void IgnoreResult(bool unused) {
 }
 
 void PushMessagingServiceImpl::DidGetNotificationsShown(
     const GURL& requesting_origin, int64 service_worker_registration_id,
     bool notification_shown, bool notification_needed,
+    const base::Closure& message_handled_closure,
     const std::string& data, bool success, bool not_found) {
   content::ServiceWorkerContext* service_worker_context =
       content::BrowserContext::GetStoragePartitionForSite(
           profile_, requesting_origin)->GetServiceWorkerContext();
 
   // We remember whether the last (up to) 10 pushes showed notifications.
   const size_t MISSED_NOTIFICATIONS_LENGTH = 10;
   // data is a string like "0001000", where '0' means shown, and '1' means
   // needed but not shown. We manipulate it in bitset form.
   std::bitset<MISSED_NOTIFICATIONS_LENGTH> missed_notifications(data);
 
   bool needed_but_not_shown = notification_needed && !notification_shown;
 
   // New entries go at the end, and old ones are shifted off the beginning once
   // the history length is exceeded.
   missed_notifications <<= 1;
   missed_notifications[0] = needed_but_not_shown;
   std::string updated_data(missed_notifications.
       to_string<char, std::string::traits_type, std::string::allocator_type>());
   SetNotificationsShownByLastFewPushes(
       service_worker_context, service_worker_registration_id,
       requesting_origin, updated_data,
       base::Bind(&IgnoreResult));  // This is a heuristic; ignore failure.
 
   if (notification_shown) {
     RecordUserVisibleStatus(
         notification_needed
         ? content::PUSH_USER_VISIBLE_STATUS_REQUIRED_AND_SHOWN
         : content::PUSH_USER_VISIBLE_STATUS_NOT_REQUIRED_BUT_SHOWN);
+    message_handled_closure.Run();
     return;
   }
   if (needed_but_not_shown) {
     if (missed_notifications.count() <= 1) {  // apply grace
       RecordUserVisibleStatus(
         content::PUSH_USER_VISIBLE_STATUS_REQUIRED_BUT_NOT_SHOWN_USED_GRACE);
+      message_handled_closure.Run();
       return;
     }
     RecordUserVisibleStatus(
         content::
             PUSH_USER_VISIBLE_STATUS_REQUIRED_BUT_NOT_SHOWN_GRACE_EXCEEDED);
     rappor::SampleDomainAndRegistryFromGURL(
         g_browser_process->rappor_service(),
         "PushMessaging.GenericNotificationShown.Origin",
         requesting_origin);
     // The site failed to show a notification when one was needed, and they have
@@ skipping 12 matching lines @@
     notification_data.icon = GURL();  // TODO(johnme): Better icon?
     notification_data.silent = true;
     PlatformNotificationServiceImpl* notification_service =
         PlatformNotificationServiceImpl::GetInstance();
     notification_service->DisplayPersistentNotification(
         profile_,
         service_worker_registration_id,
         requesting_origin,
         SkBitmap() /* icon */,
         notification_data);
+    message_handled_closure.Run();
   }
 }
 
+void PushMessagingServiceImpl::SetMessageCallbackForTesting(
+      const base::Closure& callback) {
+  message_callback_for_testing_ = callback;
+}
+
 // Other gcm::GCMAppHandler methods -------------------------------------------
 
 void PushMessagingServiceImpl::OnMessagesDeleted(const std::string& app_id) {
   // TODO(mvanouwerkerk): Fire push error event on the Service Worker
   // corresponding to app_id.
 }
 
 void PushMessagingServiceImpl::OnSendError(
     const std::string& app_id,
     const gcm::GCMClient::SendErrorDetails& send_error_details) {
@@ skipping 357 matching lines @@
       CONTENT_SETTING_ALLOW;
 }
 
 gcm::GCMDriver* PushMessagingServiceImpl::GetGCMDriver() const {
   gcm::GCMProfileService* gcm_profile_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile_);
   CHECK(gcm_profile_service);
   CHECK(gcm_profile_service->driver());
   return gcm_profile_service->driver();
 }