[Payments] Return a basic card response

components/payments/content/payment_request.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 "components/payments/content/payment_request.h"
 
 #include <algorithm>
 #include <unordered_map>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "components/autofill/core/browser/autofill_data_util.h"
 #include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/payments/content/payment_details_validation.h"
 #include "components/payments/content/payment_request_web_contents_manager.h"
+#include "components/payments/core/autofill_payment_instrument.h"
 #include "components/payments/core/currency_formatter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 
 namespace payments {
 
+namespace {
+// Identifier for the basic card payment method in the PaymentMethodData.
+static const char* const kBasicCardMethodName = "basic-card";
+}  // namespace
+
 PaymentRequest::PaymentRequest(
     content::WebContents* web_contents,
     std::unique_ptr<PaymentRequestDelegate> delegate,
     PaymentRequestWebContentsManager* manager,
     mojo::InterfaceRequest<payments::mojom::PaymentRequest> request)
     : web_contents_(web_contents),
       delegate_(std::move(delegate)),
       manager_(manager),
       binding_(this, std::move(request)),
       is_ready_to_pay_(false),
@@ skipping 41 matching lines @@
 }
 
 void PaymentRequest::Abort() {
   // The API user has decided to abort. We return a successful abort message to
   // the renderer, which closes the Mojo message pipe, which triggers
   // PaymentRequest::OnConnectionTerminated, which destroys this object.
   if (client_.is_bound())
     client_->OnAbort(true /* aborted_successfully */);
 }
 
+void PaymentRequest::Complete(payments::mojom::PaymentComplete result) {
+  if (!client_.is_bound())
+    return;
+
+  // TODO(mathp): Validate |result|.
+
+  // When the renderer closes the connection,
+  // PaymentRequest::OnConnectionTerminated will be called.
+  client_->OnComplete();
+}
+
+void PaymentRequest::CanMakePayment() {
+  // TODO(mathp): Return whether we can make payment.
+  client_->OnCanMakePayment(mojom::CanMakePaymentQueryResult::CAN_MAKE_PAYMENT);
+}
+
+void PaymentRequest::OnInstrumentDetailsReady(
+    const std::string& method_name,
+    const std::string& stringified_details) {
+  payment_response_->method_name = method_name;
+  payment_response_->stringified_details = stringified_details;
+  client_->OnPaymentResponse(std::move(payment_response_));
+}
+
 void PaymentRequest::UserCancelled() {
   // If |client_| is not bound, then the object is already being destroyed as
   // a result of a renderer event.
   if (!client_.is_bound())
     return;
 
   // This sends an error to the renderer, which informs the API user.
   client_->OnError(payments::mojom::PaymentErrorReason::USER_CANCEL);
 
   // We close all bindings and ask to be destroyed.
@@ skipping 10 matching lines @@
   // the binding and the dialog, and ask to be deleted.
   client_.reset();
   binding_.Close();
   delegate_->CloseDialog();
   manager_->DestroyRequest(this);
 }
 
 void PaymentRequest::Pay() {
   DCHECK(is_ready_to_pay_);
 
-  // TODO(mathp): Return the PaymentResponse to the |client_|.
-  OnConnectionTerminated();
+  // TODO(mathp): Fill other fields in the PaymentResponsePtr object.
+  payment_response_ = mojom::PaymentResponse::New();
+
+  // TODO(mathp): PaymentRequest should know about the currently selected
+  // instrument, and not |selected_credit_card_| which is too specific.
+  // TODO(mathp): The method_name should reflect what the merchant asked, and
+  // not necessarily basic-card.
+  selected_payment_instrument_.reset(new AutofillPaymentInstrument(
+      kBasicCardMethodName, *selected_credit_card_, shipping_profiles_,
+      delegate_->GetApplicationLocale()));
+  // Fetch the instrument details, will call back into
+  // PaymentRequest::OnInstrumentsDetailsReady.
+  selected_payment_instrument_->InvokePaymentApp(this);
 }
 
 void PaymentRequest::AddObserver(Observer* observer) {
   CHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void PaymentRequest::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 90 matching lines @@
 }
 
 void PaymentRequest::PopulateValidatedMethodData(
     const std::vector<payments::mojom::PaymentMethodDataPtr>& method_data) {
   if (method_data.empty()) {
     LOG(ERROR) << "Invalid payment methods or data";
     OnConnectionTerminated();
     return;
   }
 
-  // Identifier for the basic card payment method in the PaymentMethodData.
-  const char* const kBasicCardMethodName = "basic-card";
   std::set<std::string> card_networks{"amex",     "diners",     "discover",
                                       "jcb",      "mastercard", "mir",
                                       "unionpay", "visa"};
   for (const payments::mojom::PaymentMethodDataPtr& method_data_entry :
        method_data) {
     std::vector<std::string> supported_methods =
         method_data_entry->supported_methods;
     if (supported_methods.empty()) {
       LOG(ERROR) << "Invalid payment methods or data";
       OnConnectionTerminated();
@@ skipping 104 matching lines @@
            ->GetInfo(autofill::AutofillType(autofill::PHONE_HOME_WHOLE_NUMBER),
                      app_locale)
            .empty())) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace payments