PaymentHandler: Implement PaymentInstruments.has().

The method to check whether the payment instrument for the specified key is
stored.

Related Spec Link:
  https://w3c.github.io/webpayments-payment-handler/#paymentinstruments-interface

BUG=661608
TEST=payment_manager_unittest.cc, payment-instruments.html

Review-Url: https://codereview.chromium.org/2844673002
Cr-Commit-Position: refs/heads/master@{#467701}

components/payments/mojom/payment_app.mojom

@@ -52,6 +52,8 @@ interface PaymentManager {
       => (PaymentHandlerStatus status);
   SetPaymentInstrument(string instrument_key, PaymentInstrument instrument)
       => (PaymentHandlerStatus status);
+  HasPaymentInstrument(string instrument_key)
+      => (PaymentHandlerStatus status);
   GetPaymentInstrument(string instrument_key)
       => (PaymentInstrument instrument, PaymentHandlerStatus status);
 };

content/browser/payments/payment_app_database.cc

@@ -135,6 +135,19 @@ void PaymentAppDatabase::ReadPaymentInstrument(
           base::Passed(std::move(callback))));
 }
 
+void PaymentAppDatabase::HasPaymentInstrument(
+    const GURL& scope,
+    const std::string& instrument_key,
+    HasPaymentInstrumentCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  service_worker_context_->FindReadyRegistrationForPattern(
+      scope,
+      base::Bind(&PaymentAppDatabase::DidFindRegistrationToHasPaymentInstrument,
+                 weak_ptr_factory_.GetWeakPtr(), instrument_key,
+                 base::Passed(std::move(callback))));
+}
+
 void PaymentAppDatabase::WritePaymentInstrument(
     const GURL& scope,
     const std::string& instrument_key,
@@ -349,6 +362,39 @@ void PaymentAppDatabase::DidReadPaymentInstrument(
   std::move(callback).Run(std::move(instrument), PaymentHandlerStatus::SUCCESS);
 }
 
+void PaymentAppDatabase::DidFindRegistrationToHasPaymentInstrument(
+    const std::string& instrument_key,
+    HasPaymentInstrumentCallback 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;
+  }
+
+  service_worker_context_->GetRegistrationUserData(
+      registration->id(), {instrument_key},
+      base::Bind(&PaymentAppDatabase::DidHasPaymentInstrument,
+                 weak_ptr_factory_.GetWeakPtr(), registration->id(),
+                 instrument_key, base::Passed(std::move(callback))));
+}
+
+void PaymentAppDatabase::DidHasPaymentInstrument(
+    int64_t registration_id,
+    const std::string& instrument_key,
+    DeletePaymentInstrumentCallback callback,
+    const std::vector<std::string>& data,
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK || data.size() != 1) {
+    std::move(callback).Run(PaymentHandlerStatus::NOT_FOUND);
+    return;
+  }
+
+  std::move(callback).Run(PaymentHandlerStatus::SUCCESS);
+}
+
 void PaymentAppDatabase::DidFindRegistrationToWritePaymentInstrument(
     const std::string& instrument_key,
     PaymentInstrumentPtr instrument,

content/browser/payments/payment_app_database.h

@@ -37,6 +37,8 @@ class CONTENT_EXPORT PaymentAppDatabase {
   using ReadPaymentInstrumentCallback =
       base::OnceCallback<void(payments::mojom::PaymentInstrumentPtr,
                               payments::mojom::PaymentHandlerStatus)>;
+  using HasPaymentInstrumentCallback =
+      base::OnceCallback<void(payments::mojom::PaymentHandlerStatus)>;
   using WritePaymentInstrumentCallback =
       base::OnceCallback<void(payments::mojom::PaymentHandlerStatus)>;
 
@@ -55,6 +57,9 @@ class CONTENT_EXPORT PaymentAppDatabase {
   void ReadPaymentInstrument(const GURL& scope,
                              const std::string& instrument_key,
                              ReadPaymentInstrumentCallback callback);
+  void HasPaymentInstrument(const GURL& scope,
+                            const std::string& instrument_key,
+                            HasPaymentInstrumentCallback callback);
   void WritePaymentInstrument(const GURL& scope,
                               const std::string& instrument_key,
                               payments::mojom::PaymentInstrumentPtr instrument,
@@ -109,6 +114,18 @@ class CONTENT_EXPORT PaymentAppDatabase {
                                 const std::vector<std::string>& data,
                                 ServiceWorkerStatusCode status);
 
+  // HasPaymentInstrument callbacks
+  void DidFindRegistrationToHasPaymentInstrument(
+      const std::string& instrument_key,
+      HasPaymentInstrumentCallback callback,
+      ServiceWorkerStatusCode status,
+      scoped_refptr<ServiceWorkerRegistration> registration);
+  void DidHasPaymentInstrument(int64_t registration_id,
+                               const std::string& instrument_key,
+                               DeletePaymentInstrumentCallback callback,
+                               const std::vector<std::string>& data,
+                               ServiceWorkerStatusCode status);
+
   // WritePaymentInstrument callbacks
   void DidFindRegistrationToWritePaymentInstrument(
       const std::string& instrument_key,

content/browser/payments/payment_manager.cc

@@ -76,6 +76,15 @@ void PaymentManager::SetPaymentInstrument(
       scope_, instrument_key, std::move(details), callback);
 }
 
+void PaymentManager::HasPaymentInstrument(
+    const std::string& instrument_key,
+    const HasPaymentInstrumentCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  payment_app_context_->payment_app_database()->HasPaymentInstrument(
+      scope_, instrument_key, callback);
+}
+
 void PaymentManager::GetPaymentInstrument(
     const std::string& instrument_key,
     const PaymentManager::GetPaymentInstrumentCallback& callback) {

content/browser/payments/payment_manager.h

@@ -43,6 +43,9 @@ class CONTENT_EXPORT PaymentManager
       const std::string& instrument_key,
       payments::mojom::PaymentInstrumentPtr details,
       const SetPaymentInstrumentCallback& callback) override;
+  void HasPaymentInstrument(
+      const std::string& instrument_key,
+      const HasPaymentInstrumentCallback& callback) override;
   void GetPaymentInstrument(
       const std::string& instrument_key,
       const GetPaymentInstrumentCallback& callback) override;

content/browser/payments/payment_manager_unittest.cc

@@ -50,6 +50,11 @@ void SetPaymentInstrumentCallback(PaymentHandlerStatus* out_status,
   *out_status = status;
 }
 
+void HasPaymentInstrumentCallback(PaymentHandlerStatus* out_status,
+                                  PaymentHandlerStatus status) {
+  *out_status = status;
+}
+
 void GetPaymentInstrumentCallback(PaymentInstrumentPtr* out_instrument,
                                   PaymentHandlerStatus* out_status,
                                   PaymentInstrumentPtr instrument,
@@ -87,6 +92,13 @@ class PaymentManagerTest : public PaymentAppContentUnitTestBase {
     base::RunLoop().RunUntilIdle();
   }
 
+  void HasPaymentInstrument(const std::string& instrument_key,
+                            PaymentHandlerStatus* out_status) {
+    manager_->HasPaymentInstrument(
+        instrument_key, base::Bind(&HasPaymentInstrumentCallback, out_status));
+    base::RunLoop().RunUntilIdle();
+  }
+
   void GetPaymentInstrument(const std::string& instrument_key,
                             PaymentInstrumentPtr* out_instrument,
                             PaymentHandlerStatus* out_status) {
@@ -175,13 +187,11 @@ TEST_F(PaymentManagerTest, SetAndGetPaymentInstrument) {
   write_details->name = "Visa ending ****4756",
   write_details->enabled_methods.push_back("visa");
   write_details->stringified_capabilities = "{}";
-  ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, write_status);
   SetPaymentInstrument("test_key", std::move(write_details), &write_status);
   ASSERT_EQ(PaymentHandlerStatus::SUCCESS, write_status);
 
   PaymentHandlerStatus read_status = PaymentHandlerStatus::NOT_FOUND;
   PaymentInstrumentPtr read_details;
-  ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, read_status);
   GetPaymentInstrument("test_key", &read_details, &read_status);
   ASSERT_EQ(PaymentHandlerStatus::SUCCESS, read_status);
   EXPECT_EQ("Visa ending ****4756", read_details->name);
@@ -193,7 +203,6 @@ TEST_F(PaymentManagerTest, SetAndGetPaymentInstrument) {
 TEST_F(PaymentManagerTest, GetUnstoredPaymentInstrument) {
   PaymentHandlerStatus read_status = PaymentHandlerStatus::SUCCESS;
   PaymentInstrumentPtr read_details;
-  ASSERT_EQ(PaymentHandlerStatus::SUCCESS, read_status);
   GetPaymentInstrument("test_key", &read_details, &read_status);
   ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, read_status);
 }
@@ -204,13 +213,11 @@ TEST_F(PaymentManagerTest, DeletePaymentInstrument) {
   write_details->name = "Visa ending ****4756",
   write_details->enabled_methods.push_back("visa");
   write_details->stringified_capabilities = "{}";
-  ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, write_status);
   SetPaymentInstrument("test_key", std::move(write_details), &write_status);
   ASSERT_EQ(PaymentHandlerStatus::SUCCESS, write_status);
 
   PaymentHandlerStatus read_status = PaymentHandlerStatus::NOT_FOUND;
   PaymentInstrumentPtr read_details;
-  ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, read_status);
   GetPaymentInstrument("test_key", &read_details, &read_status);
   ASSERT_EQ(PaymentHandlerStatus::SUCCESS, read_status);
 
@@ -223,4 +230,21 @@ TEST_F(PaymentManagerTest, DeletePaymentInstrument) {
   ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, read_status);
 }
 
+TEST_F(PaymentManagerTest, HasPaymentInstrument) {
+  PaymentHandlerStatus write_status = PaymentHandlerStatus::NOT_FOUND;
+  PaymentInstrumentPtr write_details = PaymentInstrument::New();
+  write_details->name = "Visa ending ****4756",
+  write_details->enabled_methods.push_back("visa");
+  write_details->stringified_capabilities = "{}";
+  SetPaymentInstrument("test_key", std::move(write_details), &write_status);
+  ASSERT_EQ(PaymentHandlerStatus::SUCCESS, write_status);
+
+  PaymentHandlerStatus has_status = PaymentHandlerStatus::NOT_FOUND;
+  HasPaymentInstrument("test_key", &has_status);
+  ASSERT_EQ(PaymentHandlerStatus::SUCCESS, has_status);
+
+  HasPaymentInstrument("unstored_test_key", &has_status);
+  ASSERT_EQ(PaymentHandlerStatus::NOT_FOUND, has_status);
+}
+
 }  // namespace content

third_party/WebKit/LayoutTests/http/tests/payments/payment-instruments.html

@@ -82,4 +82,41 @@ promise_test(test => {
       .catch(unreached_rejection(test));
   }, 'PaymentInstruments delete method test');
 
+promise_test(test => {
+    var registration;
+    var script_url = 'resources/empty-worker.js';
+    var scope = 'resources/';
+
+    return service_worker_unregister_and_register(test, script_url, scope)
+      .then(r => {
+          registration = r;
+          return wait_for_state(test, registration.installing, 'activated');
+        })
+      .then(state => {
+          assert_equals(state, 'activated');
+          return registration.paymentManager.instruments.set(
+              'test_key',
+              {
+                name: 'Visa ending ****4756',
+                enabledMethods: ['basic-card'],
+                capabilities: {
+                  supportedNetworks: ['visa'],
+                  supportedTypes: ['credit']
+                }
+              });
+        })
+      .then(result => {
+          assert_equals(result, undefined);
+          return registration.paymentManager.instruments.has('test_key');
+        })
+      .then(result => {
+          assert_equals(result, true);
+          return registration.paymentManager.instruments.has('unstored_test_key');
+        })
+      .then(result => {
+          assert_equals(result, false);
+        })
+      .catch(unreached_rejection(test));
+  }, 'PaymentInstruments |has| method test');
+
 </script>

third_party/WebKit/Source/modules/payments/PaymentInstruments.cpp

@@ -94,9 +94,22 @@ ScriptPromise PaymentInstruments::keys() {
   return ScriptPromise();
 }
 
-ScriptPromise PaymentInstruments::has(const String& instrument_key) {
-  NOTIMPLEMENTED();
-  return ScriptPromise();
+ScriptPromise PaymentInstruments::has(ScriptState* script_state,
+                                      const String& instrument_key) {
+  if (!manager_.is_bound()) {
+    return ScriptPromise::RejectWithDOMException(
+        script_state,
+        DOMException::Create(kInvalidStateError, kPaymentManagerUnavailable));
+  }
+
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
+  ScriptPromise promise = resolver->Promise();
+
+  manager_->HasPaymentInstrument(
+      instrument_key, ConvertToBaseCallback(WTF::Bind(
+                          &PaymentInstruments::onHasPaymentInstrument,
+                          WrapPersistent(this), WrapPersistent(resolver))));
+  return promise;
 }
 
 ScriptPromise PaymentInstruments::set(ScriptState* script_state,
@@ -184,6 +197,14 @@ void PaymentInstruments::onGetPaymentInstrument(
   resolver->Resolve(instrument);
 }
 
+void PaymentInstruments::onHasPaymentInstrument(
+    ScriptPromiseResolver* resolver,
+    payments::mojom::blink::PaymentHandlerStatus status) {
+  DCHECK(resolver);
+  resolver->Resolve(status ==
+                    payments::mojom::blink::PaymentHandlerStatus::SUCCESS);
+}
+
 void PaymentInstruments::onSetPaymentInstrument(
     ScriptPromiseResolver* resolver,
     payments::mojom::blink::PaymentHandlerStatus status) {

third_party/WebKit/Source/modules/payments/PaymentInstruments.h

@@ -32,7 +32,7 @@ class MODULES_EXPORT PaymentInstruments final
   ScriptPromise deleteInstrument(ScriptState*, const String& instrument_key);
   ScriptPromise get(ScriptState*, const String& instrument_key);
   ScriptPromise keys();
-  ScriptPromise has(const String& instrument_key);
+  ScriptPromise has(ScriptState*, const String& instrument_key);
   ScriptPromise set(ScriptState*,
                     const String& instrument_key,
                     const PaymentInstrument& details,
@@ -46,6 +46,8 @@ class MODULES_EXPORT PaymentInstruments final
   void onGetPaymentInstrument(ScriptPromiseResolver*,
                               payments::mojom::blink::PaymentInstrumentPtr,
                               payments::mojom::blink::PaymentHandlerStatus);
+  void onHasPaymentInstrument(ScriptPromiseResolver*,
+                              payments::mojom::blink::PaymentHandlerStatus);
   void onSetPaymentInstrument(ScriptPromiseResolver*,
                               payments::mojom::blink::PaymentHandlerStatus);
 

third_party/WebKit/Source/modules/payments/PaymentInstruments.idl

@@ -11,6 +11,6 @@
     [CallWith=ScriptState, ImplementedAs=deleteInstrument] Promise<boolean> delete(DOMString instrumentKey);
     [CallWith=ScriptState] Promise<PaymentInstrument> get(DOMString instrumentKey);
     Promise<sequence<DOMString>> keys();
-    Promise<boolean> has(DOMString instrumentKey);
+    [CallWith=ScriptState] Promise<boolean> has(DOMString instrumentKey);
     [CallWith=ScriptState, RaisesException] Promise<void> set(DOMString instrumentKey, PaymentInstrument details);
 };