[Payments] Implement web payment app manifest

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/base64.h"
 #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"
+#include "content/public/browser/stored_payment_instrument.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 namespace content {
 namespace {
 
 using ::payments::mojom::PaymentHandlerStatus;
 using ::payments::mojom::PaymentInstrument;
 using ::payments::mojom::PaymentInstrumentPtr;
 
+const char kPaymentAppPrefix[] = "PaymentApp:";
 const char kPaymentInstrumentPrefix[] = "PaymentInstrument:";
 const char kPaymentInstrumentKeyInfoPrefix[] = "PaymentInstrumentKeyInfo:";
 
+std::string CreatePaymentAppKey(const std::string& origin) {
+  return kPaymentAppPrefix + origin;
+}
+
 std::string CreatePaymentInstrumentKey(const std::string& instrument_key) {
   return kPaymentInstrumentPrefix + instrument_key;
 }
 
 std::string CreatePaymentInstrumentKeyInfoKey(
     const std::string& instrument_key) {
   return kPaymentInstrumentKeyInfoPrefix + instrument_key;
 }
 
 std::map<uint64_t, std::string> ToStoredPaymentInstrumentKeyInfos(
@@ skipping 23 matching lines @@
         payments::mojom::ImageObject::New(GURL(icon.src())));
   }
   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<StoredPaymentApp> ToStoredPaymentApp(const std::string& input) {
+  StoredPaymentAppProto app_proto;
+  if (!app_proto.ParseFromString(input))
+    return std::unique_ptr<StoredPaymentApp>();
+
+  std::unique_ptr<StoredPaymentApp> app = base::MakeUnique<StoredPaymentApp>();
+  app->registration_id = app_proto.registration_id();
+  app->origin = url::Origin(GURL(app_proto.origin()));
+  app->name = app_proto.name();
+
+  if (!app_proto.icon().empty()) {
+    std::string icon_raw_data;
+    base::Base64Decode(app_proto.icon(), &icon_raw_data);
+    // Note that the icon has been decoded to PNG raw data regardless of the
+    // original icon format that was downloaded.
+    gfx::Image icon_image = gfx::Image::CreateFrom1xPNGBytes(
+        reinterpret_cast<const unsigned char*>(icon_raw_data.data()),
+        icon_raw_data.size());
+    app->icon = base::MakeUnique<SkBitmap>(icon_image.AsBitmap());
+  }
+
+  return app;
+}
+
 std::unique_ptr<StoredPaymentInstrument> ToStoredPaymentInstrument(
     const std::string& input) {
   StoredPaymentInstrumentProto instrument_proto;
   if (!instrument_proto.ParseFromString(input))
     return std::unique_ptr<StoredPaymentInstrument>();
 
   std::unique_ptr<StoredPaymentInstrument> instrument =
       base::MakeUnique<StoredPaymentInstrument>();
-  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();
 
   if (!instrument_proto.decoded_instrument_icon().empty()) {
     std::string icon_raw_data;
     base::Base64Decode(instrument_proto.decoded_instrument_icon(),
                        &icon_raw_data);
     // Note that the icon has been decoded to PNG raw data regardless of the
     // original icon format that was downloaded.
@@ skipping 18 matching lines @@
 
 PaymentAppDatabase::~PaymentAppDatabase() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 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))));
+      kPaymentAppPrefix, 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,
@@ skipping 84 matching lines @@
 
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
       base::Bind(
           &PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument,
           weak_ptr_factory_.GetWeakPtr(), instrument_key,
           base::Passed(std::move(instrument)), icon,
           base::Passed(std::move(callback))));
 }
 
+void PaymentAppDatabase::FetchAndWritePaymentAppInfo(
+    const GURL& context,
+    const GURL& scope,
+    FetchAndWritePaymentAppInfoCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  payment_app_info_fetcher_ = new PaymentAppInfoFetcher();
+  payment_app_info_fetcher_->Start(
+      context, service_worker_context_,
+      base::BindOnce(&PaymentAppDatabase::FetchPaymentAppInfoCallback,
+                     weak_ptr_factory_.GetWeakPtr(), scope,
+                     std::move(callback)));
+}
+
+void PaymentAppDatabase::FetchPaymentAppInfoCallback(
+    const GURL& scope,
+    FetchAndWritePaymentAppInfoCallback callback,
+    const std::string& name,
+    const std::string& icon) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  payment_app_info_fetcher_ = nullptr;
+
+  service_worker_context_->FindReadyRegistrationForPattern(
+      scope,
+      base::Bind(&PaymentAppDatabase::DidFindRegistrationToWritePaymentAppInfo,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback)), name, icon));
+}
+
+void PaymentAppDatabase::DidFindRegistrationToWritePaymentAppInfo(
+    FetchAndWritePaymentAppInfoCallback callback,
+    const std::string& name,
+    const std::string& icon,
+    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;
+  }
+
+  StoredPaymentAppProto payment_app_proto;
+  payment_app_proto.set_registration_id(registration->id());
+  payment_app_proto.set_origin(registration->pattern().GetOrigin().spec());
+  payment_app_proto.set_name(name.empty() ? payment_app_proto.origin() : name);
+  payment_app_proto.set_icon(icon);
+
+  std::string serialized_payment_app;
+  bool success = payment_app_proto.SerializeToString(&serialized_payment_app);
+  DCHECK(success);
+
+  service_worker_context_->StoreRegistrationUserData(
+      registration->id(), registration->pattern().GetOrigin(),
+      {{CreatePaymentAppKey(registration->pattern().GetOrigin().spec()),
+        serialized_payment_app}},
+      base::Bind(&PaymentAppDatabase::DidWritePaymentApp,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback)),
+                 name.empty() | icon.empty()));
+}
+
+void PaymentAppDatabase::DidWritePaymentApp(
+    FetchAndWritePaymentAppInfoCallback callback,
+    bool fetch_app_info_failed,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  PaymentHandlerStatus handler_status =
+      fetch_app_info_failed
+          ? PaymentHandlerStatus::FETCH_PAYMENT_APP_INFO_FAILED
+          : PaymentHandlerStatus::SUCCESS;
+  handler_status = status == SERVICE_WORKER_OK
+                       ? handler_status
+                       : PaymentHandlerStatus::STORAGE_OPERATION_FAILED;
+  return std::move(callback).Run(handler_status);
+}
+
 void PaymentAppDatabase::ClearPaymentInstruments(
     const GURL& scope,
     ClearPaymentInstrumentsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
       base::Bind(
           &PaymentAppDatabase::DidFindRegistrationToClearPaymentInstruments,
           weak_ptr_factory_.GetWeakPtr(), scope,
           base::Passed(std::move(callback))));
 }
 
 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<StoredPaymentApp> app =
+        ToStoredPaymentApp(item_of_raw_data.second);
+    if (app)
+      apps[app->origin.GetURL()] = std::move(app);
+  }
+
+  if (apps.size() == 0U) {
+    std::move(callback).Run(PaymentApps());
+    return;
+  }
+
+  service_worker_context_->GetUserDataForAllRegistrationsByKeyPrefix(
+      kPaymentInstrumentPrefix,
+      base::Bind(&PaymentAppDatabase::DidReadAllPaymentInstruments,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(std::move(apps)),
+                 base::Passed(std::move(callback))));
+}
+
+void PaymentAppDatabase::DidReadAllPaymentInstruments(
+    PaymentApps apps,
+    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(std::move(apps));
+    return;
+  }
+
+  for (const auto& item_of_raw_data : raw_data) {
     std::unique_ptr<StoredPaymentInstrument> instrument =
         ToStoredPaymentInstrument(item_of_raw_data.second);
-    if (!instrument)
+    if (!instrument || !base::ContainsKey(apps, instrument->origin))
       continue;
-    if (!base::ContainsKey(apps, instrument->origin))
-      apps.insert(std::make_pair(instrument->origin, Instruments()));
-    apps[instrument->origin].push_back(std::move(instrument));
+    apps[instrument->origin]->instruments.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) {
@@ skipping 156 matching lines @@
     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;
   }
 
   StoredPaymentInstrumentProto instrument_proto;
   instrument_proto.set_decoded_instrument_icon(decoded_instrument_icon);
-  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);
   }
   for (const auto& image_object : instrument->icons) {
     StoredPaymentInstrumentImageObject* image_object_proto =
         instrument_proto.add_icons();
     image_object_proto->set_src(image_object->src.spec());
@@ skipping 41 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (status != SERVICE_WORKER_OK) {
     std::move(callback).Run(PaymentHandlerStatus::NO_ACTIVE_WORKER);
     return;
   }
 
   KeysOfPaymentInstruments(
       scope,
       base::BindOnce(&PaymentAppDatabase::DidGetKeysToClearPaymentInstruments,
-                     weak_ptr_factory_.GetWeakPtr(), registration->id(),
+                     weak_ptr_factory_.GetWeakPtr(), std::move(registration),
                      std::move(callback)));
 }
 
 void PaymentAppDatabase::DidGetKeysToClearPaymentInstruments(
-    int64_t registration_id,
+    scoped_refptr<ServiceWorkerRegistration> registration,
     ClearPaymentInstrumentsCallback callback,
     const std::vector<std::string>& keys,
     PaymentHandlerStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (status != PaymentHandlerStatus::SUCCESS) {
     std::move(callback).Run(PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
   std::vector<std::string> keys_with_prefix;
   for (const auto& key : keys) {
     keys_with_prefix.push_back(CreatePaymentInstrumentKey(key));
     keys_with_prefix.push_back(CreatePaymentInstrumentKeyInfoKey(key));
   }
 
+  // Clear payment app info after clearing all payment instruments.
+  keys_with_prefix.push_back(
+      CreatePaymentAppKey(registration->pattern().GetOrigin().spec()));
+
   service_worker_context_->ClearRegistrationUserData(
-      registration_id, keys_with_prefix,
+      registration->id(), keys_with_prefix,
       base::Bind(&PaymentAppDatabase::DidClearPaymentInstruments,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback))));
 }
 
 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