Implement IsReadyToPay handling

chrome/android/java/src/org/chromium/chrome/browser/payments/PaymentRequestImpl.java

 // 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.
 
 package org.chromium.chrome.browser.payments;
 
 import android.app.Activity;
 import android.graphics.Bitmap;
 import android.os.Handler;
 import android.text.TextUtils;
@@ skipping 51 matching lines @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * Android implementation of the PaymentRequest service defined in
  * components/payments/payment_request.mojom.
  */
 public class PaymentRequestImpl implements PaymentRequest, PaymentRequestUI.Client,
+        PaymentAppFactory.PaymentAppsCallback,
         PaymentApp.InstrumentsCallback, PaymentInstrument.InstrumentDetailsCallback,
         PaymentResponseHelper.PaymentResponseRequesterDelegate {
     /**
      * Observer to be notified when PaymentRequest UI has been dismissed.
      */
     public interface PaymentRequestDismissObserver {
         /**
          * Called when PaymentRequest UI has been dismissed.
          */
         void onPaymentRequestDismissed();
@@ skipping 49 matching lines @@
     /** Monitors changes in the current TabModel. */
     private final TabModelObserver mTabModelObserver = new EmptyTabModelObserver() {
         @Override
         public void didSelectTab(Tab tab, TabSelectionType type, int lastId) {
             if (tab == null || tab.getId() != lastId) onDismiss();
         }
     };
 
     private final Handler mHandler = new Handler();
     private final ChromeActivity mContext;
+    private final WebContents mWebContents;
     private final PaymentRequestDismissObserver mDismissObserver;
     private final String mMerchantName;
     private final String mOrigin;
-    private final List<PaymentApp> mApps;
     private final AddressEditor mAddressEditor;
     private final CardEditor mCardEditor;
     private final PaymentRequestJourneyLogger mJourneyLogger = new PaymentRequestJourneyLogger();
 
     private Bitmap mFavicon;
     private PaymentRequestClient mClient;
 
     /**
      * The raw total amount being charged, as it was received from the website. This data is passed
      * to the payment app.
@@ skipping 24 matching lines @@
     private List<PaymentApp> mPendingApps;
     private List<PaymentInstrument> mPendingInstruments;
     private List<PaymentInstrument> mPendingAutofillInstruments;
     private SectionInformation mPaymentMethodsSection;
     private PaymentRequestUI mUI;
     private Callback<PaymentInformation> mPaymentInformationCallback;
     private boolean mPaymentAppRunning;
     private boolean mMerchantSupportsAutofillPaymentInstruments;
     private ContactEditor mContactEditor;
     private boolean mHasRecordedAbortReason;
+    private boolean mWaitingForPaymentFactory;
 
     /** True if any of the requested payment methods are supported. */
     private boolean mArePaymentMethodsSupported;
 
     /** True if show() was called. */
     private boolean mIsShowing;
 
     /** The helper to create and fill the response to send to the merchant. */
     private PaymentResponseHelper mPaymentResponseHelper;
 
     /**
      * Builds the PaymentRequest service implementation.
      *
      * @param context         The context where PaymentRequest has been invoked.
      * @param webContents     The web contents that have invoked the PaymentRequest API.
      * @param dismissObserver The observer to notify when PaymentRequest UI has been dismissed.
      */
     public PaymentRequestImpl(Activity context, WebContents webContents,
             PaymentRequestDismissObserver dismissObserver) {
         assert context != null;
         assert webContents != null;
         assert dismissObserver != null;
 
         assert context instanceof ChromeActivity;
         mContext = (ChromeActivity) context;
+        mWebContents = webContents;
 
         mDismissObserver = dismissObserver;
-        mMerchantName = webContents.getTitle();
+        mMerchantName = mWebContents.getTitle();
         // The feature is available only in secure context, so it's OK to not show HTTPS.
-        mOrigin = UrlFormatter.formatUrlForSecurityDisplay(webContents.getVisibleUrl(), false);
+        mOrigin = UrlFormatter.formatUrlForSecurityDisplay(mWebContents.getVisibleUrl(), false);
 
         final FaviconHelper faviconHelper = new FaviconHelper();
         faviconHelper.getLocalFaviconImageForURL(Profile.getLastUsedProfile(),
-                webContents.getVisibleUrl(),
+                mWebContents.getVisibleUrl(),
                 mContext.getResources().getDimensionPixelSize(R.dimen.payments_favicon_size),
                 new FaviconHelper.FaviconImageCallback() {
                     @Override
                     public void onFaviconAvailable(Bitmap bitmap, String iconUrl) {
                         faviconHelper.destroy();
                         if (bitmap == null) return;
                         if (mUI == null) {
                             mFavicon = bitmap;
                             return;
                         }
                         mUI.setTitleBitmap(bitmap);
                     }
                 });
 
-        mApps = PaymentAppFactory.create(mContext, webContents);
-
         mAddressEditor = new AddressEditor();
-        mCardEditor = new CardEditor(webContents, mAddressEditor, sObserverForTest);
+        mCardEditor = new CardEditor(mWebContents, mAddressEditor, sObserverForTest);
 
         recordSuccessFunnelHistograms("Initiated");
     }
 
     /**
      * Called by the merchant website to initialize the payment request data.
      */
     @Override
     public void init(PaymentRequestClient client, PaymentMethodData[] methodData,
             PaymentDetails details, PaymentOptions options) {
@@ skipping 10 matching lines @@
         mMethodData = getValidatedMethodData(methodData, mCardEditor);
         if (mMethodData == null) {
             disconnectFromClientWithDebugMessage("Invalid payment methods or data");
             recordAbortReasonHistogram(
                     PaymentRequestMetrics.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
             return;
         }
 
         if (!parseAndValidateDetailsOrDisconnectFromClient(details)) return;
 
-        getMatchingPaymentInstruments();
+        mWaitingForPaymentFactory = true;
+        PaymentAppFactory.create(mContext, mWebContents, mMethodData.keySet(), this);
 
         boolean requestShipping = options != null && options.requestShipping;
         boolean requestPayerName = options != null && options.requestPayerName;
         boolean requestPayerPhone = options != null && options.requestPayerPhone;
         boolean requestPayerEmail = options != null && options.requestPayerEmail;
 
         List<AutofillProfile> profiles = null;
         if (requestShipping || requestPayerName || requestPayerPhone || requestPayerEmail) {
             profiles = PersonalDataManager.getInstance().getProfilesToSuggest(
                     false /* includeNameInLabel */);
@@ skipping 162 matching lines @@
                 // Payment methods should be non-empty.
                 if (TextUtils.isEmpty(methods[j])) return null;
                 result.put(methods[j], data);
             }
 
             paymentMethodsCollector.addAcceptedPaymentMethodsIfRecognized(methods);
         }
         return result;
     }
 
-    /** Queries the installed payment apps for their instruments that merchant supports. */
-    private void getMatchingPaymentInstruments() {
-        mPendingApps = new ArrayList<>(mApps);
+    /**
+     * Called when installed payment apps have been determined. Queries the installed payment apps
+     * for their instruments that merchant supports.
+     */
+    @Override
+    public void onPaymentAppsReady(List<PaymentApp> apps) {
+        mPendingApps = new ArrayList<>(apps);
         mPendingInstruments = new ArrayList<>();
         mPendingAutofillInstruments = new ArrayList<>();
 
         Map<PaymentApp, Map<String, JSONObject>> queryApps = new HashMap<>();
-        for (int i = 0; i < mApps.size(); i++) {
-            PaymentApp app = mApps.get(i);
+        for (int i = 0; i < apps.size(); i++) {
+            PaymentApp app = apps.get(i);
             Map<String, JSONObject> appMethods =
                     filterMerchantMethodData(mMethodData, app.getAppMethodNames());
             if (appMethods == null) {
                 mPendingApps.remove(app);
             } else {
                 mArePaymentMethodsSupported = true;
                 mMerchantSupportsAutofillPaymentInstruments |= app instanceof AutofillPaymentApp;
                 queryApps.put(app, appMethods);
             }
         }
 
         // Query instruments after mMerchantSupportsAutofillPaymentInstruments has been initialized,
         // so a fast response from a non-autofill payment app at the front of the app list does not
         // cause NOT_SUPPORTED payment rejection.
         for (Map.Entry<PaymentApp, Map<String, JSONObject>> q : queryApps.entrySet()) {
-            q.getKey().getInstruments(q.getValue(), this);
+            q.getKey().getInstruments(q.getValue(), mOrigin, this);
         }
+        mWaitingForPaymentFactory = false;
     }
 
     /** Filter out merchant method data that's not relevant to a payment app. Can return null. */
     private static Map<String, JSONObject> filterMerchantMethodData(
             Map<String, JSONObject> merchantMethodData, Set<String> appMethods) {
         Map<String, JSONObject> result = null;
         for (String method : appMethods) {
             if (merchantMethodData.containsKey(method)) {
                 if (result == null) result = new HashMap<>();
                 result.put(method, merchantMethodData.get(method));
@@ skipping 561 matching lines @@
         // UI has requested the full list of payment instruments. Provide it now.
         if (mPaymentInformationCallback != null) providePaymentInformation();
     }
 
     /**
      * If no payment methods are supported, disconnect from the client and return true.
      *
      * @return True if no payment methods are supported
      */
     private boolean disconnectIfNoPaymentMethodsSupported() {
+        // Waiting for payment app factory to respond.
+        if (mPendingApps == null || mPendingInstruments == null) return false;

[please use gerrit instead, 2016/11/17 20:40:08]

Maybe check mWaitingForPaymentFactory here instead?

+
         boolean waitingForPaymentApps = !mPendingApps.isEmpty() || !mPendingInstruments.isEmpty();
         boolean foundPaymentMethods =
                 mPaymentMethodsSection != null && !mPaymentMethodsSection.isEmpty();
         boolean userCanAddCreditCard = mMerchantSupportsAutofillPaymentInstruments
                 && !ChromeFeatureList.isEnabled(ChromeFeatureList.NO_CREDIT_CARD_ABORT);
 
         if (!mArePaymentMethodsSupported
                 || (mIsShowing && !waitingForPaymentApps && !foundPaymentMethods
-                           && !userCanAddCreditCard)) {
+                           && !mWaitingForPaymentFactory && !userCanAddCreditCard)) {
             // All payment apps have responded, but none of them have instruments. It's possible to
             // add credit cards, but the merchant does not support them either. The payment request
             // must be rejected.
             disconnectFromClientWithDebugMessage("Requested payment methods have no instruments",
                     PaymentErrorReason.NOT_SUPPORTED);
             recordAbortReasonHistogram(mArePaymentMethodsSupported
                             ? PaymentRequestMetrics.ABORT_REASON_NO_MATCHING_PAYMENT_METHOD
                             : PaymentRequestMetrics.ABORT_REASON_NO_SUPPORTED_PAYMENT_METHOD);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return true;
@@ skipping 143 matching lines @@
                 "PaymentRequest.CheckoutFunnel.Aborted", abortReason,
                 PaymentRequestMetrics.ABORT_REASON_MAX);
 
         if (abortReason == PaymentRequestMetrics.ABORT_REASON_ABORTED_BY_USER) {
             mJourneyLogger.recordJourneyStatsHistograms("UserAborted");
         } else {
             mJourneyLogger.recordJourneyStatsHistograms("OtherAborted");
         }
     }
 }