[BackgroundSync] Fire one-shot sync events

content/browser/background_sync/background_sync_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 "content/browser/background_sync/background_sync_manager.h"
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
@@ skipping 211 matching lines @@
                                          registration_proto.periodicity());
         BackgroundSyncRegistration* registration =
             &registrations->registration_map[registration_key];
 
         registration->id = registration_proto.id();
         registration->tag = registration_proto.tag();
         registration->periodicity = registration_proto.periodicity();
         registration->min_period = registration_proto.min_period();
         registration->network_state = registration_proto.network_state();
         registration->power_state = registration_proto.power_state();
+        registration->sync_state = registration_proto.sync_state();
+        if (registration->sync_state == SYNC_STATE_FIRING) {
+          // If the browser (or worker) closed while firing the event, consider
+          // it pending again>
+          registration->sync_state = SYNC_STATE_PENDING;
+        }
       }
     }
 
     if (corruption_detected)
       break;
   }
 
   if (corruption_detected) {
     LOG(ERROR) << "Corruption detected in background sync backend";
     DisableAndClearManager(base::Bind(callback));
     return;
   }
 
-  // TODO(jkarlin): Call the scheduling algorithm here.
+  FireReadyEvents();
 
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
 }
 
 void BackgroundSyncManager::RegisterImpl(
     const GURL& origin,
     int64 sw_registration_id,
     const BackgroundSyncRegistration& sync_registration,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
@@ skipping 108 matching lines @@
     const BackgroundSyncRegistration& registration =
         key_and_registration.second;
     BackgroundSyncRegistrationProto* registration_proto =
         registrations_proto.add_registration();
     registration_proto->set_id(registration.id);
     registration_proto->set_tag(registration.tag);
     registration_proto->set_periodicity(registration.periodicity);
     registration_proto->set_min_period(registration.min_period);
     registration_proto->set_network_state(registration.network_state);
     registration_proto->set_power_state(registration.power_state);
+    registration_proto->set_sync_state(registration.sync_state);
   }
   std::string serialized;
   bool success = registrations_proto.SerializeToString(&serialized);
   DCHECK(success);
 
   StoreDataInBackend(sw_registration_id, registrations.origin,
                      kBackgroundSyncUserDataKey, serialized, callback);
 }
 
 void BackgroundSyncManager::RegisterDidStore(
@@ skipping 11 matching lines @@
   }
 
   if (status != SERVICE_WORKER_OK) {
     LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
                   "failure.";
     DisableAndClearManager(
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
-  // TODO(jkarlin): Run the registration algorithm.
+  FireReadyEvents();
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, new_registration));
 }
 
 void BackgroundSyncManager::RemoveRegistrationFromMap(
     int64 sw_registration_id,
     const RegistrationKey& registration_key) {
   DCHECK(LookupRegistration(sw_registration_id, registration_key));
 
   BackgroundSyncRegistrations* registrations =
@@ skipping 30 matching lines @@
 void BackgroundSyncManager::GetDataFromBackend(
     const std::string& backend_key,
     const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
         callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->GetUserDataForAllRegistrations(backend_key,
                                                           callback);
 }
 
+void BackgroundSyncManager::FireOneShotSync(
+    const scoped_refptr<ServiceWorkerVersion>& active_version,
+    const ServiceWorkerVersion::StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  active_version->DispatchSyncEvent(callback);
+}
+
 void BackgroundSyncManager::UnregisterImpl(
     const GURL& origin,
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
@@ skipping 27 matching lines @@
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   if (status != SERVICE_WORKER_OK) {
     LOG(ERROR) << "BackgroundSync failed to unregister due to backend failure.";
     DisableAndClearManager(base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
-  // TODO(jkarlin): Run the registration algorithm.
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback, ERROR_TYPE_OK));
 }
 
 void BackgroundSyncManager::GetRegistrationImpl(
     const GURL& origin,
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
@@ skipping 25 matching lines @@
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
 }
 
 void BackgroundSyncManager::OnStorageWipedImpl(const base::Closure& callback) {
   sw_to_registrations_map_.clear();
   disabled_ = false;
   InitImpl(callback);
 }
 
 void BackgroundSyncManager::OnNetworkChanged() {
-  // TODO(jkarlin): Run the scheduling algorithm here if initialized and not
-  // disabled.
+  FireReadyEvents();
 }
 
 void BackgroundSyncManager::PendingStatusAndRegistrationCallback(
     const StatusAndRegistrationCallback& callback,
     ErrorType error,
     const BackgroundSyncRegistration& sync_registration) {
   // The callback might delete this object, so hang onto a weak ptr to find out.
   base::WeakPtr<BackgroundSyncManager> manager = weak_ptr_factory_.GetWeakPtr();
   callback.Run(error, sync_registration);
   if (manager)
@@ skipping 11 matching lines @@
 }
 
 void BackgroundSyncManager::PendingClosure(const base::Closure& callback) {
   // The callback might delete this object, so hang onto a weak ptr to find out.
   base::WeakPtr<BackgroundSyncManager> manager = weak_ptr_factory_.GetWeakPtr();
   callback.Run();
   if (manager)
     op_scheduler_.CompleteOperationAndRunNext();
 }
 
+bool BackgroundSyncManager::IsRegistrationReadyToFire(
+    const BackgroundSyncRegistration& registration) {
+  // TODO(jkarlin): Add support for firing periodic registrations.
+  if (registration.periodicity == SYNC_PERIODIC)
+    return false;
+
+  if (registration.sync_state != SYNC_STATE_PENDING)
+    return false;
+
+  DCHECK_EQ(SYNC_ONE_SHOT, registration.periodicity);
+
+  return network_observer_->NetworkSufficient(registration.network_state);
+}
+
+void BackgroundSyncManager::FireReadyEvents() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (disabled_)
+    return;
+
+  op_scheduler_.ScheduleOperation(
+      base::Bind(&BackgroundSyncManager::FireReadyEventsImpl,
+                 weak_ptr_factory_.GetWeakPtr(), MakeEmptyCompletion()));
+}
+
+void BackgroundSyncManager::FireReadyEventsImpl(const base::Closure& callback) {
+  if (disabled_) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  // Find the registrations that are ready to run.
+  std::vector<std::pair<int64, RegistrationKey>> sw_id_and_keys_to_fire;
+
+  for (auto& sw_id_and_registrations : sw_to_registrations_map_) {
+    const int64 service_worker_id = sw_id_and_registrations.first;
+    for (auto& key_and_registration :
+         sw_id_and_registrations.second.registration_map) {
+      BackgroundSyncRegistration* registration = &key_and_registration.second;
+      if (IsRegistrationReadyToFire(*registration)) {
+        sw_id_and_keys_to_fire.push_back(
+            std::make_pair(service_worker_id, key_and_registration.first));
+        // The state change is not saved to persistent storage because
+        // if the sync event is killed mid-sync then it should return to
+        // SYNC_STATE_PENDING.
+        registration->sync_state = SYNC_STATE_FIRING;
+      }
+    }
+  }
+
+  // Fire the sync event of the ready registrations and run |callback| once
+  // they're all done.
+  base::Closure barrier_closure =
+      base::BarrierClosure(sw_id_and_keys_to_fire.size(), base::Bind(callback));
+
+  for (const auto& sw_id_and_key : sw_id_and_keys_to_fire) {
+    int64 service_worker_id = sw_id_and_key.first;
+    const BackgroundSyncRegistration* registration =
+        LookupRegistration(service_worker_id, sw_id_and_key.second);
+
+    service_worker_context_->FindRegistrationForId(
+        service_worker_id, sw_to_registrations_map_[service_worker_id].origin,
+        base::Bind(&BackgroundSyncManager::FireReadyEventsDidFindRegistration,
+                   weak_ptr_factory_.GetWeakPtr(), sw_id_and_key.second,
+                   registration->id, barrier_closure));
+  }
+}
+
+void BackgroundSyncManager::FireReadyEventsDidFindRegistration(
+    const RegistrationKey& registration_key,
+    BackgroundSyncRegistration::RegistrationId registration_id,
+    const base::Closure& callback,
+    ServiceWorkerStatusCode service_worker_status,
+    const scoped_refptr<ServiceWorkerRegistration>&
+        service_worker_registration) {
+  if (service_worker_status != SERVICE_WORKER_OK) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  ServiceWorkerVersion* active_version =
+      service_worker_registration->active_version();
+  if (!active_version) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));

[iclelland, 2015/04/28 02:48:53]

Will this happen if the service worker is still activating when this code
executes? Does this leave the sync registration in the FIRING state in that
case, and if so, can the system recover without a restart?

[jkarlin, 2015/04/28 14:41:00]

Ah, good point. I'll check for active registration in ::RegisterImpl() in a
followup CL so that we know before registering that the service worker is
already active. For this CL I'll remove the check.

[jkarlin, 2015/04/28 16:39:22]

Followup CL is here: https://crrev.com/1110993003

+    return;
+  }
+
+  FireOneShotSync(active_version,
+                  base::Bind(&BackgroundSyncManager::EventComplete,
+                             weak_ptr_factory_.GetWeakPtr(),
+                             service_worker_registration->id(),
+                             registration_key, registration_id));
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+}
+
+void BackgroundSyncManager::EventComplete(
+    int64 service_worker_id,
+    const RegistrationKey& key,
+    BackgroundSyncRegistration::RegistrationId sync_registration_id,
+    ServiceWorkerStatusCode status_code) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (disabled_)
+    return;
+
+  op_scheduler_.ScheduleOperation(
+      base::Bind(&BackgroundSyncManager::EventCompleteImpl,
+                 weak_ptr_factory_.GetWeakPtr(), service_worker_id, key,
+                 sync_registration_id, status_code, MakeEmptyCompletion()));
+}
+
+void BackgroundSyncManager::EventCompleteImpl(

[iclelland, 2015/04/28 02:48:53]

It looks like there are situations here where the event is complete, but that
fact is not stored. Is that expected?

[jkarlin, 2015/04/28 14:41:00]

Are you referring to the early returns below? In all of those cases either the
registration is already gone (disabled_ and !registration) or a new registration
has replaced it (registration->id != sync_registration_id). 

The non-early returns will either remove the registration or set its state to
FAILED. 

[iclelland, 2015/04/28 18:50:39]

Yes, those ones. So if I'm following the code correctly, the event has been
found, set to state FIRING (in memory only), has run to completion, and now we
discover that it has been replaced. Does the old event need to be deleted from
storage, or will that have been taken care of already?

[jkarlin, 2015/04/28 21:00:08]

We should be good. If it's disabled_ then all memory registrations have been
wiped from memory and disk in DisableAndClearManager() so there is nothing left
with FIRING. If a registration id has changed then the old FIRING registration
has been replaced in memory and on disk by the new one in RegisterImpl().

+    int64 service_worker_id,
+    const RegistrationKey& key,
+    BackgroundSyncRegistration::RegistrationId sync_registration_id,
+    ServiceWorkerStatusCode status_code,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (disabled_) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  BackgroundSyncRegistration* registration =
+      LookupRegistration(service_worker_id, key);
+  if (!registration || registration->id != sync_registration_id) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  if (registration->periodicity == SYNC_ONE_SHOT) {
+    if (status_code != SERVICE_WORKER_OK) {
+      // TODO(jkarlin) Fire the sync event on the next page load controlled by
+      // this registration. (crbug.com/479665)
+      registration->sync_state = SYNC_STATE_FAILED;
+    } else {
+      registration = nullptr;
+      RemoveRegistrationFromMap(service_worker_id, key);
+    }
+  } else {
+    // TODO(jkarlin): Add support for running periodic syncs. (crbug.com/479674)
+    NOTREACHED();
+  }
+
+  StoreRegistrations(
+      service_worker_id,
+      base::Bind(&BackgroundSyncManager::EventCompleteDidStore,
+                 weak_ptr_factory_.GetWeakPtr(), service_worker_id, callback));
+}
+
+void BackgroundSyncManager::EventCompleteDidStore(
+    int64 service_worker_id,
+    const base::Closure& callback,
+    ServiceWorkerStatusCode status_code) {
+  if (status_code == SERVICE_WORKER_ERROR_NOT_FOUND) {
+    // The registration is gone.
+    sw_to_registrations_map_.erase(service_worker_id);
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  if (status_code != SERVICE_WORKER_OK) {
+    LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
+                  "failure.";
+    DisableAndClearManager(base::Bind(callback));
+    return;
+  }
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+}
+
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
   return base::Bind(&BackgroundSyncManager::PendingClosure,
                     weak_ptr_factory_.GetWeakPtr(),
                     base::Bind(base::DoNothing));
 }
 
 BackgroundSyncManager::StatusAndRegistrationCallback
 BackgroundSyncManager::MakeStatusAndRegistrationCompletion(
     const StatusAndRegistrationCallback& callback) {
   return base::Bind(
       &BackgroundSyncManager::PendingStatusAndRegistrationCallback,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusCallback
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   return base::Bind(&BackgroundSyncManager::PendingStatusCallback,
                     weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content