Background service worker push message processing

chrome/browser/push_messaging/push_messaging_notification_manager.cc

 // Copyright 2015 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_notification_manager.h"
 
 #include <stddef.h>
 
 #include <bitset>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/push_messaging/background_budget_service.h"
 #include "chrome/browser/push_messaging/push_messaging_constants.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/rappor_utils.h"
 #include "components/url_formatter/elide_url.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/platform_notification_context.h"
@@ skipping 52 matching lines @@
   notification_data.icon = GURL();
   notification_data.silent = true;
 
   NotificationDatabaseData database_data;
   database_data.origin = origin;
   database_data.service_worker_registration_id = service_worker_registration_id;
   database_data.notification_data = notification_data;
   return database_data;
 }
 
-void IgnoreResult(bool unused) {}
-
 }  // namespace
 
 PushMessagingNotificationManager::PushMessagingNotificationManager(
     Profile* profile)
     : profile_(profile), weak_factory_(this) {}
 
 PushMessagingNotificationManager::~PushMessagingNotificationManager() {}
 
 void PushMessagingNotificationManager::EnforceUserVisibleOnlyRequirements(
     const GURL& origin,
@@ skipping 85 matching lines @@
           profile_, notification_database_data.notification_id,
           notification_database_data.origin, false /* by_user */);
 
       break;
     }
   }
 
   // Don't track push messages that didn't show a notification but were exempt
   // from needing to do so.
   if (notification_shown || notification_needed) {
-    ServiceWorkerContext* service_worker_context =
-        GetStoragePartition(profile_, origin)->GetServiceWorkerContext();
-
-    PushMessagingService::GetNotificationsShownByLastFewPushes(
-        service_worker_context, service_worker_registration_id,
-        base::Bind(&PushMessagingNotificationManager::
-                       DidGetNotificationsShownAndNeeded,
-                   weak_factory_.GetWeakPtr(), origin,
-                   service_worker_registration_id, notification_shown,
-                   notification_needed, message_handled_closure));
+    std::string notification_history =
+        BackgroundBudgetService::GetBudget(profile_, origin);
+    DidGetBudget(origin, service_worker_registration_id, notification_shown,
+                 notification_needed, message_handled_closure,
+                 notification_history);
   } else {
     RecordUserVisibleStatus(
         content::PUSH_USER_VISIBLE_STATUS_NOT_REQUIRED_AND_NOT_SHOWN);
     message_handled_closure.Run();
   }
 }
 
 bool PushMessagingNotificationManager::IsTabVisible(
     Profile* profile,
     WebContents* active_web_contents,
@@ skipping 20 matching lines @@
 
   // view-source: pages are considered to be controlled Service Worker clients
   // and thus should be considered when checking the visible URL. However, the
   // prefix has to be removed before the origins can be compared.
   if (visible_url.SchemeIs(content::kViewSourceScheme))
     visible_url = GURL(visible_url.GetContent());
 
   return visible_url.GetOrigin() == origin;
 }
 
-void PushMessagingNotificationManager::DidGetNotificationsShownAndNeeded(
+void PushMessagingNotificationManager::DidGetBudget(
     const GURL& 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) {
+    const std::string& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ServiceWorkerContext* service_worker_context =
-      GetStoragePartition(profile_, 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);
 
   DCHECK(notification_shown || notification_needed);  // Caller must ensure this
   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>());
-  PushMessagingService::SetNotificationsShownByLastFewPushes(
-      service_worker_context, service_worker_registration_id, origin,
-      updated_data,
-      base::Bind(&IgnoreResult));  // This is a heuristic; ignore failure.
+  BackgroundBudgetService::StoreBudget(profile_, origin, updated_data);
 
   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;
   }
   DCHECK(needed_but_not_shown);
@@ skipping 56 matching lines @@
     message_handled_closure.Run();
     return;
   }
 
   PlatformNotificationServiceImpl::GetInstance()->DisplayPersistentNotification(
       profile_, persistent_notification_id, origin, notification_data,
       NotificationResources());
 
   message_handled_closure.Run();
 }