[Payments] Present web payment app instead of instruments to user

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;
@@ skipping 67 matching lines @@
     // 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->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.
-    gfx::Image icon_image = gfx::Image::CreateFrom1xPNGBytes(
-        reinterpret_cast<const unsigned char*>(icon_raw_data.data()),
-        icon_raw_data.size());
-    instrument->icon = base::MakeUnique<SkBitmap>(icon_image.AsBitmap());
-  }
-  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 237 matching lines @@
     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 || !base::ContainsKey(apps, instrument->origin))
+    StoredPaymentInstrumentProto instrument_proto;
+    if (!instrument_proto.ParseFromString(item_of_raw_data.second))
       continue;
-    apps[instrument->origin]->instruments.push_back(std::move(instrument));
+
+    GURL origin = GURL(instrument_proto.origin());
+    if (!base::ContainsKey(apps, origin))
+      continue;
+
+    for (const auto& method : instrument_proto.enabled_methods()) {
+      apps[origin]->enabled_methods.push_back(method);
+    }
   }
 
   std::move(callback).Run(std::move(apps));
 }
 
 void PaymentAppDatabase::DidFindRegistrationToDeletePaymentInstrument(
     const std::string& instrument_key,
     DeletePaymentInstrumentCallback callback,
     ServiceWorkerStatusCode status,
     scoped_refptr<ServiceWorkerRegistration> registration) {
@@ skipping 260 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