PaymentHandler: Implement GetAllPaymentApps().

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 <map>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/time/time.h"
 #include "content/browser/payments/payment_app.pb.h"
 #include "content/browser/payments/payment_app_context_impl.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 namespace {
 
 using ::payments::mojom::PaymentHandlerStatus;
-using ::payments::mojom::PaymentInstrument;
 using ::payments::mojom::PaymentInstrumentPtr;
 
 const char kPaymentAppManifestDataKey[] = "PaymentAppManifestData";
 const char kPaymentInstrumentPrefix[] = "PaymentInstrument:";
 const char kPaymentInstrumentKeyInfoPrefix[] = "PaymentInstrumentKeyInfo:";
 
 std::string CreatePaymentInstrumentKey(const std::string& instrument_key) {
   return kPaymentInstrumentPrefix + instrument_key;
 }
 
@@ skipping 21 matching lines @@
       option->icon = option_proto.icon();
     option->id = option_proto.id();
     for (const auto& method : option_proto.enabled_methods())
       option->enabled_methods.push_back(method);
     manifest->options.push_back(std::move(option));
   }
 
   return manifest;
 }
 
-std::map<uint64_t, std::string> DeserializePaymentInstrumentKeyInfo(
+std::map<uint64_t, std::string> ToInstalledPaymentInstrumentKeyInfo(
     const std::vector<std::string>& inputs) {
   std::map<uint64_t, std::string> key_info;
   for (const auto& input : inputs) {
     PaymentInstrumentKeyInfoProto key_info_proto;
     if (!key_info_proto.ParseFromString(input))
       return std::map<uint64_t, std::string>();
 
     key_info.insert(std::pair<uint64_t, std::string>(
         key_info_proto.insertion_order(), key_info_proto.key()));
   }
 
   return key_info;
 }
 
-PaymentInstrumentPtr DeserializePaymentInstrument(const std::string& input) {
-  PaymentInstrumentProto instrument_proto;
+PaymentInstrumentPtr ToPaymentInstrumentForMojo(const std::string& input) {
+  InstalledPaymentInstrumentProto instrument_proto;
   if (!instrument_proto.ParseFromString(input))
     return nullptr;
 
-  PaymentInstrumentPtr instrument = PaymentInstrument::New();
+  PaymentInstrumentPtr instrument = payments::mojom::PaymentInstrument::New();
   instrument->name = instrument_proto.name();
   for (const auto& method : instrument_proto.enabled_methods())
     instrument->enabled_methods.push_back(method);
   instrument->stringified_capabilities =
       instrument_proto.stringified_capabilities();
 
   return instrument;
 }
 
+std::unique_ptr<InstalledPaymentInstrument> ToInstalledPaymentInstrument(
+    const std::string& input) {
+  InstalledPaymentInstrumentProto instrument_proto;
+  if (!instrument_proto.ParseFromString(input))
+    return std::unique_ptr<InstalledPaymentInstrument>();
+
+  std::unique_ptr<InstalledPaymentInstrument> instrument =
+      base::MakeUnique<InstalledPaymentInstrument>();
+  instrument->registration_id = instrument_proto.registration_id();
+  instrument->instrument_key = instrument_proto.instrument_key();
+  instrument->origin = GURL(instrument_proto.origin());
+  instrument->name = instrument_proto.name();
+  for (const auto& method : instrument_proto.enabled_methods())
+    instrument->enabled_methods.push_back(method);
+
+  return instrument;
+}
+
 }  // namespace
 
 PaymentAppDatabase::PaymentAppDatabase(
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
     : service_worker_context_(service_worker_context), weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 PaymentAppDatabase::~PaymentAppDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 23 matching lines @@
 
 void PaymentAppDatabase::ReadAllManifests(ReadAllManifestsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->GetUserDataForAllRegistrations(
       kPaymentAppManifestDataKey,
       base::Bind(&PaymentAppDatabase::DidReadAllManifests,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
 }
 
+void PaymentAppDatabase::ReadAllPaymentApps(
+    ReadAllPaymentAppsCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  service_worker_context_->GetUserDataForAllRegistrationsByKeyPrefix(
+      kPaymentInstrumentPrefix,
+      base::Bind(&PaymentAppDatabase::DidReadAllPaymentApps,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(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,
@@ skipping 175 matching lines @@
     if (!manifest)
       continue;
 
     manifests.push_back(
         ManifestWithID(item_of_raw_data.first, std::move(manifest)));
   }
 
   std::move(callback).Run(std::move(manifests));
 }
 
+void PaymentAppDatabase::DidReadAllPaymentApps(
+    ReadAllPaymentAppsCallback callback,
+    const std::vector<std::pair<int64_t, std::string>>& raw_data,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK) {
+    std::move(callback).Run(PaymentApps());
+    return;
+  }
+
+  PaymentApps apps;
+  for (const auto& item_of_raw_data : raw_data) {
+    std::unique_ptr<InstalledPaymentInstrument> instrument =
+        ToInstalledPaymentInstrument(item_of_raw_data.second);
+    if (!instrument)
+      continue;
+    if (!base::ContainsKey(apps, instrument->origin))
+      apps.insert(std::make_pair(instrument->origin, Instruments()));
+    apps[instrument->origin].push_back(std::move(instrument));
+  }
+
+  std::move(callback).Run(std::move(apps));
+}
+
 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;
   }
@@ skipping 35 matching lines @@
                                      : PaymentHandlerStatus::NOT_FOUND);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToReadPaymentInstrument(
     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(),
+    std::move(callback).Run(payments::mojom::PaymentInstrument::New(),
                             PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
       registration->id(), {CreatePaymentInstrumentKey(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(),
+    std::move(callback).Run(payments::mojom::PaymentInstrument::New(),
                             PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
-  PaymentInstrumentPtr instrument = DeserializePaymentInstrument(data[0]);
+  PaymentInstrumentPtr instrument = ToPaymentInstrumentForMojo(data[0]);
   if (!instrument) {
-    std::move(callback).Run(PaymentInstrument::New(),
+    std::move(callback).Run(payments::mojom::PaymentInstrument::New(),
                             PaymentHandlerStatus::STORAGE_OPERATION_FAILED);
     return;
   }
 
   std::move(callback).Run(std::move(instrument), PaymentHandlerStatus::SUCCESS);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToGetKeys(
     KeysOfPaymentInstrumentsCallback callback,
     ServiceWorkerStatusCode status,
@@ skipping 17 matching lines @@
     const std::vector<std::string>& data,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(std::vector<std::string>(),
                             PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
   std::vector<std::string> keys;
-  for (const auto& key_info : DeserializePaymentInstrumentKeyInfo(data)) {
+  for (const auto& key_info : ToInstalledPaymentInstrumentKeyInfo(data)) {
     keys.push_back(key_info.second);
   }
 
   std::move(callback).Run(keys, PaymentHandlerStatus::SUCCESS);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToHasPaymentInstrument(
     const std::string& instrument_key,
     HasPaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
@@ skipping 31 matching lines @@
     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;
+  InstalledPaymentInstrumentProto instrument_proto;
+  instrument_proto.set_registration_id(registration->id());
+  instrument_proto.set_instrument_key(instrument_key);
+  instrument_proto.set_origin(registration->pattern().GetOrigin().spec());
   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_instrument;
   bool success = instrument_proto.SerializeToString(&serialized_instrument);
   DCHECK(success);
@@ skipping 73 matching lines @@
 void PaymentAppDatabase::DidClearPaymentInstruments(
     ClearPaymentInstrumentsCallback callback,
     ServiceWorkerStatusCode status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return std::move(callback).Run(status == SERVICE_WORKER_OK
                                      ? PaymentHandlerStatus::SUCCESS
                                      : PaymentHandlerStatus::NOT_FOUND);
 }
 
 }  // namespace content