[Payments] Implement payment instrument icons

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 "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image.h"
 
 namespace content {
 namespace {
 
 using ::payments::mojom::PaymentHandlerStatus;
 using ::payments::mojom::PaymentInstrument;
 using ::payments::mojom::PaymentInstrumentPtr;
 
 const char kPaymentInstrumentPrefix[] = "PaymentInstrument:";
 const char kPaymentInstrumentKeyInfoPrefix[] = "PaymentInstrumentKeyInfo:";
@@ skipping 22 matching lines @@
   return key_info;
 }
 
 PaymentInstrumentPtr ToPaymentInstrumentForMojo(const std::string& input) {
   StoredPaymentInstrumentProto instrument_proto;
   if (!instrument_proto.ParseFromString(input))
     return nullptr;
 
   PaymentInstrumentPtr instrument = PaymentInstrument::New();
   instrument->name = instrument_proto.name();
+  for (const auto& icon : instrument_proto.icons()) {
+    payments::mojom::ImageObjectPtr image_object =
+        payments::mojom::ImageObject::New();
+    image_object->src = icon.src();
+    instrument->icons.emplace_back(std::move(image_object));
+  }
   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<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.
+    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());

[zino, 2017/06/09 20:29:48]

Although there is no desktop implementation yet, we can not use each different
icon in desktop and mobile.
We will have to store multiple icons unless Chrome decided to use only one
size/type icon in all platforms and all screens.
(But leaving a comment and filing bug is okay for now.)

It might be better to fetch and cache before actual displaying the icon.

[gogerald1, 2017/06/09 22:25:02]

yep, I added TODO on the start interface,

+  }
   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)
@@ skipping 282 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;
   }
 
+  instrument_icon_fetcher_ = base::MakeUnique<PaymentInstrumentIconFetcher>();
+  instrument_icon_fetcher_->start(
+      registration->pattern(), instrument->icons, service_worker_context_,
+      base::Bind(&PaymentAppDatabase::DidFetchedPaymentInstrumentIcon,
+                 weak_ptr_factory_.GetWeakPtr(), instrument_key,
+                 base::Passed(std::move(instrument)),
+                 base::Passed(std::move(callback)),
+                 base::Passed(std::move(registration))));
+}
+
+void PaymentAppDatabase::DidFetchedPaymentInstrumentIcon(
+    const std::string& instrument_key,
+    payments::mojom::PaymentInstrumentPtr instrument,
+    WritePaymentInstrumentCallback callback,
+    scoped_refptr<ServiceWorkerRegistration> registration,
+    const std::string& icon) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  instrument_icon_fetcher_.reset(nullptr);
+  if (icon.empty()) {
+    std::move(callback).Run(PaymentHandlerStatus::FETCH_INSTRUMENT_ICON_FAILED);
+    return;
+  }
+
   StoredPaymentInstrumentProto instrument_proto;
+  instrument_proto.set_decoded_instrument_icon(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);
+  }
   instrument_proto.set_stringified_capabilities(
       instrument->stringified_capabilities);
 
   std::string serialized_instrument;
   bool success = instrument_proto.SerializeToString(&serialized_instrument);
   DCHECK(success);
 
   StoredPaymentInstrumentKeyInfoProto key_info_proto;
   key_info_proto.set_key(instrument_key);
   key_info_proto.set_insertion_order(base::Time::Now().ToInternalValue());
@@ skipping 69 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