PaymentHandler: Implement GetAllPaymentApps().

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 782 matching lines @@
       base::Bind(
           &ServiceWorkerStorage::GetUserDataForAllRegistrationsInDB,
           database_.get(),
           base::ThreadTaskRunnerHandle::Get(),
           key,
           base::Bind(&ServiceWorkerStorage::DidGetUserDataForAllRegistrations,
                      weak_factory_.GetWeakPtr(),
                      callback)));
 }
 
+void ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefix(
+    const std::string& key_prefix,
+    const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
+        callback) {
+  if (!LazyInitialize(base::Bind(
+          &ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefix,
+          weak_factory_.GetWeakPtr(), key_prefix, callback))) {
+    if (state_ != INITIALIZING) {
+      RunSoon(
+          FROM_HERE,
+          base::Bind(callback, std::vector<std::pair<int64_t, std::string>>(),
+                     SERVICE_WORKER_ERROR_ABORT));
+    }
+    return;
+  }
+  DCHECK_EQ(INITIALIZED, state_);
+
+  if (key_prefix.empty()) {
+    RunSoon(FROM_HERE,
+            base::Bind(callback, std::vector<std::pair<int64_t, std::string>>(),
+                       SERVICE_WORKER_ERROR_FAILED));
+    return;
+  }
+
+  database_task_manager_->GetTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefixInDB,
+          database_.get(), base::ThreadTaskRunnerHandle::Get(), key_prefix,
+          base::Bind(&ServiceWorkerStorage::DidGetUserDataForAllRegistrations,
+                     weak_factory_.GetWeakPtr(), callback)));
+}
+
 bool ServiceWorkerStorage::OriginHasForeignFetchRegistrations(
     const GURL& origin) {
   return !IsDisabled() &&
          foreign_fetch_origins_.find(origin) != foreign_fetch_origins_.end();
 }
 
 void ServiceWorkerStorage::DeleteAndStartOver(const StatusCallback& callback) {
   Disable();
 
   // Delete the database on the database thread.
@@ skipping 1011 matching lines @@
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const std::string& key,
     const GetUserDataForAllRegistrationsInDBCallback& callback) {
   std::vector<std::pair<int64_t, std::string>> user_data;
   ServiceWorkerDatabase::Status status =
       database->ReadUserDataForAllRegistrations(key, &user_data);
   original_task_runner->PostTask(FROM_HERE,
                                  base::Bind(callback, user_data, status));
 }
 
+void ServiceWorkerStorage::GetUserDataForAllRegistrationsByKeyPrefixInDB(
+    ServiceWorkerDatabase* database,
+    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+    const std::string& key_prefix,
+    const GetUserDataForAllRegistrationsInDBCallback& callback) {
+  std::vector<std::pair<int64_t, std::string>> user_data;
+  ServiceWorkerDatabase::Status status =
+      database->ReadUserDataForAllRegistrationsByKeyPrefix(key_prefix,
+                                                           &user_data);
+  original_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(callback, user_data, status));
+}
+
 void ServiceWorkerStorage::DeleteAllDataForOriginsFromDB(
     ServiceWorkerDatabase* database,
     const std::set<GURL>& origins) {
   DCHECK(database);
 
   std::vector<int64_t> newly_purgeable_resources;
   database->DeleteAllDataForOrigins(origins, &newly_purgeable_resources);
 }
 
 bool ServiceWorkerStorage::IsDisabled() const {
@@ skipping 54 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