| // 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 <string> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/feature_list.h" |
| #include "base/stl_util.h" |
| #include "base/strings/string_util.h" |
| #include "components/payments/content/can_make_payment_query_factory.h" |
| #include "components/payments/content/content_payment_request_delegate.h" |
| #include "components/payments/content/payment_details_converter.h" |
| #include "components/payments/content/payment_request_converter.h" |
| #include "components/payments/content/payment_request_web_contents_manager.h" |
| #include "components/payments/content/service_worker_payment_instrument.h" |
| #include "components/payments/core/can_make_payment_query.h" |
| #include "components/payments/core/error_strings.h" |
| #include "components/payments/core/features.h" |
| #include "components/payments/core/native_error_strings.h" |
| #include "components/payments/core/payment_details.h" |
| #include "components/payments/core/payment_details_validation.h" |
| #include "components/payments/core/payment_instrument.h" |
| #include "components/payments/core/payment_prefs.h" |
| #include "components/payments/core/payments_experimental_features.h" |
| #include "components/payments/core/payments_validators.h" |
| #include "components/payments/core/url_util.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/ukm/content/source_url_recorder.h" |
| #include "components/url_formatter/elide_url.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/render_frame_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/content_features.h" |
| #include "content/public/common/origin_util.h" |
| |
| namespace payments { |
| namespace { |
| |
| using ::payments::mojom::CanMakePaymentQueryResult; |
| using ::payments::mojom::HasEnrolledInstrumentQueryResult; |
| |
| bool IsGooglePaymentMethodInstrumentSelected(const std::string& method_name) { |
| return method_name == kGooglePayMethodName || |
| method_name == kAndroidPayMethodName; |
| } |
| |
| std::string GetNotSupportedErrorMessage(PaymentRequestSpec* spec) { |
| if (!spec || spec->payment_method_identifiers_set().empty()) |
| return errors::kGenericPaymentMethodNotSupportedMessage; |
| |
| std::vector<std::string> method_names( |
| spec->payment_method_identifiers_set().size()); |
| std::transform( |
| spec->payment_method_identifiers_set().begin(), |
| spec->payment_method_identifiers_set().end(), method_names.begin(), |
| [](const std::string& method_name) { return "\"" + method_name + "\""; }); |
| |
| std::string output; |
| bool replaced = base::ReplaceChars( |
| method_names.size() == 1 |
| ? errors::kSinglePaymentMethodNotSupportedFormat |
| : errors::kMultiplePaymentMethodsNotSupportedFormat, |
| "$", base::JoinString(method_names, ", "), &output); |
| DCHECK(replaced); |
| return output; |
| } |
| |
| } // namespace |
| |
| PaymentRequest::PaymentRequest( |
| content::RenderFrameHost* render_frame_host, |
| content::WebContents* web_contents, |
| std::unique_ptr<ContentPaymentRequestDelegate> delegate, |
| PaymentRequestWebContentsManager* manager, |
| PaymentRequestDisplayManager* display_manager, |
| mojo::InterfaceRequest<mojom::PaymentRequest> request, |
| ObserverForTest* observer_for_testing) |
| : web_contents_(web_contents), |
| log_(web_contents_), |
| delegate_(std::move(delegate)), |
| manager_(manager), |
| display_manager_(display_manager), |
| display_handle_(nullptr), |
| binding_(this, std::move(request)), |
| payment_handler_host_(this), |
| top_level_origin_(url_formatter::FormatUrlForSecurityDisplay( |
| web_contents_->GetLastCommittedURL())), |
| frame_origin_(url_formatter::FormatUrlForSecurityDisplay( |
| render_frame_host->GetLastCommittedURL())), |
| observer_for_testing_(observer_for_testing), |
| journey_logger_(delegate_->IsIncognito(), |
| ukm::GetSourceIdForWebContentsDocument(web_contents)) { |
| // OnConnectionTerminated will be called when the Mojo pipe is closed. This |
| // will happen as a result of many renderer-side events (both successful and |
| // erroneous in nature). |
| // TODO(crbug.com/683636): Investigate using |
| // set_connection_error_with_reason_handler with Binding::CloseWithReason. |
| binding_.set_connection_error_handler(base::BindOnce( |
| &PaymentRequest::OnConnectionTerminated, weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| PaymentRequest::~PaymentRequest() {} |
| |
| void PaymentRequest::Init(mojom::PaymentRequestClientPtr client, |
| std::vector<mojom::PaymentMethodDataPtr> method_data, |
| mojom::PaymentDetailsPtr details, |
| mojom::PaymentOptionsPtr options) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| if (is_initialized_) { |
| log_.Error(errors::kAttemptedInitializationTwice); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| is_initialized_ = true; |
| client_ = std::move(client); |
| |
| const GURL last_committed_url = delegate_->GetLastCommittedURL(); |
| if (!content::IsOriginSecure(last_committed_url)) { |
| log_.Error(errors::kNotInASecureOrigin); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| // TODO(crbug.com/978471): Improve architecture for handling prohibited |
| // origins and invalid SSL certificates. |
| bool allowed_origin = |
| UrlUtil::IsOriginAllowedToUseWebPaymentApis(last_committed_url); |
| if (!allowed_origin) { |
| reject_show_error_message_ = errors::kProhibitedOrigin; |
| } |
| |
| bool invalid_ssl = false; |
| if (last_committed_url.SchemeIsCryptographic()) { |
| DCHECK(reject_show_error_message_.empty()); |
| reject_show_error_message_ = |
| delegate_->GetInvalidSslCertificateErrorMessage(); |
| invalid_ssl = !reject_show_error_message_.empty(); |
| } |
| |
| if (!allowed_origin || invalid_ssl) { |
| // Intentionally don't set |spec_| and |state_|, so the UI is never shown. |
| log_.Error(reject_show_error_message_); |
| log_.Error(errors::kProhibitedOriginOrInvalidSslExplanation); |
| return; |
| } |
| |
| std::string error; |
| if (!ValidatePaymentDetails(ConvertPaymentDetails(details), &error)) { |
| log_.Error(error); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!details->total) { |
| log_.Error(errors::kTotalRequired); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| spec_ = std::make_unique<PaymentRequestSpec>( |
| std::move(options), std::move(details), std::move(method_data), this, |
| delegate_->GetApplicationLocale()); |
| state_ = std::make_unique<PaymentRequestState>( |
| web_contents_, top_level_origin_, frame_origin_, spec_.get(), this, |
| delegate_->GetApplicationLocale(), delegate_->GetPersonalDataManager(), |
| delegate_.get(), &journey_logger_); |
| |
| journey_logger_.SetRequestedInformation( |
| spec_->request_shipping(), spec_->request_payer_email(), |
| spec_->request_payer_phone(), spec_->request_payer_name()); |
| |
| // Log metrics around which payment methods are requested by the merchant. |
| GURL google_pay_url(kGooglePayMethodName); |
| GURL android_pay_url(kAndroidPayMethodName); |
| // Looking for payment methods that are NOT google-related payment methods. |
| auto non_google_it = |
| std::find_if(spec_->url_payment_method_identifiers().begin(), |
| spec_->url_payment_method_identifiers().end(), |
| [google_pay_url, android_pay_url](const GURL& url) { |
| return url != google_pay_url && url != android_pay_url; |
| }); |
| journey_logger_.SetRequestedPaymentMethodTypes( |
| /*requested_basic_card=*/!spec_->supported_card_networks().empty(), |
| /*requested_method_google=*/ |
| base::Contains(spec_->url_payment_method_identifiers(), google_pay_url) || |
| base::Contains(spec_->url_payment_method_identifiers(), |
| android_pay_url), |
| /*requested_method_other=*/non_google_it != |
| spec_->url_payment_method_identifiers().end()); |
| } |
| |
| void PaymentRequest::Show(bool is_user_gesture, bool wait_for_updated_details) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotShowWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (is_show_called_) { |
| log_.Error(errors::kCannotShowTwice); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| is_show_called_ = true; |
| |
| // A tab can display only one PaymentRequest UI at a time. |
| display_handle_ = display_manager_->TryShow(delegate_.get()); |
| if (!display_handle_) { |
| log_.Error(errors::kAnotherUiShowing); |
| DCHECK(!has_recorded_completion_); |
| has_recorded_completion_ = true; |
| journey_logger_.SetNotShown( |
| JourneyLogger::NOT_SHOWN_REASON_CONCURRENT_REQUESTS); |
| client_->OnError(mojom::PaymentErrorReason::ALREADY_SHOWING, |
| errors::kAnotherUiShowing); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!delegate_->IsBrowserWindowActive()) { |
| log_.Error(errors::kCannotShowInBackgroundTab); |
| DCHECK(!has_recorded_completion_); |
| has_recorded_completion_ = true; |
| journey_logger_.SetNotShown(JourneyLogger::NOT_SHOWN_REASON_OTHER); |
| client_->OnError(mojom::PaymentErrorReason::USER_CANCEL, |
| errors::kCannotShowInBackgroundTab); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!state_) { |
| // SSL is not valid. Reject show with NotSupportedError, disconnect the |
| // mojo pipe, and destroy this object. |
| AreRequestedMethodsSupportedCallback(false, reject_show_error_message_); |
| return; |
| } |
| |
| is_show_user_gesture_ = is_user_gesture; |
| |
| if (wait_for_updated_details) { |
| // Put |spec_| into uninitialized state, so the UI knows to show a spinner. |
| // This method does not block. |
| spec_->StartWaitingForUpdateWith( |
| PaymentRequestSpec::UpdateReason::INITIAL_PAYMENT_DETAILS); |
| } else { |
| DCHECK(spec_->details().total); |
| journey_logger_.RecordTransactionAmount( |
| spec_->details().total->amount->currency, |
| spec_->details().total->amount->value, false /*completed*/); |
| } |
| |
| display_handle_->Show(this); |
| state_->AreRequestedMethodsSupported( |
| base::BindOnce(&PaymentRequest::AreRequestedMethodsSupportedCallback, |
| weak_ptr_factory_.GetWeakPtr())); |
| } |
| |
| void PaymentRequest::Retry(mojom::PaymentValidationErrorsPtr errors) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotRetryWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!IsThisPaymentRequestShowing()) { |
| log_.Error(errors::kCannotRetryWithoutShow); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| std::string error; |
| if (!PaymentsValidators::IsValidPaymentValidationErrorsFormat(errors, |
| &error)) { |
| log_.Error(error); |
| client_->OnError(mojom::PaymentErrorReason::USER_CANCEL, error); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| spec()->Retry(std::move(errors)); |
| display_handle_->Retry(); |
| } |
| |
| void PaymentRequest::UpdateWith(mojom::PaymentDetailsPtr details) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotUpdateWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!IsThisPaymentRequestShowing()) { |
| log_.Error(errors::kCannotUpdateWithoutShow); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| std::string error; |
| if (!ValidatePaymentDetails(ConvertPaymentDetails(details), &error)) { |
| log_.Error(error); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (details->shipping_address_errors && |
| !PaymentsValidators::IsValidAddressErrorsFormat( |
| details->shipping_address_errors, &error)) { |
| log_.Error(error); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (state()->selected_instrument() && state()->IsPaymentAppInvoked() && |
| payment_handler_host_.is_changing_payment_method()) { |
| payment_handler_host_.UpdateWith( |
| PaymentDetailsConverter::ConvertToPaymentMethodChangeResponse( |
| details, base::BindRepeating( |
| &PaymentInstrument::IsValidForPaymentMethodIdentifier, |
| base::Unretained(state()->selected_instrument())))); |
| } |
| |
| bool is_resolving_promise_passed_into_show_method = !spec_->IsInitialized(); |
| |
| spec_->UpdateWith(std::move(details)); |
| |
| if (is_resolving_promise_passed_into_show_method) { |
| DCHECK(spec_->details().total); |
| journey_logger_.RecordTransactionAmount( |
| spec_->details().total->amount->currency, |
| spec_->details().total->amount->value, false /*completed*/); |
| if (SatisfiesSkipUIConstraints()) { |
| Pay(); |
| } else if (spec_->request_shipping()) { |
| state_->SelectDefaultShippingAddressAndNotifyObservers(); |
| } |
| } |
| } |
| |
| void PaymentRequest::NoUpdatedPaymentDetails() { |
| // This Mojo call is triggered by the user of the API doing nothing in |
| // response to a shipping address update event, so the error messages cannot |
| // be more verbose. |
| if (!IsInitialized()) { |
| log_.Error(errors::kNotInitialized); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!IsThisPaymentRequestShowing()) { |
| log_.Error(errors::kNotShown); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| spec_->RecomputeSpecForDetails(); |
| |
| if (state()->IsPaymentAppInvoked() && |
| payment_handler_host_.is_changing_payment_method()) { |
| payment_handler_host_.NoUpdatedPaymentDetails(); |
| } |
| } |
| |
| void PaymentRequest::Abort() { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotAbortWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!IsThisPaymentRequestShowing()) { |
| log_.Error(errors::kCannotAbortWithoutShow); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| // The API user has decided to abort. If a successful abort message is |
| // returned to the renderer, the Mojo message pipe is closed, which triggers |
| // PaymentRequest::OnConnectionTerminated, which destroys this object. |
| // Otherwise, the abort promise is rejected and the pipe is not closed. |
| // The abort is only successful if the payment app wasn't yet invoked. |
| // TODO(crbug.com/716546): Add a merchant abort metric |
| |
| bool accepting_abort = !state_->IsPaymentAppInvoked(); |
| if (accepting_abort) |
| RecordFirstAbortReason(JourneyLogger::ABORT_REASON_ABORTED_BY_MERCHANT); |
| |
| if (client_.is_bound()) |
| client_->OnAbort(accepting_abort); |
| |
| if (observer_for_testing_) |
| observer_for_testing_->OnAbortCalled(); |
| } |
| |
| void PaymentRequest::Complete(mojom::PaymentComplete result) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotCompleteWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| if (!IsThisPaymentRequestShowing()) { |
| log_.Error(errors::kCannotAbortWithoutShow); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| // Failed transactions show an error. Successful and unknown-state |
| // transactions don't show an error. |
| if (result == mojom::PaymentComplete::FAIL) { |
| delegate_->ShowErrorMessage(); |
| } else { |
| DCHECK(!has_recorded_completion_); |
| journey_logger_.SetCompleted(); |
| has_recorded_completion_ = true; |
| DCHECK(spec_->details().total); |
| journey_logger_.RecordTransactionAmount( |
| spec_->details().total->amount->currency, |
| spec_->details().total->amount->value, true /*completed*/); |
| |
| delegate_->GetPrefService()->SetBoolean(kPaymentsFirstTransactionCompleted, |
| true); |
| // When the renderer closes the connection, |
| // PaymentRequest::OnConnectionTerminated will be called. |
| client_->OnComplete(); |
| state_->RecordUseStats(); |
| } |
| } |
| |
| void PaymentRequest::CanMakePayment(bool legacy_mode) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotCallCanMakePaymentWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| // It's valid to call canMakePayment() without calling show() first. |
| |
| if (observer_for_testing_) |
| observer_for_testing_->OnCanMakePaymentCalled(); |
| |
| if (!delegate_->GetPrefService()->GetBoolean(kCanMakePaymentEnabled) || |
| !state_) { |
| CanMakePaymentCallback(legacy_mode, /*can_make_payment=*/false); |
| } else { |
| state_->CanMakePayment( |
| legacy_mode, |
| base::BindOnce(&PaymentRequest::CanMakePaymentCallback, |
| weak_ptr_factory_.GetWeakPtr(), legacy_mode)); |
| } |
| } |
| |
| void PaymentRequest::HasEnrolledInstrument(bool per_method_quota) { |
| if (!IsInitialized()) { |
| log_.Error(errors::kCannotCallHasEnrolledInstrumentWithoutInit); |
| OnConnectionTerminated(); |
| return; |
| } |
| |
| // It's valid to call hasEnrolledInstrument() without calling show() first. |
| |
| if (observer_for_testing_) |
| observer_for_testing_->OnHasEnrolledInstrumentCalled(); |
| |
| if (!delegate_->GetPrefService()->GetBoolean(kCanMakePaymentEnabled) || |
| !state_) { |
| HasEnrolledInstrumentCallback(per_method_quota, |
| /*has_enrolled_instrument=*/false); |
| } else { |
| state_->HasEnrolledInstrument( |
| base::BindOnce(&PaymentRequest::HasEnrolledInstrumentCallback, |
| weak_ptr_factory_.GetWeakPtr(), per_method_quota)); |
| } |
| } |
| |
| bool PaymentRequest::ChangePaymentMethod(const std::string& method_name, |
| const std::string& stringified_data) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(!method_name.empty()); |
| |
| if (!state_ || !state_->IsPaymentAppInvoked() || !client_) |
| return false; |
| |
| client_->OnPaymentMethodChange(method_name, stringified_data); |
| return true; |
| } |
| |
| void PaymentRequest::AreRequestedMethodsSupportedCallback( |
| bool methods_supported, |
| const std::string& error_message) { |
| if (methods_supported) { |
| if (SatisfiesSkipUIConstraints()) |
| Pay(); |
| } else { |
| DCHECK(!has_recorded_completion_); |
| has_recorded_completion_ = true; |
| journey_logger_.SetNotShown( |
| JourneyLogger::NOT_SHOWN_REASON_NO_SUPPORTED_PAYMENT_METHOD); |
| client_->OnError(mojom::PaymentErrorReason::NOT_SUPPORTED, |
| GetNotSupportedErrorMessage(spec_.get()) + |
| (error_message.empty() ? "" : " " + error_message)); |
| if (observer_for_testing_) |
| observer_for_testing_->OnNotSupportedError(); |
| OnConnectionTerminated(); |
| } |
| } |
| |
| bool PaymentRequest::IsInitialized() const { |
| return is_initialized_ && client_ && client_.is_bound() && |
| binding_.is_bound(); |
| } |
| |
| bool PaymentRequest::IsThisPaymentRequestShowing() const { |
| return is_show_called_ && display_handle_ && spec_ && state_; |
| } |
| |
| bool PaymentRequest::SatisfiesSkipUIConstraints() { |
| // Only allowing URL base payment apps to skip the payment sheet. |
| skipped_payment_request_ui_ = |
| (spec()->url_payment_method_identifiers().size() == 1 || |
| delegate_->SkipUiForBasicCard()) && |
| base::FeatureList::IsEnabled(features::kWebPaymentsSingleAppUiSkip) && |
| base::FeatureList::IsEnabled(::features::kServiceWorkerPaymentApps) && |
| is_show_user_gesture_ && state()->IsInitialized() && |
| spec()->IsInitialized() && state()->available_instruments().size() == 1 && |
| spec()->stringified_method_data().size() == 1 && |
| !spec()->request_shipping() && !spec()->request_payer_name() && |
| !spec()->request_payer_phone() && !spec()->request_payer_email(); |
| if (skipped_payment_request_ui_) { |
| DCHECK(state()->IsInitialized() && spec()->IsInitialized()); |
| journey_logger_.SetEventOccurred(JourneyLogger::EVENT_SKIPPED_SHOW); |
| } else if (state()->IsInitialized() && spec()->IsInitialized()) { |
| // Set EVENT_SHOWN only after state() and spec() initialization. |
| journey_logger_.SetEventOccurred(JourneyLogger::EVENT_SHOWN); |
| } |
| return skipped_payment_request_ui_; |
| } |
| |
| void PaymentRequest::OnPaymentResponseAvailable( |
| mojom::PaymentResponsePtr response) { |
| DCHECK(!response->method_name.empty()); |
| DCHECK(!response->stringified_details.empty()); |
| |
| journey_logger_.SetEventOccurred( |
| JourneyLogger::EVENT_RECEIVED_INSTRUMENT_DETAILS); |
| |
| // Log the correct "selected instrument" metric according to its type and |
| // the method name in response. |
| DCHECK(state_->selected_instrument()); |
| JourneyLogger::Event selected_event = |
| JourneyLogger::Event::EVENT_SELECTED_OTHER; |
| switch (state_->selected_instrument()->type()) { |
| case PaymentInstrument::Type::AUTOFILL: |
| selected_event = JourneyLogger::Event::EVENT_SELECTED_CREDIT_CARD; |
| break; |
| case PaymentInstrument::Type::SERVICE_WORKER_APP: { |
| selected_event = |
| IsGooglePaymentMethodInstrumentSelected(response->method_name) |
| ? JourneyLogger::Event::EVENT_SELECTED_GOOGLE |
| : JourneyLogger::Event::EVENT_SELECTED_OTHER; |
| break; |
| } |
| case PaymentInstrument::Type::NATIVE_MOBILE_APP: |
| NOTREACHED(); |
| break; |
| } |
| journey_logger_.SetEventOccurred(selected_event); |
| |
| // If currently interactive, show the processing spinner. Autofill payment |
| // instruments request a CVC, so they are always interactive at this point. A |
| // payment handler may elect to be non-interactive by not showing a |
| // confirmation page to the user. |
| if (delegate_->IsInteractive()) |
| delegate_->ShowProcessingSpinner(); |
| |
| client_->OnPaymentResponse(std::move(response)); |
| } |
| |
| void PaymentRequest::OnPaymentResponseError(const std::string& error_message) { |
| journey_logger_.SetEventOccurred( |
| JourneyLogger::EVENT_RECEIVED_INSTRUMENT_DETAILS); |
| RecordFirstAbortReason(JourneyLogger::ABORT_REASON_INSTRUMENT_DETAILS_ERROR); |
| |
| reject_show_error_message_ = error_message; |
| delegate_->ShowErrorMessage(); |
| // When the user dismisses the error message, UserCancelled() will reject |
| // PaymentRequest.show() with |reject_show_error_message_|. |
| } |
| |
| void PaymentRequest::OnShippingOptionIdSelected( |
| std::string shipping_option_id) { |
| client_->OnShippingOptionChange(shipping_option_id); |
| } |
| |
| void PaymentRequest::OnShippingAddressSelected( |
| mojom::PaymentAddressPtr address) { |
| // Redact shipping address before exposing it in ShippingAddressChangeEvent. |
| // https://w3c.github.io/payment-request/#shipping-address-changed-algorithm |
| if (PaymentsExperimentalFeatures::IsEnabled( |
| features::kWebPaymentsRedactShippingAddress)) { |
| address->organization.clear(); |
| address->phone.clear(); |
| address->recipient.clear(); |
| address->address_line.clear(); |
| } |
| client_->OnShippingAddressChange(std::move(address)); |
| } |
| |
| void PaymentRequest::OnPayerInfoSelected(mojom::PayerDetailPtr payer_info) { |
| client_->OnPayerDetailChange(std::move(payer_info)); |
| } |
| |
| 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; |
| |
| RecordFirstAbortReason(JourneyLogger::ABORT_REASON_ABORTED_BY_USER); |
| |
| // This sends an error to the renderer, which informs the API user. |
| client_->OnError(mojom::PaymentErrorReason::USER_CANCEL, |
| !reject_show_error_message_.empty() |
| ? reject_show_error_message_ |
| : errors::kUserCancelled); |
| |
| // We close all bindings and ask to be destroyed. |
| client_.reset(); |
| binding_.Close(); |
| payment_handler_host_.Disconnect(); |
| if (observer_for_testing_) |
| observer_for_testing_->OnConnectionTerminated(); |
| manager_->DestroyRequest(this); |
| } |
| |
| void PaymentRequest::DidStartMainFrameNavigationToDifferentDocument( |
| bool is_user_initiated) { |
| RecordFirstAbortReason(is_user_initiated |
| ? JourneyLogger::ABORT_REASON_USER_NAVIGATION |
| : JourneyLogger::ABORT_REASON_MERCHANT_NAVIGATION); |
| } |
| |
| void PaymentRequest::OnConnectionTerminated() { |
| // We are here because of a browser-side error, or likely as a result of the |
| // connection_error_handler on |binding_|, which can mean that the renderer |
| // has decided to close the pipe for various reasons (see all uses of |
| // PaymentRequest::clearResolversAndCloseMojoConnection() in Blink). We close |
| // the binding and the dialog, and ask to be deleted. |
| client_.reset(); |
| binding_.Close(); |
| payment_handler_host_.Disconnect(); |
| delegate_->CloseDialog(); |
| if (observer_for_testing_) |
| observer_for_testing_->OnConnectionTerminated(); |
| |
| RecordFirstAbortReason(JourneyLogger::ABORT_REASON_MOJO_CONNECTION_ERROR); |
| manager_->DestroyRequest(this); |
| } |
| |
| void PaymentRequest::Pay() { |
| journey_logger_.SetEventOccurred(JourneyLogger::EVENT_PAY_CLICKED); |
| DCHECK(state_->selected_instrument()); |
| if (state_->selected_instrument()->type() == |
| PaymentInstrument::Type::SERVICE_WORKER_APP) { |
| static_cast<ServiceWorkerPaymentInstrument*>(state_->selected_instrument()) |
| ->set_payment_handler_host(payment_handler_host_.Bind()); |
| } |
| state_->GeneratePaymentResponse(); |
| } |
| |
| void PaymentRequest::HideIfNecessary() { |
| display_handle_.reset(); |
| } |
| |
| bool PaymentRequest::IsIncognito() const { |
| return delegate_->IsIncognito(); |
| } |
| |
| void PaymentRequest::RecordFirstAbortReason( |
| JourneyLogger::AbortReason abort_reason) { |
| if (!has_recorded_completion_) { |
| has_recorded_completion_ = true; |
| journey_logger_.SetAborted(abort_reason); |
| } |
| } |
| |
| void PaymentRequest::CanMakePaymentCallback(bool legacy_mode, |
| bool can_make_payment) { |
| // Only need to enforce query quota in legacy mode. Per-method quota not |
| // supported. |
| if (legacy_mode && spec_ && |
| !CanMakePaymentQueryFactory::GetInstance() |
| ->GetForContext(web_contents_->GetBrowserContext()) |
| ->CanQuery(top_level_origin_, frame_origin_, |
| spec_->stringified_method_data(), |
| /*per_method_quota=*/false)) { |
| if (UrlUtil::IsLocalDevelopmentUrl(frame_origin_)) { |
| client_->OnCanMakePayment( |
| can_make_payment |
| ? CanMakePaymentQueryResult::WARNING_CAN_MAKE_PAYMENT |
| : CanMakePaymentQueryResult::WARNING_CANNOT_MAKE_PAYMENT); |
| } else { |
| client_->OnCanMakePayment( |
| CanMakePaymentQueryResult::QUERY_QUOTA_EXCEEDED); |
| } |
| } else { |
| client_->OnCanMakePayment( |
| can_make_payment |
| ? mojom::CanMakePaymentQueryResult::CAN_MAKE_PAYMENT |
| : mojom::CanMakePaymentQueryResult::CANNOT_MAKE_PAYMENT); |
| } |
| |
| journey_logger_.SetCanMakePaymentValue(can_make_payment); |
| |
| if (observer_for_testing_) |
| observer_for_testing_->OnCanMakePaymentReturned(); |
| } |
| |
| void PaymentRequest::HasEnrolledInstrumentCallback( |
| bool per_method_quota, |
| bool has_enrolled_instrument) { |
| if (!spec_ || |
| CanMakePaymentQueryFactory::GetInstance() |
| ->GetForContext(web_contents_->GetBrowserContext()) |
| ->CanQuery(top_level_origin_, frame_origin_, |
| spec_->stringified_method_data(), per_method_quota)) { |
| RespondToHasEnrolledInstrumentQuery(has_enrolled_instrument, |
| /*warn_local_development=*/false); |
| } else if (UrlUtil::IsLocalDevelopmentUrl(frame_origin_)) { |
| RespondToHasEnrolledInstrumentQuery(has_enrolled_instrument, |
| /*warn_local_development=*/true); |
| } else { |
| client_->OnHasEnrolledInstrument( |
| HasEnrolledInstrumentQueryResult::QUERY_QUOTA_EXCEEDED); |
| } |
| |
| if (observer_for_testing_) |
| observer_for_testing_->OnHasEnrolledInstrumentReturned(); |
| } |
| |
| void PaymentRequest::RespondToHasEnrolledInstrumentQuery( |
| bool has_enrolled_instrument, |
| bool warn_local_development) { |
| HasEnrolledInstrumentQueryResult positive = |
| warn_local_development |
| ? HasEnrolledInstrumentQueryResult::WARNING_HAS_ENROLLED_INSTRUMENT |
| : HasEnrolledInstrumentQueryResult::HAS_ENROLLED_INSTRUMENT; |
| HasEnrolledInstrumentQueryResult negative = |
| warn_local_development |
| ? HasEnrolledInstrumentQueryResult::WARNING_HAS_NO_ENROLLED_INSTRUMENT |
| : HasEnrolledInstrumentQueryResult::HAS_NO_ENROLLED_INSTRUMENT; |
| |
| client_->OnHasEnrolledInstrument(has_enrolled_instrument ? positive |
| : negative); |
| journey_logger_.SetHasEnrolledInstrumentValue(has_enrolled_instrument); |
| } |
| |
| } // namespace payments |
