Push API: Forced notifications should use Notifications database

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 19 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/permission_request_id.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_database_data.h"
+#include "content/public/browser/platform_notification_context.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/platform_notification_data.h"
 #include "content/public/common/push_messaging_status.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/ui/android/tab_model/tab_model.h"
 #include "chrome/browser/ui/android/tab_model/tab_model_list.h"
 #else
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_iterator.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #endif
 
+using content::BrowserThread;
+
 namespace {
 const int kMaxRegistrations = 1000000;
 
 void RecordDeliveryStatus(content::PushDeliveryStatus status) {
   UMA_HISTOGRAM_ENUMERATION("PushMessaging.DeliveryStatus",
                             status,
                             content::PUSH_DELIVERY_STATUS_LAST + 1);
 }
 
 void RecordUserVisibleStatus(content::PushUserVisibleStatus status) {
@@ skipping 201 matching lines @@
     case content::PUSH_DELIVERY_STATUS_NO_SERVICE_WORKER:
       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_t service_worker_registration_id,
     const base::Closure& message_handled_closure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 #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();
+  scoped_refptr<content::PlatformNotificationContext> notification_context =
+      content::BrowserContext::GetStoragePartitionForSite(
+          profile_, requesting_origin)->GetPlatformNotificationContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &content::PlatformNotificationContext
+                  ::ReadAllNotificationDataForServiceWorkerRegistration,
+          notification_context,
+          requesting_origin, service_worker_registration_id,
+          base::Bind(
+              &PushMessagingServiceImpl::DidGetNotificationsFromDatabaseIOProxy,
+              weak_factory_.GetWeakPtr(),
+              requesting_origin, service_worker_registration_id,
+              message_handled_closure)));
+#else
+  message_handled_closure.Run();
+#endif  // defined(ENABLE_NOTIFICATIONS)
+}
+
+// static
+void PushMessagingServiceImpl::DidGetNotificationsFromDatabaseIOProxy(
+    const base::WeakPtr<PushMessagingServiceImpl>& ui_weak_ptr,
+    const GURL& requesting_origin,
+    int64_t service_worker_registration_id,
+    const base::Closure& message_handled_closure,
+    bool success,
+    const std::vector<content::NotificationDatabaseData>& data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&PushMessagingServiceImpl::DidGetNotificationsFromDatabase,
+                 ui_weak_ptr,
+                 requesting_origin, service_worker_registration_id,
+                 message_handled_closure,
+                 success, data));
+}
+
+void PushMessagingServiceImpl::DidGetNotificationsFromDatabase(
+    const GURL& requesting_origin, int64_t service_worker_registration_id,
+    const base::Closure& message_handled_closure,
+    bool success, const std::vector<content::NotificationDatabaseData>& data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // TODO(johnme): Hiding an existing notification should also count as a useful
   // user-visible action done in response to a push message - but make sure that
   // sending two messages in rapid succession which show then hide a
   // notification doesn't count.
+  int notification_count = success ? data.size() : 0;
   bool notification_shown = notification_count > 0;
 
   bool notification_needed = true;
   // Sites with a currently visible tab don't need to show notifications.
 #if defined(OS_ANDROID)
   for (auto it = TabModelList::begin(); it != TabModelList::end(); ++it) {
     Profile* profile = (*it)->GetProfile();
     content::WebContents* active_web_contents =
         (*it)->GetActiveWebContents();
 #else
@@ skipping 33 matching lines @@
 
   // Don't track push messages that didn't show a notification but were exempt
   // from needing to do so.
   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,
+        base::Bind(&PushMessagingServiceImpl::DidGetNotificationsShownAndNeeded,
                    weak_factory_.GetWeakPtr(),
                    requesting_origin, service_worker_registration_id,
                    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,
+void PushMessagingServiceImpl::DidGetNotificationsShownAndNeeded(
+    const GURL& requesting_origin, int64_t 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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   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);
 
@@ skipping 39 matching lines @@
   // TODO(johnme): The generic notification should probably automatically
   // close itself when the next push message arrives?
   content::PlatformNotificationData notification_data;
   // TODO(johnme): Switch to FormatOriginForDisplay from crbug.com/402698
   notification_data.title = base::UTF8ToUTF16(requesting_origin.host());
   notification_data.direction =
       content::PlatformNotificationData::NotificationDirectionLeftToRight;
   notification_data.body =
       l10n_util::GetStringUTF16(IDS_PUSH_MESSAGING_GENERIC_NOTIFICATION_BODY);
   notification_data.tag = kPushMessagingForcedNotificationTag;
-  notification_data.icon = GURL();  // TODO(johnme): Better icon?
+  notification_data.icon = GURL();
   notification_data.silent = true;
-  PlatformNotificationServiceImpl* notification_service =
-      PlatformNotificationServiceImpl::GetInstance();
-  notification_service->DisplayPersistentNotification(
+
+  content::NotificationDatabaseData database_data;
+  database_data.origin = requesting_origin;
+  database_data.service_worker_registration_id =
+      service_worker_registration_id;
+  database_data.notification_data = notification_data;
+
+  scoped_refptr<content::PlatformNotificationContext> notification_context =
+    content::BrowserContext::GetStoragePartitionForSite(
+        profile_, requesting_origin)->GetPlatformNotificationContext();
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &content::PlatformNotificationContext::WriteNotificationData,
+          notification_context,
+          requesting_origin, database_data,
+          base::Bind(&PushMessagingServiceImpl::DidWriteNotificationDataIOProxy,
+                     weak_factory_.GetWeakPtr(),
+                     requesting_origin, notification_data,
+                     message_handled_closure)));
+}
+
+// static
+void PushMessagingServiceImpl::DidWriteNotificationDataIOProxy(
+    const base::WeakPtr<PushMessagingServiceImpl>& ui_weak_ptr,
+    const GURL& requesting_origin,
+    const content::PlatformNotificationData& notification_data,
+    const base::Closure& message_handled_closure,
+    bool success,
+    int64_t persistent_notification_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&PushMessagingServiceImpl::DidWriteNotificationData,
+                 ui_weak_ptr,
+                 requesting_origin, notification_data, message_handled_closure,
+                 success, persistent_notification_id));
+}
+
+void PushMessagingServiceImpl::DidWriteNotificationData(
+    const GURL& requesting_origin,
+    const content::PlatformNotificationData& notification_data,
+    const base::Closure& message_handled_closure,
+    bool success,
+    int64_t persistent_notification_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!success) {
+    DLOG(ERROR) << "Writing forced notification to database should not fail";
+    message_handled_closure.Run();
+    return;
+  }
+  PlatformNotificationServiceImpl::GetInstance()->DisplayPersistentNotification(
       profile_,
-      service_worker_registration_id,
+      persistent_notification_id,
       requesting_origin,
       SkBitmap() /* icon */,
       notification_data);
   message_handled_closure.Run();
 }
 
 void PushMessagingServiceImpl::SetMessageCallbackForTesting(
       const base::Closure& callback) {
   message_callback_for_testing_ = callback;
 }
@@ skipping 368 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();
 }