[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 122 matching lines @@
   // Operations already in the queue will either fail when they write to storage
   // or return stale results based on registrations loaded in memory. This is
   // inconsequential since the service worker is gone.
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::OnRegistrationDeletedImpl,
       weak_ptr_factory_.GetWeakPtr(), registration_id, MakeEmptyCompletion()));
 }
 
 void BackgroundSyncManager::OnStorageWiped() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // Operations already in the queue will either fail when they write to storage
   // or return stale results based on registrations loaded in memory. This is
   // inconsequential since the service workers are gone.
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::OnStorageWipedImpl,
                  weak_ptr_factory_.GetWeakPtr(), MakeEmptyCompletion()));
 }
 
 BackgroundSyncManager::BackgroundSyncManager(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
@@ skipping 30 matching lines @@
   GetDataFromBackend(
       kBackgroundSyncUserDataKey,
       base::Bind(&BackgroundSyncManager::InitDidGetDataFromBackend,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncManager::InitDidGetDataFromBackend(
     const base::Closure& callback,
     const std::vector<std::pair<int64, std::string>>& user_data,
     ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (status != SERVICE_WORKER_OK && status != SERVICE_WORKER_ERROR_NOT_FOUND) {
     LOG(ERROR) << "BackgroundSync failed to init due to backend failure.";
     DisableAndClearManager(base::Bind(callback));
     return;
   }
 
   bool corruption_detected = false;
   for (const std::pair<int64, std::string>& data : user_data) {
     BackgroundSyncRegistrationsProto registrations_proto;
     if (registrations_proto.ParseFromString(data.second)) {
@@ skipping 16 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(
     int64 sw_registration_id,
     const BackgroundSyncRegistration& sync_registration,
     const StatusAndRegistrationCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   const BackgroundSyncRegistration* existing_registration = LookupRegistration(
       sw_registration_id, RegistrationKey(sync_registration));
   if (existing_registration &&
@@ skipping 23 matching lines @@
 
   StoreRegistrations(
       sw_registration_id,
       base::Bind(&BackgroundSyncManager::RegisterDidStore,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
                  new_registration, callback));
 }
 
 void BackgroundSyncManager::DisableAndClearManager(
     const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (disabled_) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
     return;
   }
 
   disabled_ = true;
   sw_to_registrations_map_.clear();
 
   // Delete all backend entries. The memory representation of registered syncs
   // may be out of sync with storage (e.g., due to corruption detection on
   // loading from storage), so reload the registrations from storage again.
   GetDataFromBackend(
       kBackgroundSyncUserDataKey,
       base::Bind(&BackgroundSyncManager::DisableAndClearDidGetRegistrations,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncManager::DisableAndClearDidGetRegistrations(
     const base::Closure& callback,
     const std::vector<std::pair<int64, std::string>>& user_data,
     ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (status != SERVICE_WORKER_OK || user_data.empty()) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
     return;
   }
 
   base::Closure barrier_closure =
       base::BarrierClosure(user_data.size(), base::Bind(callback));
 
   for (const auto& sw_id_and_regs : user_data) {
     service_worker_context_->ClearRegistrationUserData(
         sw_id_and_regs.first, kBackgroundSyncUserDataKey,
         base::Bind(&BackgroundSyncManager::DisableAndClearManagerClearedOne,
                    weak_ptr_factory_.GetWeakPtr(), barrier_closure));
   }
 }
 
 void BackgroundSyncManager::DisableAndClearManagerClearedOne(
     const base::Closure& barrier_closure,
     ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // The status doesn't matter at this point, there is nothing else to be done.
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(barrier_closure));
 }
 
 BackgroundSyncManager::BackgroundSyncRegistration*
 BackgroundSyncManager::LookupRegistration(
     int64 sw_registration_id,
     const RegistrationKey& registration_key) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   SWIdToRegistrationsMap::iterator it =
       sw_to_registrations_map_.find(sw_registration_id);
   if (it == sw_to_registrations_map_.end())
     return nullptr;
 
   BackgroundSyncRegistrations& registrations = it->second;
   DCHECK_LE(BackgroundSyncRegistration::kInitialId, registrations.next_id);
   DCHECK(!registrations.origin.is_empty());
 
   auto key_and_registration_iter =
       registrations.registration_map.find(registration_key);
   if (key_and_registration_iter == registrations.registration_map.end())
     return nullptr;
 
   return &key_and_registration_iter->second;
 }
 
 void BackgroundSyncManager::StoreRegistrations(
     int64 sw_registration_id,
     const ServiceWorkerStorage::StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // Serialize the data.
   const BackgroundSyncRegistrations& registrations =
       sw_to_registrations_map_[sw_registration_id];
   BackgroundSyncRegistrationsProto registrations_proto;
   registrations_proto.set_next_registration_id(registrations.next_id);
   registrations_proto.set_origin(registrations.origin.spec());
 
   for (const auto& key_and_registration : registrations.registration_map) {
     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(
     int64 sw_registration_id,
     const BackgroundSyncRegistration& new_registration,
     const StatusAndRegistrationCallback& callback,
     ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     // The registration is gone.
     sw_to_registrations_map_.erase(sw_registration_id);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   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_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(LookupRegistration(sw_registration_id, registration_key));
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
 
   registrations->registration_map.erase(registration_key);
 }
 
 void BackgroundSyncManager::AddRegistrationToMap(
     int64 sw_registration_id,
     const GURL& origin,
     const BackgroundSyncRegistration& sync_registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(BackgroundSyncRegistration::kInvalidRegistrationId,
             sw_registration_id);
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
   registrations->origin = origin;
 
   RegistrationKey registration_key(sync_registration);
   registrations->registration_map[registration_key] = sync_registration;
 }
 
 void BackgroundSyncManager::StoreDataInBackend(
     int64 sw_registration_id,
     const GURL& origin,
     const std::string& backend_key,
     const std::string& data,
     const ServiceWorkerStorage::StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   service_worker_context_->StoreRegistrationUserData(
       sw_registration_id, origin, backend_key, data, callback);
 }
 
 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(
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   const BackgroundSyncRegistration* existing_registration =
       LookupRegistration(sw_registration_id, registration_key);
   if (!existing_registration ||
       existing_registration->id != sync_registration_id) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_NOT_FOUND));
     return;
   }
 
   RemoveRegistrationFromMap(sw_registration_id, registration_key);
 
   StoreRegistrations(
       sw_registration_id,
       base::Bind(&BackgroundSyncManager::UnregisterDidStore,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id, callback));
 }
 
 void BackgroundSyncManager::UnregisterDidStore(
     int64 sw_registration_id,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     // ServiceWorker was unregistered.
     sw_to_registrations_map_.erase(sw_registration_id);
     base::MessageLoop::current()->PostTask(
         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(
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     const StatusAndRegistrationCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   const BackgroundSyncRegistration* out_registration =
       LookupRegistration(sw_registration_id, registration_key);
   if (!out_registration) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_NOT_FOUND,
                               BackgroundSyncRegistration()));
     return;
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, *out_registration));
 }
 
+bool BackgroundSyncManager::IsRegistrationReadyToFire(
+    const BackgroundSyncRegistration& registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  // 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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (service_worker_status != SERVICE_WORKER_OK) {
+    base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+    return;
+  }
+
+  FireOneShotSync(
+      service_worker_registration->active_version(),
+      base::Bind(&BackgroundSyncManager::EventComplete,
+                 weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
+                 service_worker_registration->id(), registration_key,
+                 registration_id));
+
+  base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
+}
+
+// |service_worker_registration| is just to keep the registration alive
+// while the event is firing.
+void BackgroundSyncManager::EventComplete(
+    const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
+    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(
+    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) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  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));
+}
+
 void BackgroundSyncManager::OnRegistrationDeletedImpl(
     int64 registration_id,
     const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // The backend (ServiceWorkerStorage) will delete the data, so just delete the
   // memory representation here.
   sw_to_registrations_map_.erase(registration_id);
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
 }
 
 void BackgroundSyncManager::OnStorageWipedImpl(const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   sw_to_registrations_map_.clear();
   disabled_ = false;
   InitImpl(callback);
 }
 
 void BackgroundSyncManager::OnNetworkChanged() {
-  // TODO(jkarlin): Run the scheduling algorithm here if initialized and not
-  // disabled.
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  FireReadyEvents();
 }
 
 void BackgroundSyncManager::PendingStatusAndRegistrationCallback(
     const StatusAndRegistrationCallback& callback,
     ErrorType error,
     const BackgroundSyncRegistration& sync_registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // 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)
     op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::PendingStatusCallback(
     const StatusCallback& callback,
     ErrorType error) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // 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);
   if (manager)
     op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::PendingClosure(const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   // 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();
 }
 
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   return base::Bind(&BackgroundSyncManager::PendingClosure,
                     weak_ptr_factory_.GetWeakPtr(),
                     base::Bind(base::DoNothing));
 }
 
 BackgroundSyncManager::StatusAndRegistrationCallback
 BackgroundSyncManager::MakeStatusAndRegistrationCompletion(
     const StatusAndRegistrationCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   return base::Bind(
       &BackgroundSyncManager::PendingStatusAndRegistrationCallback,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusCallback
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   return base::Bind(&BackgroundSyncManager::PendingStatusCallback,
                     weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content