[BackgroundSync] Add browser side support for SyncRegistration.done

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 "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 685 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     BackgroundSyncMetrics::CountUnregister(
         periodicity, BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR));
     return;
   }
 
-  const RefCountedRegistration* existing_registration =
+  RefCountedRegistration* existing_registration =
       LookupActiveRegistration(sw_registration_id, registration_key);
 
   if (!existing_registration ||
       existing_registration->value()->id() != sync_registration_id) {
     BackgroundSyncMetrics::CountUnregister(periodicity,
                                            BACKGROUND_SYNC_STATUS_NOT_FOUND);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_NOT_FOUND));
     return;
   }
 
+  bool firing = existing_registration->value()->sync_state() ==
+                BACKGROUND_SYNC_STATE_FIRING;
+
+  existing_registration->value()->set_sync_state(
+      BACKGROUND_SYNC_STATE_UNREGISTERED);
+
+  if (!firing) {
+    // If the registration is currently firing then wait to run
+    // RunDoneCallbacks until after it has finished as it might
+    // change state to SUCCESS first.
+    existing_registration->value()->RunDoneCallbacks();
+  }
+
   RemoveActiveRegistration(sw_registration_id, registration_key);
 
   StoreRegistrations(sw_registration_id,
                      base::Bind(&BackgroundSyncManager::UnregisterDidStore,
                                 weak_ptr_factory_.GetWeakPtr(),
                                 sw_registration_id, periodicity, callback));
 }
 
 void BackgroundSyncManager::UnregisterDidStore(int64 sw_registration_id,
                                                SyncPeriodicity periodicity,
@@ skipping 19 matching lines @@
         base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR));
     return;
   }
 
   BackgroundSyncMetrics::CountUnregister(periodicity,
                                          BACKGROUND_SYNC_STATUS_OK);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK));
 }
 
+void BackgroundSyncManager::NotifyWhenDone(
+    BackgroundSyncRegistrationHandle::HandleId handle_id,
+    const StatusAndStateCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (disabled_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
+                              BACKGROUND_SYNC_STATE_FAILED));
+    return;
+  }
+
+  scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
+      DuplicateRegistrationHandle(handle_id);
+
+  op_scheduler_.ScheduleOperation(
+      base::Bind(&BackgroundSyncManager::NotifyWhenDoneImpl,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(registration_handle.Pass()), callback));
+}
+
+void BackgroundSyncManager::NotifyWhenDoneImpl(
+    scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
+    const StatusAndStateCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (disabled_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
+                              BACKGROUND_SYNC_STATE_FAILED));
+    return;
+  }
+
+  if (registration_handle->sync_state() == BACKGROUND_SYNC_STATE_PENDING ||
+      registration_handle->sync_state() == BACKGROUND_SYNC_STATE_FIRING) {
+    registration_handle->registration()->AddDoneCallback(
+        base::Bind(&BackgroundSyncManager::NotifyWhenDoneDidFinish,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+    op_scheduler_.CompleteOperationAndRunNext();
+    return;
+  }
+
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
+                            registration_handle->sync_state()));
+  op_scheduler_.CompleteOperationAndRunNext();
+}
+
+void BackgroundSyncManager::NotifyWhenDoneDidFinish(
+    const StatusAndStateCallback& callback,
+    BackgroundSyncState sync_state) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (disabled_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
+                              BACKGROUND_SYNC_STATE_FAILED));
+    return;
+  }
+
+  callback.Run(BACKGROUND_SYNC_STATUS_OK, sync_state);
+}
+
 void BackgroundSyncManager::GetRegistrationImpl(
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     PostErrorResponse(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback);
     return;
   }
@@ skipping 71 matching lines @@
 
 void BackgroundSyncManager::SchedulePendingRegistrations() {
 #if defined(OS_ANDROID)
   bool keep_browser_alive_for_one_shot = false;
 
   for (const auto& sw_id_and_registrations : active_registrations_) {
     for (const auto& key_and_registration :
          sw_id_and_registrations.second.registration_map) {
       const BackgroundSyncRegistration& registration =
           *key_and_registration.second->value();
-      if (registration.sync_state() == SYNC_STATE_PENDING) {
+      if (registration.sync_state() == BACKGROUND_SYNC_STATE_PENDING) {
         if (registration.options()->periodicity == SYNC_ONE_SHOT) {
           keep_browser_alive_for_one_shot = true;
         } else {
           // TODO(jkarlin): Support keeping the browser alive for periodic
           // syncs.
         }
       }
     }
   }
 
@@ skipping 159 matching lines @@
       registration_handle->registration();
   DCHECK(registration);
 
   // The event ran to completion, we should count it, no matter what happens
   // from here.
   BackgroundSyncMetrics::RecordEventResult(registration->options()->periodicity,
                                            status_code == SERVICE_WORKER_OK);
 
   if (registration->options()->periodicity == SYNC_ONE_SHOT) {
     if (status_code != SERVICE_WORKER_OK) {
-      // TODO(jkarlin) Fire the sync event on the next page load controlled by
+      // TODO(jkarlin): Insert retry logic here. Be sure to check if the state
+      // is unregistered first. If unregistered then set the state to failed
+      // if it was already out of retry attempts otherwise keep the state as

[iclelland, 2015/09/17 13:48:09]

Add link to bug? crbug.com/501838

[jkarlin, 2015/09/17 17:40:24]

Done.

+      // unregistered. Then call RunDoneCallbacks();
+      // TODO(jkarlin): Fire the sync event on the next page load controlled
+      // by
       // this registration. (crbug.com/479665)
       registration->set_sync_state(BACKGROUND_SYNC_STATE_FAILED);
+      registration->RunDoneCallbacks();
     } else {
+      registration->set_sync_state(BACKGROUND_SYNC_STATE_SUCCESS);
+      registration->RunDoneCallbacks();
+
       RegistrationKey key(*registration);
       // Remove the registration if it's still active.
       RefCountedRegistration* active_registration =
           LookupActiveRegistration(service_worker_id, key);
       if (active_registration &&
           active_registration->value()->id() == registration->id()) {
         RemoveActiveRegistration(service_worker_id, key);
       }
     }
   } else {
@@ skipping 143 matching lines @@
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return base::Bind(
       &BackgroundSyncManager::CompleteOperationCallback<StatusCallback,
                                                         BackgroundSyncStatus>,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content