BackgroundSyncManager tracks client registrations

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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 "content/browser/service_worker/service_worker_version.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 796 matching lines @@
   ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
       ServiceWorkerMsg_FetchEvent(request_id, request));
   if (status != SERVICE_WORKER_OK) {
     fetch_requests_.Remove(request_id);
     RunSoon(base::Bind(&RunErrorFetchCallback,
                        fetch_callback,
                        SERVICE_WORKER_ERROR_FAILED));
   }
 }
 
-void ServiceWorkerVersion::DispatchSyncEvent(SyncRegistrationPtr registration,
-                                             const StatusCallback& callback) {
+void ServiceWorkerVersion::DispatchSyncEvent(
+    BackgroundSyncRegistrationHandle::HandleId handle_id,
+    const StatusCallback& callback) {
   OnBeginEvent();
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(
         &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
         base::Bind(&self::DispatchSyncEvent, weak_factory_.GetWeakPtr(),
-                   base::Passed(registration.Pass()), callback)));
+                   handle_id, callback)));
     return;
   }
 
   int request_id = AddRequest(callback, &sync_requests_, REQUEST_SYNC);
   if (!background_sync_dispatcher_) {
     embedded_worker_->GetServiceRegistry()->ConnectToRemoteService(
         mojo::GetProxy(&background_sync_dispatcher_));
     background_sync_dispatcher_.set_connection_error_handler(base::Bind(
         &ServiceWorkerVersion::OnBackgroundSyncDispatcherConnectionError,
         weak_factory_.GetWeakPtr()));
   }
 
   background_sync_dispatcher_->Sync(
-      registration.Pass(), base::Bind(&self::OnSyncEventFinished,
-                                      weak_factory_.GetWeakPtr(), request_id));
+      handle_id, base::Bind(&self::OnSyncEventFinished,
+                            weak_factory_.GetWeakPtr(), request_id));
 }
 
 void ServiceWorkerVersion::DispatchNotificationClickEvent(
     const StatusCallback& callback,
     int64_t persistent_notification_id,
     const PlatformNotificationData& notification_data,
     int action_index) {
   OnBeginEvent();
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
@@ skipping 1486 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content