Show additional display items when instruments change.

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.support.v4.util.ArrayMap;
@@ skipping 24 matching lines @@
 import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModel.TabSelectionType;
 import org.chromium.chrome.browser.tabmodel.TabModelObserver;
 import org.chromium.chrome.browser.tabmodel.TabModelSelectorObserver;
 import org.chromium.components.url_formatter.UrlFormatter;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.mojo.system.MojoException;
 import org.chromium.payments.mojom.CanMakePaymentQueryResult;
 import org.chromium.payments.mojom.PaymentComplete;
 import org.chromium.payments.mojom.PaymentDetails;
+import org.chromium.payments.mojom.PaymentDetailsModifier;
 import org.chromium.payments.mojom.PaymentErrorReason;
 import org.chromium.payments.mojom.PaymentItem;
 import org.chromium.payments.mojom.PaymentMethodData;
 import org.chromium.payments.mojom.PaymentOptions;
 import org.chromium.payments.mojom.PaymentRequest;
 import org.chromium.payments.mojom.PaymentRequestClient;
 import org.chromium.payments.mojom.PaymentResponse;
 import org.chromium.payments.mojom.PaymentShippingOption;
 import org.chromium.payments.mojom.PaymentShippingType;
 
@@ skipping 160 matching lines @@
      */
     private PaymentItem mRawTotal;
 
     /**
      * The raw items in the shopping cart, as they were received from the website. This data is
      * passed to the payment app.
      */
     private List<PaymentItem> mRawLineItems;
 
     /**
-     * A mapping from method names to modified totals. Used to display modified totals for each
-     * payment instrument.
+     * A mapping from method names to modifiers, which include modified totals and additional line
+     * items. Used to display modified totals for each payment instrument, modified total in order
+     * summary, and additional line items in order summary.
      */
-    private Map<String, PaymentItem> mModifiedTotals;
+    private Map<String, PaymentDetailsModifier> mModifiers;
 
     /**
      * The UI model of the shopping cart, including the total. Each item includes a label and a
      * price string. This data is passed to the UI.
      */
     private ShoppingCart mUiShoppingCart;
 
     /**
      * The UI model for the shipping options. Includes the label and sublabel for each shipping
      * option. Also keeps track of the selected shipping option. This data is passed to the UI.
@@ skipping 144 matching lines @@
             int firstCompleteAddressIndex = SectionInformation.NO_SELECTION;
             if (mUiShippingOptions.getSelectedItem() != null && !addresses.isEmpty()
                     && addresses.get(0).isComplete()) {
                 firstCompleteAddressIndex = 0;
 
                 // The initial label for the selected shipping address should not include the
                 // country.
                 addresses.get(firstCompleteAddressIndex).setShippingAddressLabelWithoutCountry();
             }
 
-            mShippingAddressesSection =
-                    new SectionInformation(PaymentRequestUI.TYPE_SHIPPING_ADDRESSES,
-                            firstCompleteAddressIndex, addresses);
+            mShippingAddressesSection = new SectionInformation(
+                    PaymentRequestUI.TYPE_SHIPPING_ADDRESSES,
+                    firstCompleteAddressIndex, addresses);
         }
 
         if (requestPayerName || requestPayerPhone || requestPayerEmail) {
             Set<String> uniqueContactInfos = new HashSet<>();
             mContactEditor = new ContactEditor(
                     requestPayerName, requestPayerPhone, requestPayerEmail);
             List<AutofillContact> contacts = new ArrayList<>();
 
             for (int i = 0; i < profiles.size(); i++) {
                 AutofillProfile profile = profiles.get(i);
                 String name = requestPayerName && !TextUtils.isEmpty(profile.getFullName())
                         ? profile.getFullName() : null;
                 String phone = requestPayerPhone && !TextUtils.isEmpty(profile.getPhoneNumber())
                         ? profile.getPhoneNumber() : null;
                 String email = requestPayerEmail && !TextUtils.isEmpty(profile.getEmailAddress())
                         ? profile.getEmailAddress() : null;
                 mContactEditor.addPayerNameIfValid(name);
                 mContactEditor.addPhoneNumberIfValid(phone);
                 mContactEditor.addEmailAddressIfValid(email);
 
                 if (name != null || phone != null || email != null) {
                     // Different profiles can have identical contact info. Do not add the same
                     // contact info to the list twice.
                     String uniqueContactInfo = name + phone + email;
                     if (!uniqueContactInfos.contains(uniqueContactInfo)) {
                         uniqueContactInfos.add(uniqueContactInfo);
 
-                        boolean isComplete =
-                                mContactEditor.isContactInformationComplete(name, phone, email);
+                        boolean isComplete = mContactEditor.isContactInformationComplete(name,
+                                phone, email);
                         contacts.add(new AutofillContact(profile, name, phone, email, isComplete));
                     }
                 }
             }
 
             // Suggest complete contact infos first.
             Collections.sort(contacts, COMPLETENESS_COMPARATOR);
 
             // Limit the number of suggestions.
             contacts = contacts.subList(0, Math.min(contacts.size(), SUGGESTIONS_LIMIT));
@@ skipping 42 matching lines @@
         if (getIsShowing()) {
             disconnectFromClientWithDebugMessage("A PaymentRequest UI is already showing");
             recordAbortReasonHistogram(
                     PaymentRequestMetrics.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
             return;
         }
 
         setIsShowing(true);
         if (disconnectIfNoPaymentMethodsSupported()) return;
 
-        // Catch any time the user switches tabs.  Because the dialog is modal, a user shouldn't be
+        // Catch any time the user switches tabs. Because the dialog is modal, a user shouldn't be
         // allowed to switch tabs, which can happen if the user receives an external Intent.
         mContext.getTabModelSelector().addObserver(mSelectorObserver);
         mContext.getCurrentTabModel().addObserver(mTabModelObserver);
 
         mUI.show();
         recordSuccessFunnelHistograms("Shown");
     }
 
     private static Map<String, PaymentMethodData> getValidatedMethodData(
             PaymentMethodData[] methodData, CardEditor paymentMethodsCollector) {
@@ skipping 19 matching lines @@
 
     /** Queries the installed payment apps for their instruments that merchant supports. */
     private void getMatchingPaymentInstruments() {
         mPendingApps = new ArrayList<>(mApps);
         mPendingInstruments = new ArrayList<>();
         mPendingAutofillInstruments = new ArrayList<>();
 
         Map<PaymentApp, Map<String, PaymentMethodData>> queryApps = new ArrayMap<>();
         for (int i = 0; i < mApps.size(); i++) {
             PaymentApp app = mApps.get(i);
-            Map<String, PaymentMethodData> appMethods =
-                    filterMerchantMethodData(mMethodData, app.getAppMethodNames());
+            Map<String, PaymentMethodData> appMethods = filterMerchantMethodData(mMethodData,
+                    app.getAppMethodNames());
             if (appMethods == null || !app.supportsMethodsAndData(appMethods)) {
                 mPendingApps.remove(app);
             } else {
                 mArePaymentMethodsSupported = true;
                 mMerchantSupportsAutofillPaymentInstruments |= app instanceof AutofillPaymentApp;
                 queryApps.put(app, appMethods);
             }
         }
 
         // Query instruments after mMerchantSupportsAutofillPaymentInstruments has been initialized,
@@ skipping 59 matching lines @@
      * @return True if the data is valid. False if the data is invalid.
      */
     private boolean parseAndValidateDetailsOrDisconnectFromClient(PaymentDetails details) {
         if (!PaymentValidator.validatePaymentDetails(details)) {
             disconnectFromClientWithDebugMessage("Invalid payment details");
             recordAbortReasonHistogram(
                     PaymentRequestMetrics.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
             return false;
         }
 
-        String totalCurrency = details.total.amount.currency;
         if (mFormatter == null) {
-            mFormatter = new CurrencyStringFormatter(totalCurrency, Locale.getDefault());
+            mFormatter = new CurrencyStringFormatter(details.total.amount.currency,
+                    Locale.getDefault());
         }
 
         // Total is never pending.
         LineItem uiTotal = new LineItem(
                 details.total.label, mFormatter.getFormattedCurrencyCode(),
                 mFormatter.format(details.total.amount.value), /* isPending */ false);
 
-        List<LineItem> uiLineItems = getLineItems(details.displayItems, totalCurrency, mFormatter);
+        List<LineItem> uiLineItems = getLineItems(details.displayItems, mFormatter);
 
         mUiShoppingCart = new ShoppingCart(uiTotal, uiLineItems);
         mRawTotal = details.total;
         mRawLineItems = Collections.unmodifiableList(Arrays.asList(details.displayItems));
 
-        mUiShippingOptions = getShippingOptions(details.shippingOptions, totalCurrency, mFormatter);
+        mUiShippingOptions = getShippingOptions(details.shippingOptions, mFormatter);
 
         for (int i = 0; i < details.modifiers.length; i++) {
-            PaymentItem total = details.modifiers[i].total;
-            String[] methods = details.modifiers[i].methodData.supportedMethods;
-            if (total != null) {
-                for (int j = 0; j < methods.length; j++) {
-                    if (mModifiedTotals == null) mModifiedTotals = new ArrayMap<>();
-                    mModifiedTotals.put(methods[j], total);
-                }
+            PaymentDetailsModifier modifier = details.modifiers[i];
+            String[] methods = modifier.methodData.supportedMethods;
+            for (int j = 0; j < methods.length; j++) {
+                if (mModifiers == null) mModifiers = new ArrayMap<>();
+                mModifiers.put(methods[j], modifier);
             }
         }
 
         updateInstrumentModifiedTotals();
 
         return true;
     }
 
-    /** Updates the modified totals for payment instruments. */
+    /** Updates the modifiers for payment instruments and order summary. */
     private void updateInstrumentModifiedTotals() {
         if (!ChromeFeatureList.isEnabled(ChromeFeatureList.WEB_PAYMENTS_MODIFIERS)) return;
-        if (mModifiedTotals == null) return;
+        if (mModifiers == null) return;
         if (mPaymentMethodsSection == null) return;
 
         for (int i = 0; i < mPaymentMethodsSection.getSize(); i++) {
             PaymentInstrument instrument = (PaymentInstrument) mPaymentMethodsSection.getItem(i);
-            PaymentItem modifiedTotal = getModifiedTotal(instrument);
-            instrument.setModifiedTotal(
-                    modifiedTotal == null ? null : mFormatter.format(modifiedTotal.amount.value));
+            PaymentDetailsModifier modifier = getModifier(instrument);
+            instrument.setModifiedTotal(modifier == null || modifier.total == null ? null
+                    : mFormatter.format(modifier.total.amount.value));
         }
 
-        updateOrderSummaryTotal((PaymentInstrument) mPaymentMethodsSection.getSelectedItem());
+        updateOrderSummary((PaymentInstrument) mPaymentMethodsSection.getSelectedItem());
     }
 
-    private void updateOrderSummaryTotal(@Nullable PaymentInstrument instrument) {
+    /** Sets the modifier for the order summary based on the given instrument, if any. */
+    private void updateOrderSummary(@Nullable PaymentInstrument instrument) {
         if (!ChromeFeatureList.isEnabled(ChromeFeatureList.WEB_PAYMENTS_MODIFIERS)) return;
 
-        PaymentItem total = getModifiedTotal(instrument);
+        PaymentDetailsModifier modifier = getModifier(instrument);
+        PaymentItem total = modifier == null ? null : modifier.total;
         if (total == null) total = mRawTotal;
 
         mUiShoppingCart.setTotal(new LineItem(total.label, mFormatter.getFormattedCurrencyCode(),
                 mFormatter.format(total.amount.value), false /* isPending */));
+        mUiShoppingCart.setAdditionalContents(modifier == null ? null
+                : getLineItems(modifier.additionalDisplayItems, mFormatter));
         mUI.updateOrderSummarySection(mUiShoppingCart);
     }
 
-    @Nullable private PaymentItem getModifiedTotal(@Nullable PaymentInstrument instrument) {
+    /** @return The first modifier that matches the given instrument, or null. */
+    @Nullable private PaymentDetailsModifier getModifier(@Nullable PaymentInstrument instrument) {
         if (instrument == null) return null;
         Set<String> methodNames = instrument.getInstrumentMethodNames();
-        methodNames.retainAll(mModifiedTotals.keySet());
-        return methodNames.isEmpty() ? null : mModifiedTotals.get(methodNames.iterator().next());
-    }
-
-    /**
-     * Returns true if all fields in the payment item are non-null and non-empty.
-     *
-     * @param item The payment item to examine.
-     * @return True if all fields are present and non-empty.
-     */
-    private static boolean hasAllPaymentItemFields(PaymentItem item) {
-        // "label", "currency", and "value" should be non-empty.
-        return item != null && !TextUtils.isEmpty(item.label) && item.amount != null
-                && !TextUtils.isEmpty(item.amount.currency)
-                && !TextUtils.isEmpty(item.amount.value);
+        methodNames.retainAll(mModifiers.keySet());
+        return methodNames.isEmpty() ? null : mModifiers.get(methodNames.iterator().next());
     }
 
     /**
      * Converts a list of payment items and returns their parsed representation.
      *
-     * @param items The payment items to parse and validate.
-     * @param totalCurrency The currency code for the total amount of payment.
-     * @param formatter A formatter and validator for the currency amount value.
+     * @param items     The payment items to parse. Can be null.
+     * @param formatter A formatter for the currency amount value.
      * @return A list of valid line items.
      */
     private static List<LineItem> getLineItems(
-            PaymentItem[] items, String totalCurrency, CurrencyStringFormatter formatter) {
+            @Nullable PaymentItem[] items, CurrencyStringFormatter formatter) {
         // Line items are optional.
         if (items == null) return new ArrayList<>();
 
         List<LineItem> result = new ArrayList<>(items.length);
         for (int i = 0; i < items.length; i++) {
             PaymentItem item = items[i];
 
             result.add(new LineItem(
                     item.label, "", formatter.format(item.amount.value), item.pending));
         }
 
         return Collections.unmodifiableList(result);
     }
 
     /**
      * Converts a list of shipping options and returns their parsed representation.
      *
-     * @param options The raw shipping options to parse and validate.
-     * @param totalCurrency The currency code for the total amount of payment.
-     * @param formatter A formatter and validator for the currency amount value.
+     * @param options   The raw shipping options to parse. Can be null.
+     * @param formatter A formatter for the currency amount value.
      * @return The UI representation of the shipping options.
      */
-    private static SectionInformation getShippingOptions(PaymentShippingOption[] options,
-            String totalCurrency, CurrencyStringFormatter formatter) {
+    private static SectionInformation getShippingOptions(
+            @Nullable PaymentShippingOption[] options, CurrencyStringFormatter formatter) {
         // Shipping options are optional.
         if (options == null || options.length == 0) {
             return new SectionInformation(PaymentRequestUI.TYPE_SHIPPING_OPTIONS);
         }
 
         List<PaymentOption> result = new ArrayList<>();
         int selectedItemIndex = SectionInformation.NO_SELECTION;
         for (int i = 0; i < options.length; i++) {
             PaymentShippingOption option = options[i];
             result.add(new PaymentOption(option.id, option.label,
@@ skipping 104 matching lines @@
                 mJourneyLogger.incrementSelectionChanges(
                         PaymentRequestJourneyLogger.SECTION_CREDIT_CARDS);
                 AutofillPaymentInstrument card = (AutofillPaymentInstrument) option;
 
                 if (!card.isComplete()) {
                     editCard(card);
                     return PaymentRequestUI.SELECTION_RESULT_EDITOR_LAUNCH;
                 }
             }
 
-            updateOrderSummaryTotal((PaymentInstrument) option);
+            updateOrderSummary((PaymentInstrument) option);
             mPaymentMethodsSection.setSelectedItem(option);
         }
 
         return PaymentRequestUI.SELECTION_RESULT_NONE;
     }
 
     @Override
     @PaymentRequestUI.SelectionResult
     public int onSectionEditOption(@PaymentRequestUI.DataType int optionType, PaymentOption option,
             Callback<PaymentInformation> callback) {
@@ skipping 125 matching lines @@
         mPaymentResponseHelper.onInstrumentsDetailsLoading();
     }
 
     @Override
     public boolean onPayClicked(PaymentOption selectedShippingAddress,
             PaymentOption selectedShippingOption, PaymentOption selectedPaymentMethod) {
         assert selectedPaymentMethod instanceof PaymentInstrument;
         PaymentInstrument instrument = (PaymentInstrument) selectedPaymentMethod;
         mPaymentAppRunning = true;
 
-        PaymentOption selectedContact =
-                mContactSection != null ? mContactSection.getSelectedItem() : null;
+        PaymentOption selectedContact = mContactSection != null ? mContactSection.getSelectedItem()
+                : null;
         mPaymentResponseHelper = new PaymentResponseHelper(
                 selectedShippingAddress, selectedShippingOption, selectedContact, this);
 
         // Create a map that is the subset of mMethodData that contains the
         // payment methods supported by the selected payment instrument. If this
         // intersection contains more than one payment method, the payment app is
         // at liberty to choose (or have the user choose) one of the methods.
         Map<String, PaymentMethodData> methodData = new HashMap<>();
         for (String instrumentMethodName : instrument.getInstrumentMethodNames()) {
             if (mMethodData.containsKey(instrumentMethodName)) {
@@ skipping 83 matching lines @@
         }
 
         query.addObserver(this);
         if (mPendingApps.isEmpty() && mPendingInstruments.isEmpty()) {
             query.setResponse(mPaymentMethodsSection != null
                     && mPaymentMethodsSection.getSelectedItem() != null);
         }
     }
 
     private void respondCanMakePaymentQuery(boolean response) {
-        mClient.onCanMakePayment(response
-                        ? CanMakePaymentQueryResult.CAN_MAKE_PAYMENT
-                        : CanMakePaymentQueryResult.CANNOT_MAKE_PAYMENT);
+        mClient.onCanMakePayment(response ? CanMakePaymentQueryResult.CAN_MAKE_PAYMENT
+                : CanMakePaymentQueryResult.CANNOT_MAKE_PAYMENT);
         if (sObserverForTest != null) {
             sObserverForTest.onPaymentRequestServiceCanMakePaymentQueryResponded();
         }
     }
 
     /**
      * Called when the renderer closes the Mojo connection.
      */
     @Override
     public void close() {
@@ skipping 20 matching lines @@
     @Override
     public void onInstrumentsReady(PaymentApp app, List<PaymentInstrument> instruments) {
         if (mClient == null) return;
         mPendingApps.remove(app);
 
         // Place the instruments into either "autofill" or "non-autofill" list to be displayed when
         // all apps have responded.
         if (instruments != null) {
             for (int i = 0; i < instruments.size(); i++) {
                 PaymentInstrument instrument = instruments.get(i);
-                Set<String> instrumentMethodNames =
-                        new HashSet<>(instrument.getInstrumentMethodNames());
+                Set<String> instrumentMethodNames = new HashSet<>(
+                        instrument.getInstrumentMethodNames());
                 instrumentMethodNames.retainAll(mMethodData.keySet());
                 if (!instrumentMethodNames.isEmpty()) {
                     addPendingInstrument(instrument);
                 } else {
                     instrument.dismissInstrument();
                 }
             }
         }
 
         // Some payment apps still have not responded. Continue waiting for them.
         if (!mPendingApps.isEmpty()) return;
 
         if (disconnectIfNoPaymentMethodsSupported()) return;
 
         // Load the validation rules for each unique region code in the credit card billing
         // addresses.
         Set<String> uniqueCountryCodes = new HashSet<>();
         for (int i = 0; i < mPendingAutofillInstruments.size(); ++i) {
             assert mPendingAutofillInstruments.get(i) instanceof AutofillPaymentInstrument;
 
-            String countryCode = AutofillAddress.getCountryCode((
-                    (AutofillPaymentInstrument) mPendingAutofillInstruments.get(
+            String countryCode = AutofillAddress
+                    .getCountryCode(((AutofillPaymentInstrument) mPendingAutofillInstruments.get(
                             i)).getBillingAddress());
             if (!uniqueCountryCodes.contains(countryCode)) {
                 uniqueCountryCodes.add(countryCode);
                 PersonalDataManager.getInstance().loadRulesForRegion(countryCode);
             }
         }
 
         // List order:
         // > Non-autofill instruments.
         // > Complete autofill instruments.
@@ skipping 32 matching lines @@
         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() {
         boolean waitingForPaymentApps = !mPendingApps.isEmpty() || !mPendingInstruments.isEmpty();
-        boolean foundPaymentMethods =
-                mPaymentMethodsSection != null && !mPaymentMethodsSection.isEmpty();
+        boolean foundPaymentMethods = mPaymentMethodsSection != null
+                && !mPaymentMethodsSection.isEmpty();
         boolean userCanAddCreditCard = mMerchantSupportsAutofillPaymentInstruments
                 && !ChromeFeatureList.isEnabled(ChromeFeatureList.NO_CREDIT_CARD_ABORT);
 
         if (!mArePaymentMethodsSupported
                 || (getIsShowing() && !waitingForPaymentApps && !foundPaymentMethods
-                           && !userCanAddCreditCard)) {
+                        && !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);
+                    ? PaymentRequestMetrics.ABORT_REASON_NO_MATCHING_PAYMENT_METHOD
+                    : PaymentRequestMetrics.ABORT_REASON_NO_SUPPORTED_PAYMENT_METHOD);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return true;
         }
 
         return false;
     }
 
     /**
      * Saves the given instrument in either "autofill" or "non-autofill" list. The separation
      * enables placing autofill instruments on the bottom of the list.
@@ skipping 56 matching lines @@
     }
 
     @Override
     public void onFocusChanged(
             @PaymentRequestUI.DataType int dataType, boolean willFocus) {
         assert dataType == PaymentRequestUI.TYPE_SHIPPING_ADDRESSES;
 
         if (mShippingAddressesSection.getSelectedItem() == null) return;
 
         assert mShippingAddressesSection.getSelectedItem() instanceof AutofillAddress;
-        AutofillAddress selectedAddress =
-                (AutofillAddress) mShippingAddressesSection.getSelectedItem();
+        AutofillAddress selectedAddress = (AutofillAddress) mShippingAddressesSection
+                .getSelectedItem();
 
         // The label should only include the country if the view is focused.
         if (willFocus) {
             selectedAddress.setShippingAddressLabelWithCountry();
         } else {
             selectedAddress.setShippingAddressLabelWithoutCountry();
         }
 
         mUI.updateSection(PaymentRequestUI.TYPE_SHIPPING_ADDRESSES, mShippingAddressesSection);
     }
@@ skipping 78 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");
         }
     }
 }