[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()) {
+    instrument->icons.emplace_back(
+        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<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());
+  }
   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 68 matching lines @@
                  base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::WritePaymentInstrument(
     const GURL& scope,
     const std::string& instrument_key,
     PaymentInstrumentPtr instrument,
     WritePaymentInstrumentCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  if (instrument->icons.size() > 0) {
+    instrument_icon_fetcher_ =
+        base::MakeRefCounted<PaymentInstrumentIconFetcher>();
+    instrument_icon_fetcher_->Start(
+        instrument->icons, service_worker_context_,
+        base::Bind(&PaymentAppDatabase::DidFetchedPaymentInstrumentIcon,
+                   weak_ptr_factory_.GetWeakPtr(), scope, instrument_key,
+                   base::Passed(std::move(instrument)),
+                   base::Passed(std::move(callback))));
+  } else {
+    service_worker_context_->FindReadyRegistrationForPattern(
+        scope,
+        base::Bind(
+            &PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument,
+            weak_ptr_factory_.GetWeakPtr(), instrument_key,
+            base::Passed(std::move(instrument)), std::string(),
+            base::Passed(std::move(callback))));
+  }
+}
+
+void PaymentAppDatabase::DidFetchedPaymentInstrumentIcon(
+    const GURL& scope,
+    const std::string& instrument_key,
+    payments::mojom::PaymentInstrumentPtr instrument,
+    WritePaymentInstrumentCallback callback,
+    const std::string& icon) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  instrument_icon_fetcher_ = nullptr;
+  if (icon.empty()) {
+    std::move(callback).Run(PaymentHandlerStatus::FETCH_INSTRUMENT_ICON_FAILED);
+    return;
+  }
+
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
       base::Bind(
           &PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument,
           weak_ptr_factory_.GetWeakPtr(), instrument_key,
-          base::Passed(std::move(instrument)),
+          base::Passed(std::move(instrument)), icon,
           base::Passed(std::move(callback))));
 }
 
 void PaymentAppDatabase::ClearPaymentInstruments(
     const GURL& scope,
     ClearPaymentInstrumentsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->FindReadyRegistrationForPattern(
       scope,
@@ skipping 179 matching lines @@
     std::move(callback).Run(PaymentHandlerStatus::NOT_FOUND);
     return;
   }
 
   std::move(callback).Run(PaymentHandlerStatus::SUCCESS);
 }
 
 void PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument(
     const std::string& instrument_key,
     PaymentInstrumentPtr instrument,
+    const std::string& decoded_instrument_icon,
     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;
   }
 
   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());
+  }
   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