ServiceWorker: Remove an unused origin_filter param for cleanup

content/browser/service_worker/service_worker_storage.cc

 // Copyright 2013 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/service_worker/service_worker_storage.h"
 
 #include <stddef.h>
 
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
@@ skipping 333 matching lines @@
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   std::vector<ResourceList>* resource_lists = new std::vector<ResourceList>;
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetRegistrationsForOrigin,
                  base::Unretained(database_.get()), origin, registrations,
                  resource_lists),
-      base::Bind(&ServiceWorkerStorage::DidGetRegistrations,
+      base::Bind(&ServiceWorkerStorage::DidGetRegistrationsForOrigin,
                  weak_factory_.GetWeakPtr(), callback,
                  base::Owned(registrations), base::Owned(resource_lists),
                  origin));
 }
 
 void ServiceWorkerStorage::GetAllRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback) {
   if (!LazyInitialize(
           base::Bind(&ServiceWorkerStorage::GetAllRegistrationsInfos,
                      weak_factory_.GetWeakPtr(), callback))) {
     if (state_ != INITIALIZING) {
       RunSoon(FROM_HERE,
               base::Bind(callback, SERVICE_WORKER_ERROR_ABORT,
                          std::vector<ServiceWorkerRegistrationInfo>()));
     }
     return;
   }
   DCHECK_EQ(INITIALIZED, state_);
 
   RegistrationList* registrations = new RegistrationList;
   PostTaskAndReplyWithResult(
       database_task_manager_->GetTaskRunner(), FROM_HERE,
       base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
                  base::Unretained(database_.get()), registrations),
-      base::Bind(&ServiceWorkerStorage::DidGetRegistrationsInfos,
+      base::Bind(&ServiceWorkerStorage::DidGetAllRegistrationsInfos,
                  weak_factory_.GetWeakPtr(), callback,
-                 base::Owned(registrations), GURL()));
+                 base::Owned(registrations)));
 }
 
 void ServiceWorkerStorage::StoreRegistration(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version,
     const StatusCallback& callback) {
   DCHECK(registration);
   DCHECK(version);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
@@ skipping 581 matching lines @@
 void ServiceWorkerStorage::ReturnFoundRegistration(
     const FindRegistrationCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   DCHECK(!resources.empty());
   scoped_refptr<ServiceWorkerRegistration> registration =
       GetOrCreateRegistration(data, resources);
   CompleteFindNow(std::move(registration), SERVICE_WORKER_OK, callback);
 }
 
-void ServiceWorkerStorage::DidGetRegistrations(
+void ServiceWorkerStorage::DidGetRegistrationsForOrigin(
     const GetRegistrationsCallback& callback,
     RegistrationList* registration_data_list,
     std::vector<ResourceList>* resources_list,
     const GURL& origin_filter,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registration_data_list);
   DCHECK(resources_list);
+  DCHECK(origin_filter.is_valid());
 
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
     callback.Run(DatabaseStatusToStatusCode(status),
                  std::vector<scoped_refptr<ServiceWorkerRegistration>>());
     return;
   }
 
   // Add all stored registrations.
   std::set<int64_t> registration_ids;
   std::vector<scoped_refptr<ServiceWorkerRegistration>> registrations;
   size_t index = 0;
   for (const auto& registration_data : *registration_data_list) {
     registration_ids.insert(registration_data.registration_id);
     registrations.push_back(GetOrCreateRegistration(
         registration_data, resources_list->at(index++)));
   }
 
   // Add unstored registrations that are being installed.
   for (const auto& registration : installing_registrations_) {
-    if ((!origin_filter.is_valid() ||
-         registration.second->pattern().GetOrigin() == origin_filter) &&
-        registration_ids.insert(registration.first).second) {
+    if (registration.second->pattern().GetOrigin() != origin_filter)
+      continue;
+    if (registration_ids.insert(registration.first).second)
       registrations.push_back(registration.second);
-    }
   }
 
   callback.Run(SERVICE_WORKER_OK, std::move(registrations));
 }
 
-void ServiceWorkerStorage::DidGetRegistrationsInfos(
+void ServiceWorkerStorage::DidGetAllRegistrationsInfos(
     const GetRegistrationsInfosCallback& callback,
     RegistrationList* registration_data_list,
-    const GURL& origin_filter,
     ServiceWorkerDatabase::Status status) {
   DCHECK(registration_data_list);
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
     callback.Run(DatabaseStatusToStatusCode(status),
                  std::vector<ServiceWorkerRegistrationInfo>());
     return;
   }
 
@@ skipping 44 matching lines @@
       info.waiting_version.fetch_handler_existence =
           registration_data.has_fetch_handler
               ? ServiceWorkerVersion::FetchHandlerExistence::EXISTS
               : ServiceWorkerVersion::FetchHandlerExistence::DOES_NOT_EXIST;
     }
     infos.push_back(info);
   }
 
   // Add unstored registrations that are being installed.
   for (const auto& registration : installing_registrations_) {
-    if ((!origin_filter.is_valid() ||
-         registration.second->pattern().GetOrigin() == origin_filter) &&
-        pushed_registrations.insert(registration.first).second) {
+    if (pushed_registrations.insert(registration.first).second)
       infos.push_back(registration.second->GetInfo());
-    }
   }
 
   callback.Run(SERVICE_WORKER_OK, infos);
 }
 
 void ServiceWorkerStorage::DidStoreRegistration(
     const StatusCallback& callback,
     const ServiceWorkerDatabase::RegistrationData& new_version,
     const GURL& origin,
     const ServiceWorkerDatabase::RegistrationData& deleted_version,
@@ skipping 680 matching lines @@
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   ServiceWorkerMetrics::RecordDeleteAndStartOverResult(
       ServiceWorkerMetrics::DELETE_OK);
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content