[BackgroundSyncManager] Remove dead code

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.pb.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
@@ skipping 364 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,
-    BackgroundSyncRegistration* old_registration) {
+    const std::string& sync_registration_name) {
   DCHECK(
       LookupRegistration(sw_registration_id, sync_registration_name, nullptr));
 
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
 
-  const auto name_and_registration_iter =
-      registrations->name_to_registration_map.find(sync_registration_name);
-  if (old_registration)
-    *old_registration = name_and_registration_iter->second;
-
-  registrations->name_to_registration_map.erase(name_and_registration_iter);
+  registrations->name_to_registration_map.erase(sync_registration_name);
 }
 
 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];
@@ skipping 35 matching lines @@
 
   BackgroundSyncRegistration existing_registration;
   if (!LookupRegistration(sw_registration_id, sync_registration_name,
                           &existing_registration) ||
       existing_registration.id != sync_registration_id) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_NOT_FOUND));
     return;
   }
 
-  BackgroundSyncRegistration old_sync_registration;
-  RemoveRegistrationFromMap(sw_registration_id, sync_registration_name,
-                            &old_sync_registration);
+  RemoveRegistrationFromMap(sw_registration_id, sync_registration_name);
 
   StoreRegistrations(
       origin, sw_registration_id,
       base::Bind(&BackgroundSyncManager::UnregisterDidStore,
-                 weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
-                 old_sync_registration, callback));
+                 weak_ptr_factory_.GetWeakPtr(), sw_registration_id, callback));
 }
 
 void BackgroundSyncManager::UnregisterDidStore(
     int64 sw_registration_id,
-    const BackgroundSyncRegistration& old_sync_registration,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status) {
   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;
   }
 
@@ skipping 91 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