[BackgroundSyncManager] Rename BackgroundSyncRegistration.name to tag

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/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
@@ skipping 55 matching lines @@
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::RegisterImpl, weak_ptr_factory_.GetWeakPtr(),
       origin, sw_registration_id, sync_registration,
       MakeStatusAndRegistrationCompletion(callback)));
 }
 
 void BackgroundSyncManager::Unregister(
     const GURL& origin,
     int64 sw_registration_id,
-    const std::string& sync_registration_name,
+    const std::string& sync_registration_tag,
     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;
   }
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::UnregisterImpl, weak_ptr_factory_.GetWeakPtr(),
-      origin, sw_registration_id, sync_registration_name, sync_registration_id,
+      origin, sw_registration_id, sync_registration_tag, sync_registration_id,
       MakeStatusCompletion(callback)));
 }
 
 void BackgroundSyncManager::GetRegistration(
     const GURL& origin,
     int64 sw_registration_id,
-    const std::string sync_registration_name,
+    const std::string sync_registration_tag,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::GetRegistrationImpl,
       weak_ptr_factory_.GetWeakPtr(), origin, sw_registration_id,
-      sync_registration_name, MakeStatusAndRegistrationCompletion(callback)));
+      sync_registration_tag, MakeStatusAndRegistrationCompletion(callback)));
 }
 
 void BackgroundSyncManager::OnRegistrationDeleted(int64 registration_id,
                                                   const GURL& pattern) {
   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 worker is gone.
   op_scheduler_.ScheduleOperation(base::Bind(
@@ skipping 66 matching lines @@
            ++i) {
         const BackgroundSyncRegistrationProto& registration_proto =
             registrations_proto.registration(i);
 
         if (registration_proto.id() >= registrations->next_id) {
           corruption_detected = true;
           break;
         }
 
         BackgroundSyncRegistration* registration =
-            &registrations->name_to_registration_map[registration_proto.name()];
+            &registrations->tag_to_registration_map[registration_proto.tag()];
 
         registration->id = registration_proto.id();
-        registration->name = registration_proto.name();
+        registration->tag = registration_proto.tag();
         registration->fire_once = registration_proto.fire_once();
         registration->min_period = registration_proto.min_period();
         registration->network_state = registration_proto.network_state();
         registration->power_state = registration_proto.power_state();
       }
     }
 
     if (corruption_detected)
       break;
   }
@@ skipping 15 matching lines @@
     const BackgroundSyncRegistration& sync_registration,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   BackgroundSyncRegistration existing_registration;
-  if (LookupRegistration(sw_registration_id, sync_registration.name,
+  if (LookupRegistration(sw_registration_id, sync_registration.tag,
                          &existing_registration)) {
     if (existing_registration.Equals(sync_registration)) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback, ERROR_TYPE_OK, existing_registration));
       return;
     }
   }
 
   BackgroundSyncRegistration new_registration = sync_registration;
@@ skipping 52 matching lines @@
 void BackgroundSyncManager::DisableAndClearManagerClearedOne(
     const base::Closure& barrier_closure,
     ServiceWorkerStatusCode status) {
   // 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));
 }
 
 bool BackgroundSyncManager::LookupRegistration(
     int64 sw_registration_id,
-    const std::string& sync_registration_name,
+    const std::string& sync_registration_tag,
     BackgroundSyncRegistration* existing_registration) {
   SWIdToRegistrationsMap::iterator it =
       sw_to_registrations_map_.find(sw_registration_id);
   if (it == sw_to_registrations_map_.end())
     return false;
 
   const BackgroundSyncRegistrations& registrations = it->second;
-  const auto name_and_registration_iter =
-      registrations.name_to_registration_map.find(sync_registration_name);
-  if (name_and_registration_iter ==
-      registrations.name_to_registration_map.end())
+  const auto tag_and_registration_iter =
+      registrations.tag_to_registration_map.find(sync_registration_tag);
+  if (tag_and_registration_iter == registrations.tag_to_registration_map.end())
     return false;
 
   if (existing_registration)
-    *existing_registration = name_and_registration_iter->second;
+    *existing_registration = tag_and_registration_iter->second;
 
   return true;
 }
 
 void BackgroundSyncManager::StoreRegistrations(
     const GURL& origin,
     int64 sw_registration_id,
     const ServiceWorkerStorage::StatusCallback& callback) {
   // 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);
 
-  for (const auto& name_and_registration :
-       registrations.name_to_registration_map) {
+  for (const auto& tag_and_registration :
+       registrations.tag_to_registration_map) {
     const BackgroundSyncRegistration& registration =
-        name_and_registration.second;
+        tag_and_registration.second;
     BackgroundSyncRegistrationProto* registration_proto =
         registrations_proto.add_registration();
     registration_proto->set_id(registration.id);
-    registration_proto->set_name(registration.name);
+    registration_proto->set_tag(registration.tag);
     registration_proto->set_fire_once(registration.fire_once);
     registration_proto->set_min_period(registration.min_period);
     registration_proto->set_network_state(registration.network_state);
     registration_proto->set_power_state(registration.power_state);
   }
   std::string serialized;
   bool success = registrations_proto.SerializeToString(&serialized);
   DCHECK(success);
 
   StoreDataInBackend(sw_registration_id, origin, kBackgroundSyncUserDataKey,
@@ skipping 22 matching lines @@
     return;
   }
 
   // TODO(jkarlin): Run the registration algorithm.
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, new_registration));
 }
 
 void BackgroundSyncManager::RemoveRegistrationFromMap(
     int64 sw_registration_id,
-    const std::string& sync_registration_name) {
+    const std::string& sync_registration_tag) {
   DCHECK(
-      LookupRegistration(sw_registration_id, sync_registration_name, nullptr));
+      LookupRegistration(sw_registration_id, sync_registration_tag, nullptr));
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
 
-  registrations->name_to_registration_map.erase(sync_registration_name);
+  registrations->tag_to_registration_map.erase(sync_registration_tag);
 }
 
 void BackgroundSyncManager::AddRegistrationToMap(
     int64 sw_registration_id,
     const BackgroundSyncRegistration& sync_registration) {
   DCHECK_NE(BackgroundSyncRegistration::kInvalidRegistrationId,
             sw_registration_id);
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
-  registrations->name_to_registration_map[sync_registration.name] =
+  registrations->tag_to_registration_map[sync_registration.tag] =
       sync_registration;
 }
 
 void BackgroundSyncManager::StoreDataInBackend(
     int64 sw_registration_id,
     const GURL& origin,
     const std::string& key,
     const std::string& data,
     const ServiceWorkerStorage::StatusCallback& callback) {
   service_worker_context_->context()->storage()->StoreUserData(
       sw_registration_id, origin, key, data, callback);
 }
 
 void BackgroundSyncManager::GetDataFromBackend(
     const std::string& key,
     const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
         callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->context()->storage()->GetUserDataForAllRegistrations(
       key, callback);
 }
 
 void BackgroundSyncManager::UnregisterImpl(
     const GURL& origin,
     int64 sw_registration_id,
-    const std::string& sync_registration_name,
+    const std::string& sync_registration_tag,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   BackgroundSyncRegistration existing_registration;
-  if (!LookupRegistration(sw_registration_id, sync_registration_name,
+  if (!LookupRegistration(sw_registration_id, sync_registration_tag,
                           &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, sync_registration_name);
+  RemoveRegistrationFromMap(sw_registration_id, sync_registration_tag);
 
   StoreRegistrations(
       origin, 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,
@@ skipping 13 matching lines @@
   }
 
   // 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 std::string sync_registration_name,
+    const std::string sync_registration_tag,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   BackgroundSyncRegistration out_registration;
-  if (!LookupRegistration(sw_registration_id, sync_registration_name,
+  if (!LookupRegistration(sw_registration_id, sync_registration_tag,
                           &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));
 }
@@ skipping 56 matching lines @@
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusCallback
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   return base::Bind(&BackgroundSyncManager::PendingStatusCallback,
                     weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content