[Background Sync] Gather UMA data for Background Sync

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"
 #include "base/thread_task_runner_handle.h"
+#include "content/browser/background_sync/background_sync_metrics.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_power_observer.h"
 #include "content/browser/background_sync/background_sync_registration_options.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/android/background_sync_launcher_android.h"
 #endif
@@ skipping 46 matching lines @@
     SyncPeriodicity periodicity)
     : value_(periodicity == SYNC_ONE_SHOT ? "o_" + tag : "p_" + tag) {
 }
 
 void BackgroundSyncManager::Register(
     int64 sw_registration_id,
     const BackgroundSyncRegistrationOptions& options,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // For UMA, determine here whether the sync could fire immediately
+  BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
+      AreOptionConditionsMet(options)
+          ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
+          : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
+
   if (disabled_) {
+    BackgroundSyncMetrics::CountRegistration(
+        options.periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE,
+        ERROR_TYPE_STORAGE);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::RegisterImpl,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id, options,
                  MakeStatusAndRegistrationCompletion(callback)));
 }
 
 void BackgroundSyncManager::Unregister(
     int64 sw_registration_id,
     const std::string& sync_registration_tag,
     SyncPeriodicity periodicity,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
+    BackgroundSyncMetrics::CountUnregistration(periodicity, ERROR_TYPE_STORAGE);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   RegistrationKey registration_key(sync_registration_tag, periodicity);
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::UnregisterImpl, weak_ptr_factory_.GetWeakPtr(),
-      sw_registration_id, registration_key, sync_registration_id,
+      sw_registration_id, registration_key, sync_registration_id, periodicity,
       MakeStatusCompletion(callback)));
 }
 
 void BackgroundSyncManager::GetRegistration(
     int64 sw_registration_id,
     const std::string& sync_registration_tag,
     SyncPeriodicity periodicity,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 164 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback));
 }
 
 void BackgroundSyncManager::RegisterImpl(
     int64 sw_registration_id,
     const BackgroundSyncRegistrationOptions& options,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // For UMA, determine here whether the sync could fire immediately
+  BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
+      AreOptionConditionsMet(options)
+          ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
+          : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
+
   if (disabled_) {
+    BackgroundSyncMetrics::CountRegistration(
+        options.periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE,
+        ERROR_TYPE_STORAGE);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   const BackgroundSyncRegistration* existing_registration =
       LookupRegistration(sw_registration_id, RegistrationKey(options));
   if (existing_registration &&
       existing_registration->options()->Equals(options)) {
+    // Record the duplicated registration
+    BackgroundSyncMetrics::CountRegistration(
+        existing_registration->options()->periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE, ERROR_TYPE_OK);
+
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, *existing_registration));
     return;
   }
 
   BackgroundSyncRegistration new_registration;
   *new_registration.options() = options;
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
   new_registration.set_id(registrations->next_id++);
 
   ServiceWorkerRegistration* sw_registration =
       service_worker_context_->GetLiveRegistration(sw_registration_id);
   if (!sw_registration || !sw_registration->active_version()) {
+    BackgroundSyncMetrics::CountRegistration(
+        options.periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE,
+        ERROR_TYPE_NO_SERVICE_WORKER);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_NO_SERVICE_WORKER,
                               BackgroundSyncRegistration()));
     return;
   }
 
   AddRegistrationToMap(sw_registration_id,
                        sw_registration->pattern().GetOrigin(),
                        new_registration);
 
@@ skipping 115 matching lines @@
                      kBackgroundSyncUserDataKey, serialized, callback);
 }
 
 void BackgroundSyncManager::RegisterDidStore(
     int64 sw_registration_id,
     const BackgroundSyncRegistration& new_registration,
     const StatusAndRegistrationCallback& callback,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  // For UMA, determine here whether the sync could fire immediately
+  BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
+      AreOptionConditionsMet(*new_registration.options())
+          ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
+          : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
+
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
-    // The registration is gone.
+    // The service worker registration is gone.
+    BackgroundSyncMetrics::CountRegistration(
+        new_registration.options()->periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE,
+        ERROR_TYPE_STORAGE);
     sw_to_registrations_map_.erase(sw_registration_id);
     base::ThreadTaskRunnerHandle::Get()->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.";
+    BackgroundSyncMetrics::CountRegistration(
+        new_registration.options()->periodicity, registration_could_fire,
+        BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE,
+        ERROR_TYPE_STORAGE);
     DisableAndClearManager(
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
+  BackgroundSyncMetrics::CountRegistration(
+      new_registration.options()->periodicity, registration_could_fire,
+      BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE, ERROR_TYPE_OK);
   FireReadyEvents();
   base::ThreadTaskRunnerHandle::Get()->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));
@@ skipping 46 matching lines @@
     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,
+    SyncPeriodicity periodicity,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
+    BackgroundSyncMetrics::CountUnregistration(periodicity, ERROR_TYPE_STORAGE);
     base::ThreadTaskRunnerHandle::Get()->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) {
+    BackgroundSyncMetrics::CountUnregistration(periodicity,
+                                               ERROR_TYPE_NOT_FOUND);
     base::ThreadTaskRunnerHandle::Get()->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));
+  StoreRegistrations(sw_registration_id,
+                     base::Bind(&BackgroundSyncManager::UnregisterDidStore,
+                                weak_ptr_factory_.GetWeakPtr(),
+                                sw_registration_id, periodicity, callback));
 }
 
-void BackgroundSyncManager::UnregisterDidStore(
-    int64 sw_registration_id,
-    const StatusCallback& callback,
-    ServiceWorkerStatusCode status) {
+void BackgroundSyncManager::UnregisterDidStore(int64 sw_registration_id,
+                                               SyncPeriodicity periodicity,
+                                               const StatusCallback& callback,
+                                               ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (status == SERVICE_WORKER_ERROR_NOT_FOUND) {
     // ServiceWorker was unregistered.
+    BackgroundSyncMetrics::CountUnregistration(periodicity, ERROR_TYPE_STORAGE);
     sw_to_registrations_map_.erase(sw_registration_id);
     base::ThreadTaskRunnerHandle::Get()->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.";
+    BackgroundSyncMetrics::CountUnregistration(periodicity, ERROR_TYPE_STORAGE);
     DisableAndClearManager(base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
+  BackgroundSyncMetrics::CountUnregistration(periodicity, ERROR_TYPE_OK);
   base::ThreadTaskRunnerHandle::Get()->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);
 
@@ skipping 41 matching lines @@
           tag_and_registration.second;
       if (registration.options()->periodicity == periodicity)
         out_registrations.push_back(registration);
     }
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, out_registrations));
 }
 
+bool BackgroundSyncManager::AreOptionConditionsMet(
+    const BackgroundSyncRegistrationOptions& options) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return network_observer_->NetworkSufficient(options.network_state) &&
+         power_observer_->PowerSufficient(options.power_state);
+}
+
 bool BackgroundSyncManager::IsRegistrationReadyToFire(
     const BackgroundSyncRegistration& registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(jkarlin): Add support for firing periodic registrations.
   if (registration.options()->periodicity == SYNC_PERIODIC)
     return false;
 
   if (registration.sync_state() != SYNC_STATE_PENDING)
     return false;
 
   DCHECK_EQ(SYNC_ONE_SHOT, registration.options()->periodicity);
 
-  return network_observer_->NetworkSufficient(
-             registration.options()->network_state) &&
-         power_observer_->PowerSufficient(registration.options()->power_state);
+  return AreOptionConditionsMet(*registration.options());
 }
 
 void BackgroundSyncManager::SchedulePendingRegistrations() {
 #if defined(OS_ANDROID)
   bool keep_browser_alive_for_one_shot = false;
 
   for (const auto& sw_id_and_registrations : sw_to_registrations_map_) {
     for (const auto& key_and_registration :
          sw_id_and_registrations.second.registration_map) {
       const BackgroundSyncRegistration& registration =
@@ skipping 52 matching lines @@
         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->set_sync_state(SYNC_STATE_FIRING);
       }
     }
   }
 
+  base::TimeTicks start_time = base::TimeTicks::Now();
+
   // Fire the sync event of the ready registrations and run |callback| once
   // they're all done.
-  base::Closure barrier_closure =
+  base::Closure events_fired_barrier_closure =
       base::BarrierClosure(sw_id_and_keys_to_fire.size(), base::Bind(callback));
 
+  // Record the total time taken after all events have run to completion.
+  base::Closure events_completed_barrier_closure =
+      base::BarrierClosure(sw_id_and_keys_to_fire.size(),
+                           base::Bind(&OnAllSyncEventsCompleted, start_time));
+
   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));
+                   registration->id(), events_fired_barrier_closure,
+                   events_completed_barrier_closure));
   }
 
   SchedulePendingRegistrations();
 }
 
 void BackgroundSyncManager::FireReadyEventsDidFindRegistration(
     const RegistrationKey& registration_key,
     BackgroundSyncRegistration::RegistrationId registration_id,
-    const base::Closure& callback,
+    const base::Closure& event_fired_callback,
+    const base::Closure& event_completed_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::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  base::Bind(callback));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(event_fired_callback));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(event_completed_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));
+                 registration_id, event_completed_callback));
 
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(callback));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(event_fired_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,
+    const base::Closure& callback,
     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()));
+  op_scheduler_.ScheduleOperation(base::Bind(
+      &BackgroundSyncManager::EventCompleteImpl, weak_ptr_factory_.GetWeakPtr(),
+      service_worker_id, key, sync_registration_id, status_code,
+      MakeClosureCompletion(callback)));
 }
 
 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::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   BackgroundSyncRegistration* registration =
       LookupRegistration(service_worker_id, key);
   if (!registration || registration->id() != sync_registration_id) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
+  // 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
       // this registration. (crbug.com/479665)
       registration->set_sync_state(SYNC_STATE_FAILED);
     } else {
       registration = nullptr;
       RemoveRegistrationFromMap(service_worker_id, key);
     }
   } else {
@@ skipping 25 matching lines @@
     LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
                   "failure.";
     DisableAndClearManager(base::Bind(callback));
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback));
 }
 
+// static
+void BackgroundSyncManager::OnAllSyncEventsCompleted(
+    const base::TimeTicks& start_time) {
+  // Record the combined time taken by all sync events.
+  BackgroundSyncMetrics::RecordSyncEventHandlingTime(base::TimeTicks::Now() -
+                                                     start_time);
+}
+
 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::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback));
@@ skipping 24 matching lines @@
                                                       Params... parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(parameters...);
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  return MakeClosureCompletion(base::Bind(base::DoNothing));
+}
+
+base::Closure BackgroundSyncManager::MakeClosureCompletion(
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   return base::Bind(
       &BackgroundSyncManager::CompleteOperationCallback<base::Closure>,
-      weak_ptr_factory_.GetWeakPtr(), base::Bind(base::DoNothing));
+      weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusAndRegistrationCallback
 BackgroundSyncManager::MakeStatusAndRegistrationCompletion(
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return base::Bind(&BackgroundSyncManager::CompleteOperationCallback<
                         StatusAndRegistrationCallback, ErrorType,
                         const BackgroundSyncRegistration&>,
@@ skipping 15 matching lines @@
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return base::Bind(
       &BackgroundSyncManager::CompleteOperationCallback<StatusCallback,
                                                         ErrorType>,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content