Reland "PaymentHandler: Implement PaymentInstruments.keys()."

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 675 matching lines @@
   }
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ServiceWorkerStorage::GetUserDataInDB, database_.get(),
                  base::ThreadTaskRunnerHandle::Get(), registration_id, keys,
                  base::Bind(&ServiceWorkerStorage::DidGetUserData,
                             weak_factory_.GetWeakPtr(), callback)));
 }
 
+void ServiceWorkerStorage::GetUserDataByKeyPrefix(
+    int64_t registration_id,
+    const std::string& key_prefix,
+    const GetUserDataCallback& callback) {
+  if (!LazyInitialize(base::Bind(&ServiceWorkerStorage::GetUserDataByKeyPrefix,
+                                 weak_factory_.GetWeakPtr(), registration_id,
+                                 key_prefix, callback))) {
+    if (state_ != INITIALIZING) {
+      RunSoon(FROM_HERE, base::Bind(callback, std::vector<std::string>(),
+                                    SERVICE_WORKER_ERROR_ABORT));
+    }
+    return;
+  }
+  DCHECK_EQ(INITIALIZED, state_);
+
+  if (registration_id == kInvalidServiceWorkerRegistrationId) {
+    RunSoon(FROM_HERE, base::Bind(callback, std::vector<std::string>(),
+                                  SERVICE_WORKER_ERROR_FAILED));
+    return;
+  }
+  if (key_prefix.empty()) {
+    RunSoon(FROM_HERE, base::Bind(callback, std::vector<std::string>(),
+                                  SERVICE_WORKER_ERROR_FAILED));
+    return;
+  }
+
+  database_task_manager_->GetTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ServiceWorkerStorage::GetUserDataByKeyPrefixInDB,
+                 database_.get(), base::ThreadTaskRunnerHandle::Get(),
+                 registration_id, key_prefix,
+                 base::Bind(&ServiceWorkerStorage::DidGetUserData,
+                            weak_factory_.GetWeakPtr(), callback)));
+}
+
 void ServiceWorkerStorage::ClearUserData(int64_t registration_id,
                                          const std::vector<std::string>& keys,
                                          const StatusCallback& callback) {
   if (!LazyInitialize(base::Bind(&ServiceWorkerStorage::ClearUserData,
                                  weak_factory_.GetWeakPtr(), registration_id,
                                  keys, callback))) {
     if (state_ != INITIALIZING)
       RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_ABORT));
     return;
   }
@@ skipping 1058 matching lines @@
     int64_t registration_id,
     const std::vector<std::string>& keys,
     const GetUserDataInDBCallback& callback) {
   std::vector<std::string> values;
   ServiceWorkerDatabase::Status status =
       database->ReadUserData(registration_id, keys, &values);
   original_task_runner->PostTask(FROM_HERE,
                                  base::Bind(callback, values, status));
 }
 
+void ServiceWorkerStorage::GetUserDataByKeyPrefixInDB(
+    ServiceWorkerDatabase* database,
+    scoped_refptr<base::SequencedTaskRunner> original_task_runner,
+    int64_t registration_id,
+    const std::string& key_prefix,
+    const GetUserDataInDBCallback& callback) {
+  std::vector<std::string> values;
+  ServiceWorkerDatabase::Status status =
+      database->ReadUserDataByKeyPrefix(registration_id, key_prefix, &values);
+  original_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(callback, values, status));
+}
+
 void ServiceWorkerStorage::GetUserDataForAllRegistrationsInDB(
     ServiceWorkerDatabase* database,
     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));
@@ skipping 66 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