PaymentHandler: Implement PaymentInstruments.delete().

content/browser/payments/payment_app_database.cc

 // Copyright 2016 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/payments/payment_app_database.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/optional.h"
@@ skipping 89 matching lines @@
 void PaymentAppDatabase::ReadAllManifests(
     const ReadAllManifestsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->GetUserDataForAllRegistrations(
       kPaymentAppManifestDataKey,
       base::Bind(&PaymentAppDatabase::DidReadAllManifests,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
+void PaymentAppDatabase::DeletePaymentInstrument(
+    const GURL& scope,
+    const std::string& instrument_key,
+    DeletePaymentInstrumentCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  service_worker_context_->FindReadyRegistrationForPattern(
+      scope,
+      base::Bind(
+          &PaymentAppDatabase::DidFindRegistrationToDeletePaymentInstrument,
+          weak_ptr_factory_.GetWeakPtr(), instrument_key,
+          base::Passed(std::move(callback))));
+}
+
 void PaymentAppDatabase::ReadPaymentInstrument(
     const GURL& scope,
-    const std::string& instrumentKey,
+    const std::string& instrument_key,
     ReadPaymentInstrumentCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
       base::Bind(
           &PaymentAppDatabase::DidFindRegistrationToReadPaymentInstrument,
-          weak_ptr_factory_.GetWeakPtr(), instrumentKey,
+          weak_ptr_factory_.GetWeakPtr(), instrument_key,
           base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::WritePaymentInstrument(
     const GURL& scope,
-    const std::string& instrumentKey,
+    const std::string& instrument_key,
     PaymentInstrumentPtr instrument,
     WritePaymentInstrumentCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
       base::Bind(
           &PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument,
-          weak_ptr_factory_.GetWeakPtr(), instrumentKey,
+          weak_ptr_factory_.GetWeakPtr(), instrument_key,
           base::Passed(std::move(instrument)),
           base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidFindRegistrationToWriteManifest(
     payments::mojom::PaymentAppManifestPtr manifest,
     const WriteManifestCallback& callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 96 matching lines @@
     if (!manifest)
       continue;
 
     manifests.push_back(
         ManifestWithID(item_of_raw_data.first, std::move(manifest)));
   }
 
   callback.Run(std::move(manifests));
 }
 
+void PaymentAppDatabase::DidFindRegistrationToDeletePaymentInstrument(
+    const std::string& instrument_key,
+    DeletePaymentInstrumentCallback callback,
+    ServiceWorkerStatusCode status,
+    scoped_refptr<ServiceWorkerRegistration> registration) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK) {
+    std::move(callback).Run(PaymentHandlerStatus::NO_ACTIVE_WORKER);
+    return;
+  }
+
+  service_worker_context_->GetRegistrationUserData(
+      registration->id(), {instrument_key},
+      base::Bind(&PaymentAppDatabase::DidFindPaymentInstrument,
+                 weak_ptr_factory_.GetWeakPtr(), registration->id(),
+                 instrument_key, base::Passed(std::move(callback))));
+}
+
+void PaymentAppDatabase::DidFindPaymentInstrument(
+    int64_t registration_id,
+    const std::string& instrument_key,
+    DeletePaymentInstrumentCallback callback,
+    const std::vector<std::string>& data,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK || data.size() != 1) {
+    std::move(callback).Run(PaymentHandlerStatus::NOT_FOUND);
+    return;
+  }
+
+  service_worker_context_->ClearRegistrationUserData(
+      registration_id, {instrument_key},
+      base::Bind(&PaymentAppDatabase::DidDeletePaymentInstrument,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback))));
+}
+
+void PaymentAppDatabase::DidDeletePaymentInstrument(
+    DeletePaymentInstrumentCallback callback,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return std::move(callback).Run(status == SERVICE_WORKER_OK
+                                     ? PaymentHandlerStatus::SUCCESS
+                                     : PaymentHandlerStatus::NOT_FOUND);
+}
+
 void PaymentAppDatabase::DidFindRegistrationToReadPaymentInstrument(
-    const std::string& instrumentKey,
+    const std::string& instrument_key,
     ReadPaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentInstrument::New(),
                             PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
-      registration->id(), {instrumentKey},
+      registration->id(), {instrument_key},
       base::Bind(&PaymentAppDatabase::DidReadPaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidReadPaymentInstrument(
     ReadPaymentInstrumentCallback callback,
     const std::vector<std::string>& data,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK || data.size() != 1) {
     std::move(callback).Run(PaymentInstrument::New(),
                             PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
   PaymentInstrumentPtr instrument = DeserializePaymentInstrument(data[0]);
   if (!instrument) {
     std::move(callback).Run(PaymentInstrument::New(),
                             PaymentHandlerStatus::STORAGE_OPERATION_FAILED);
     return;
   }
 
   std::move(callback).Run(std::move(instrument), PaymentHandlerStatus::SUCCESS);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument(
-    const std::string& instrumentKey,
+    const std::string& instrument_key,
     PaymentInstrumentPtr instrument,
     WritePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   PaymentInstrumentProto instrument_proto;
   instrument_proto.set_name(instrument->name);
   for (const auto& method : instrument->enabled_methods) {
     instrument_proto.add_enabled_methods(method);
   }
   instrument_proto.set_stringified_capabilities(
       instrument->stringified_capabilities);
 
   std::string serialized;
   bool success = instrument_proto.SerializeToString(&serialized);
   DCHECK(success);
 
   service_worker_context_->StoreRegistrationUserData(
       registration->id(), registration->pattern().GetOrigin(),
-      {{instrumentKey, serialized}},
+      {{instrument_key, serialized}},
       base::Bind(&PaymentAppDatabase::DidWritePaymentInstrument,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::DidWritePaymentInstrument(
     WritePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return std::move(callback).Run(
       status == SERVICE_WORKER_OK
           ? PaymentHandlerStatus::SUCCESS
           : PaymentHandlerStatus::STORAGE_OPERATION_FAILED);
 }
 
 }  // namespace content