[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();
+    image_object->sizes = icon.sizes();
+    image_object->type = icon.type();
+    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);
+    gfx::Image icon_image = gfx::Image::CreateFrom1xPNGBytes(

[please use gerrit instead, 2017/06/08 21:34:10]

Add a note that you've converted the image to PNG at this point already,
regardless of the icon format that was downloaded.

[gogerald1, 2017/06/09 14:23:24]

Done.

+        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)
@@ 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);
+    image_object_proto->set_sizes(image_object->sizes);
+    image_object_proto->set_type(image_object->type);
+  }
   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