[BackgroundSync] Remove RegistrationKey

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 <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ skipping 131 matching lines @@
   sync_manager->Init();
   return make_scoped_ptr(sync_manager);
 }
 
 BackgroundSyncManager::~BackgroundSyncManager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->RemoveObserver(this);
 }
 
-BackgroundSyncManager::RegistrationKey::RegistrationKey(
-    const BackgroundSyncRegistration& registration)
-    : RegistrationKey(registration.options()->tag) {}
-
-BackgroundSyncManager::RegistrationKey::RegistrationKey(
-    const BackgroundSyncRegistrationOptions& options)
-    : RegistrationKey(options.tag) {}
-
-BackgroundSyncManager::RegistrationKey::RegistrationKey(const std::string& tag)
-    : value_("o_" + tag) {

[iclelland, 2016/03/08 16:53:15]

What affect will removing this have on previously scheduled syncs? Will we start
calling LookupActiveRegistration by tag, and not finding the registrations,
because they were originally stored with the prefix?

[jkarlin, 2016/03/08 17:25:58]

I'm not sure what I was thinking when I wrote that comment. The prefix is never
written to disk. It's just used as an in-memory index. So upgrading versions
should have no migration issues.

-  // Note that the "o_" prefix on the key is because at one time one-shots were
-  // prefixed with an "o_" and periodic with a "p_". Removing the "o_" requires
-  // migration.
-}
-
 void BackgroundSyncManager::Register(
     int64_t sw_registration_id,
     const BackgroundSyncRegistrationOptions& options,
     bool requested_from_service_worker,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     BackgroundSyncMetrics::CountRegisterFailure(
         BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
@@ skipping 163 matching lines @@
       for (int i = 0, max = registrations_proto.registration_size(); i < max;
            ++i) {
         const BackgroundSyncRegistrationProto& registration_proto =
             registrations_proto.registration(i);
 
         if (registration_proto.id() >= registrations->next_id) {
           corruption_detected = true;
           break;
         }
 
-        RegistrationKey registration_key(registration_proto.tag());
-
         BackgroundSyncRegistration* registration =
-            &registrations->registration_map[registration_key];
+            &registrations->registration_map[registration_proto.tag()];
 
         BackgroundSyncRegistrationOptions* options = registration->options();
         options->tag = registration_proto.tag();
         options->network_state = registration_proto.network_state();
 
         registration->set_id(registration_proto.id());
         registration->set_num_attempts(registration_proto.num_attempts());
         registration->set_delay_until(
             base::Time::FromInternalValue(registration_proto.delay_until()));
       }
@@ skipping 81 matching lines @@
     PostErrorResponse(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback);
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&NotifyBackgroundSyncRegisteredOnUIThread,
                                      service_worker_context_,
                                      sw_registration->pattern().GetOrigin()));
 
   BackgroundSyncRegistration* existing_registration =
-      LookupActiveRegistration(sw_registration_id, RegistrationKey(options));
+      LookupActiveRegistration(sw_registration_id, options.tag);
   if (existing_registration) {
     DCHECK(existing_registration->options()->Equals(options));
 
     BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
         AreOptionConditionsMet(options)
             ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
             : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
     BackgroundSyncMetrics::CountRegisterSuccess(
         registration_could_fire,
         BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE);
@@ skipping 82 matching lines @@
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // The status doesn't matter at this point, there is nothing else to be done.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(barrier_closure));
 }
 
 BackgroundSyncRegistration* BackgroundSyncManager::LookupActiveRegistration(
     int64_t sw_registration_id,
-    const RegistrationKey& registration_key) {
+    const std::string& tag) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   SWIdToRegistrationsMap::iterator it =
       active_registrations_.find(sw_registration_id);
   if (it == active_registrations_.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);
+  auto key_and_registration_iter = registrations.registration_map.find(tag);
   if (key_and_registration_iter == registrations.registration_map.end())
     return nullptr;
 
   return &key_and_registration_iter->second;
 }
 
 void BackgroundSyncManager::StoreRegistrations(
     int64_t sw_registration_id,
     const ServiceWorkerStorage::StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 64 matching lines @@
   FireReadyEvents();
 
   scoped_ptr<BackgroundSyncRegistration> out_registration(
       new BackgroundSyncRegistration(new_registration));
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
                             base::Passed(std::move(out_registration))));
 }
 
-void BackgroundSyncManager::RemoveActiveRegistration(
-    int64_t sw_registration_id,
-    const RegistrationKey& registration_key) {
+void BackgroundSyncManager::RemoveActiveRegistration(int64_t sw_registration_id,
+                                                     const std::string& tag) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(LookupActiveRegistration(sw_registration_id, registration_key));
+  DCHECK(LookupActiveRegistration(sw_registration_id, tag));
 
   BackgroundSyncRegistrations* registrations =
       &active_registrations_[sw_registration_id];
 
-  registrations->registration_map.erase(registration_key);
+  registrations->registration_map.erase(tag);
 }
 
 void BackgroundSyncManager::AddActiveRegistration(
     int64_t sw_registration_id,
     const GURL& origin,
     const BackgroundSyncRegistration& sync_registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(sync_registration.IsValid());
 
   BackgroundSyncRegistrations* registrations =
       &active_registrations_[sw_registration_id];
   registrations->origin = origin;
 
-  RegistrationKey registration_key(sync_registration);
-  registrations->registration_map[registration_key] = sync_registration;
+  registrations->registration_map[sync_registration.options()->tag] =
+      sync_registration;
 }
 
 void BackgroundSyncManager::StoreDataInBackend(
     int64_t sw_registration_id,
     const GURL& origin,
     const std::string& backend_key,
     const std::string& data,
     const ServiceWorkerStorage::StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 167 matching lines @@
 void BackgroundSyncManager::FireReadyEventsImpl(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   // Find the registrations that are ready to run.
-  std::vector<std::pair<int64_t, RegistrationKey>> sw_id_and_keys_to_fire;
+  std::vector<std::pair<int64_t, std::string>> sw_id_and_tags_to_fire;
 
   for (auto& sw_id_and_registrations : active_registrations_) {
     const int64_t 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(
+        sw_id_and_tags_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(BackgroundSyncState::FIRING);
       }
     }
   }
 
-  if (sw_id_and_keys_to_fire.empty()) {
+  if (sw_id_and_tags_to_fire.empty()) {
     RunInBackgroundIfNecessary();
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   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 events_fired_barrier_closure = base::BarrierClosure(
-      sw_id_and_keys_to_fire.size(),
+      sw_id_and_tags_to_fire.size(),
       base::Bind(&BackgroundSyncManager::FireReadyEventsAllEventsFiring,
                  weak_ptr_factory_.GetWeakPtr(), 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::BarrierClosure(sw_id_and_tags_to_fire.size(),
                            base::Bind(&OnAllSyncEventsCompleted, start_time,
-                                      sw_id_and_keys_to_fire.size()));
+                                      sw_id_and_tags_to_fire.size()));
 
-  for (const auto& sw_id_and_key : sw_id_and_keys_to_fire) {
-    int64_t service_worker_id = sw_id_and_key.first;
+  for (const auto& sw_id_and_tag : sw_id_and_tags_to_fire) {
+    int64_t service_worker_id = sw_id_and_tag.first;
     const BackgroundSyncRegistration* registration =
-        LookupActiveRegistration(service_worker_id, sw_id_and_key.second);
+        LookupActiveRegistration(service_worker_id, sw_id_and_tag.second);
     DCHECK(registration);
 
     service_worker_context_->FindReadyRegistrationForId(
         service_worker_id, active_registrations_[service_worker_id].origin,
         base::Bind(&BackgroundSyncManager::FireReadyEventsDidFindRegistration,
-                   weak_ptr_factory_.GetWeakPtr(), sw_id_and_key.second,
+                   weak_ptr_factory_.GetWeakPtr(), sw_id_and_tag.second,
                    registration->id(), events_fired_barrier_closure,
                    events_completed_barrier_closure));
   }
 }
 
 void BackgroundSyncManager::FireReadyEventsDidFindRegistration(
-    const RegistrationKey& registration_key,
+    const std::string& tag,
     BackgroundSyncRegistration::RegistrationId registration_id,
     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(event_fired_callback));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(event_completed_callback));
     return;
   }
 
-  BackgroundSyncRegistration* registration = LookupActiveRegistration(
-      service_worker_registration->id(), registration_key);
+  BackgroundSyncRegistration* registration =
+      LookupActiveRegistration(service_worker_registration->id(), tag);
   DCHECK(registration);
 
   num_firing_registrations_ += 1;
 
   BackgroundSyncEventLastChance last_chance =
       registration->num_attempts() == parameters_->max_sync_attempts - 1
           ? BackgroundSyncEventLastChance::IS_LAST_CHANCE
           : BackgroundSyncEventLastChance::IS_NOT_LAST_CHANCE;
 
   HasMainFrameProviderHost(
       service_worker_registration->pattern().GetOrigin(),
       base::Bind(&BackgroundSyncMetrics::RecordEventStarted));
 
   DispatchSyncEvent(
       registration->options()->tag,
       service_worker_registration->active_version(), last_chance,
       base::Bind(&BackgroundSyncManager::EventComplete,
                  weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
-                 service_worker_registration->id(), registration_key,
+                 service_worker_registration->id(), tag,
                  event_completed_callback));
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(event_fired_callback));
 }
 
 void BackgroundSyncManager::FireReadyEventsAllEventsFiring(
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RunInBackgroundIfNecessary();
   base::ThreadTaskRunnerHandle::Get()->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_t service_worker_id,
-    const RegistrationKey& registration_key,
+    const std::string& tag,
     const base::Closure& callback,
     ServiceWorkerStatusCode status_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::EventCompleteImpl, weak_ptr_factory_.GetWeakPtr(),
-      service_worker_id, registration_key, status_code,
-      MakeClosureCompletion(callback)));
+      service_worker_id, tag, status_code, MakeClosureCompletion(callback)));
 }
 
 void BackgroundSyncManager::EventCompleteImpl(
     int64_t service_worker_id,
-    const RegistrationKey& registration_key,
+    const std::string& tag,
     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 =
-      LookupActiveRegistration(service_worker_id, registration_key);
+      LookupActiveRegistration(service_worker_id, tag);
   if (!registration) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   DCHECK(registration);
   DCHECK_NE(BackgroundSyncState::PENDING, registration->sync_state());
 
   registration->set_num_attempts(registration->num_attempts() + 1);
@@ skipping 24 matching lines @@
              can_retry) {  // Sync failed but can retry
     registration->set_sync_state(BackgroundSyncState::PENDING);
     registration->set_delay_until(clock_->Now() +
                                   parameters_->initial_retry_delay *
                                       pow(parameters_->retry_delay_factor,
                                           registration->num_attempts() - 1));
     registration_completed = false;
   }
 
   if (registration_completed) {
-    RegistrationKey key(*registration);
+    const std::string& tag = registration->options()->tag;
     BackgroundSyncRegistration* active_registration =
-        LookupActiveRegistration(service_worker_id, key);
+        LookupActiveRegistration(service_worker_id, tag);
     if (active_registration &&
         active_registration->id() == registration->id()) {
-      RemoveActiveRegistration(service_worker_id, key);
+      RemoveActiveRegistration(service_worker_id, tag);
     }
   }
 
   StoreRegistrations(
       service_worker_id,
       base::Bind(&BackgroundSyncManager::EventCompleteDidStore,
                  weak_ptr_factory_.GetWeakPtr(), service_worker_id, callback));
 }
 
 void BackgroundSyncManager::EventCompleteDidStore(
@@ skipping 137 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