Merge-60 [Payments] Use C++ metric enums in Java.

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.content.Context;
 import android.content.Intent;
 import android.graphics.Bitmap;
@@ skipping 388 matching lines @@
         }
     }
 
     /**
      * Called by the merchant website to initialize the payment request data.
      */
     @Override
     public void init(PaymentRequestClient client, PaymentMethodData[] methodData,
             PaymentDetails details, PaymentOptions options) {
         if (mClient != null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Renderer should never call init() twice");
             return;
         }
 
         if (client == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Invalid mojo client");
             return;
         }
 
         mClient = client;
         mMethodData = new HashMap<>();
 
         if (!OriginSecurityChecker.isOriginSecure(mWebContents.getLastCommittedUrl())) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Not in a secure context");
             return;
         }
 
         mRequestShipping = options != null && options.requestShipping;
         mRequestPayerName = options != null && options.requestPayerName;
         mRequestPayerPhone = options != null && options.requestPayerPhone;
         mRequestPayerEmail = options != null && options.requestPayerEmail;
         mShippingType = options == null ? PaymentShippingType.SHIPPING : options.shippingType;
 
@@ skipping 14 matching lines @@
                 && !SslValidityChecker.isSslCertificateValid(mWebContents)) {
             Log.d(TAG, "SSL certificate is not valid");
             // Don't show any UI. Resolve .canMakePayment() with "false". Reject .show() with
             // "NotSupportedError".
             onAllPaymentAppsCreated();
             return;
         }
 
         mMethodData = getValidatedMethodData(methodData, mCardEditor);
         if (mMethodData == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Invalid payment methods or data");
             return;
         }
 
         if (!parseAndValidateDetailsOrDisconnectFromClient(details)) return;
 
         if (mRawTotal == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Missing total");
             return;
         }
         mId = details.id;
 
         PaymentAppFactory.getInstance().create(mWebContents,
                 Collections.unmodifiableSet(mMethodData.keySet()), this /* callback */);
 
         // If there is a single payment method and the merchant has not requested any other
         // information, we can safely go directly to the payment app instead of showing
@@ skipping 82 matching lines @@
         Set<String> uniqueCountryCodes = new HashSet<>();
         for (int i = 0; i < addresses.size(); ++i) {
             String countryCode = AutofillAddress.getCountryCode(addresses.get(i).getProfile());
             if (!uniqueCountryCodes.contains(countryCode)) {
                 uniqueCountryCodes.add(countryCode);
                 PersonalDataManager.getInstance().loadRulesForAddressNormalization(countryCode);
             }
         }
 
         // Log the number of suggested shipping addresses.
-        mJourneyLogger.setNumberOfSuggestionsShown(
-                JourneyLogger.SECTION_SHIPPING_ADDRESS, addresses.size());
+        mJourneyLogger.setNumberOfSuggestionsShown(Section.SHIPPING_ADDRESS, addresses.size());
 
         // Automatically select the first address if one is complete and if the merchant does
         // not require a shipping address to calculate shipping costs.
         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);
     }
 
     /**
      * Called by the merchant website to show the payment request to the user.
      */
     @Override
     public void show() {
         if (mClient == null) return;
 
         if (mUI != null) {
             // Can be triggered only by a compromised renderer. In normal operation, calling show()
             // twice on the same instance of PaymentRequest in JavaScript is rejected at the
             // renderer level.
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Renderer should never invoke show() twice");
             return;
         }
 
         if (getIsAnyPaymentRequestShowing()) {
             // The renderer can create multiple instances of PaymentRequest and call show() on each
             // one. Only the first one will be shown. This also prevents multiple tabs and windows
             // from showing PaymentRequest UI at the same time.
-            mJourneyLogger.setNotShown(JourneyLogger.NO_SHOW_CONCURRENT_REQUESTS);
+            mJourneyLogger.setNotShown(NotShownReason.CONCURRENT_REQUESTS);
             disconnectFromClientWithDebugMessage("A PaymentRequest UI is already showing");
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return;
         }
 
         mIsCurrentPaymentRequestShowing = true;
         if (disconnectIfNoPaymentMethodsSupported()) return;
 
         ChromeActivity chromeActivity = ChromeActivity.fromWebContents(mWebContents);
         if (chromeActivity == null) {
-            mJourneyLogger.setNotShown(JourneyLogger.NO_SHOW_REASON_OTHER);
+            mJourneyLogger.setNotShown(NotShownReason.OTHER);
             disconnectFromClientWithDebugMessage("Unable to find Chrome activity");
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return;
         }
 
         // 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.
         mObservedTabModelSelector = chromeActivity.getTabModelSelector();
         mObservedTabModel = chromeActivity.getCurrentTabModel();
         mObservedTabModelSelector.addObserver(mSelectorObserver);
         mObservedTabModel.addObserver(mTabModelObserver);
 
         buildUI(chromeActivity);
         if (!mShouldSkipShowingPaymentRequestUi) mUI.show();
 
         triggerPaymentAppUiSkipIfApplicable();
     }
 
     private void triggerPaymentAppUiSkipIfApplicable() {
         // If we are skipping showing the Payment Request UI, we should call into the
         // PaymentApp immediately after we determine the instruments are ready and UI is shown.
         if (mShouldSkipShowingPaymentRequestUi && isFinishedQueryingPaymentApps()
                 && mIsCurrentPaymentRequestShowing) {
             assert !mPaymentMethodsSection.isEmpty();
 
             mDidRecordShowEvent = true;
             mShouldRecordAbortReason = true;
-            mJourneyLogger.setEventOccurred(JourneyLogger.EVENT_SKIPPED_SHOW);
+            mJourneyLogger.setEventOccurred(Event.SKIPPED_SHOW);
             mJourneyLogger.setShowCalled();
 
             onPayClicked(null /* selectedShippingAddress */, null /* selectedShippingOption */,
                     mPaymentMethodsSection.getItem(0));
         }
     }
 
     private static Map<String, PaymentMethodData> getValidatedMethodData(
             PaymentMethodData[] methodData, CardEditor paymentMethodsCollector) {
         // Payment methodData are required.
@@ skipping 79 matching lines @@
 
     /**
      * Called by merchant to update the shipping options and line items after the user has selected
      * their shipping address or shipping option.
      */
     @Override
     public void updateWith(PaymentDetails details) {
         if (mClient == null) return;
 
         if (mUI == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage(
                     "PaymentRequestUpdateEvent.updateWith() called without PaymentRequest.show()");
             return;
         }
 
         if (!parseAndValidateDetailsOrDisconnectFromClient(details)) return;
 
         if (mUiShippingOptions.isEmpty() && mShippingAddressesSection.getSelectedItem() != null) {
             mShippingAddressesSection.getSelectedItem().setInvalid();
             mShippingAddressesSection.setSelectedItemIndex(SectionInformation.INVALID_SELECTION);
@@ skipping 12 matching lines @@
      * Sets the total, display line items, and shipping options based on input and returns the
      * status boolean. That status is true for valid data, false for invalid data. If the input is
      * invalid, disconnects from the client. Both raw and UI versions of data are updated.
      *
      * @param details The total, line items, and shipping options to parse, validate, and save in
      *                member variables.
      * @return True if the data is valid. False if the data is invalid.
      */
     private boolean parseAndValidateDetailsOrDisconnectFromClient(PaymentDetails details) {
         if (!PaymentValidator.validatePaymentDetails(details)) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_INVALID_DATA_FROM_RENDERER);
+            mJourneyLogger.setAborted(AbortReason.INVALID_DATA_FROM_RENDERER);
             disconnectFromClientWithDebugMessage("Invalid payment details");
             return false;
         }
 
         if (details.total != null) {
             mRawTotal = details.total;
         }
 
         loadCurrencyFormattersForPaymentDetails(details);
 
@@ skipping 194 matching lines @@
 
     private void providePaymentInformation() {
         mPaymentInformationCallback.onResult(
                 new PaymentInformation(mUiShoppingCart, mShippingAddressesSection,
                         mUiShippingOptions, mContactSection, mPaymentMethodsSection));
         mPaymentInformationCallback = null;
 
         if (!mDidRecordShowEvent) {
             mDidRecordShowEvent = true;
             mShouldRecordAbortReason = true;
-            mJourneyLogger.setEventOccurred(JourneyLogger.EVENT_SHOWN);
+            mJourneyLogger.setEventOccurred(Event.SHOWN);
             mJourneyLogger.setShowCalled();
         }
     }
 
     @Override
     public void getShoppingCart(final Callback<ShoppingCart> callback) {
         mHandler.post(new Runnable() {
             @Override
             public void run() {
                 callback.onResult(mUiShoppingCart);
@@ skipping 21 matching lines @@
         });
     }
 
     @Override
     @PaymentRequestUI.SelectionResult
     public int onSectionOptionSelected(@PaymentRequestUI.DataType int optionType,
             PaymentOption option, Callback<PaymentInformation> callback) {
         if (optionType == PaymentRequestUI.TYPE_SHIPPING_ADDRESSES) {
             assert option instanceof AutofillAddress;
             // Log the change of shipping address.
-            mJourneyLogger.incrementSelectionChanges(JourneyLogger.SECTION_SHIPPING_ADDRESS);
+            mJourneyLogger.incrementSelectionChanges(Section.SHIPPING_ADDRESS);
             AutofillAddress address = (AutofillAddress) option;
             if (address.isComplete()) {
                 mShippingAddressesSection.setSelectedItem(option);
                 startShippingAddressChangeNormalization(address);
             } else {
                 editAddress(address);
             }
             mPaymentInformationCallback = callback;
             return PaymentRequestUI.SELECTION_RESULT_ASYNCHRONOUS_VALIDATION;
         } else if (optionType == PaymentRequestUI.TYPE_SHIPPING_OPTIONS) {
             // This may update the line items.
             mUiShippingOptions.setSelectedItem(option);
             mClient.onShippingOptionChange(option.getIdentifier());
             mPaymentInformationCallback = callback;
             return PaymentRequestUI.SELECTION_RESULT_ASYNCHRONOUS_VALIDATION;
         } else if (optionType == PaymentRequestUI.TYPE_CONTACT_DETAILS) {
             assert option instanceof AutofillContact;
             // Log the change of contact info.
-            mJourneyLogger.incrementSelectionChanges(JourneyLogger.SECTION_CONTACT_INFO);
+            mJourneyLogger.incrementSelectionChanges(Section.CONTACT_INFO);
             AutofillContact contact = (AutofillContact) option;
 
             if (contact.isComplete()) {
                 mContactSection.setSelectedItem(option);
             } else {
                 editContact(contact);
                 return PaymentRequestUI.SELECTION_RESULT_EDITOR_LAUNCH;
             }
         } else if (optionType == PaymentRequestUI.TYPE_PAYMENT_METHODS) {
             assert option instanceof PaymentInstrument;
             if (option instanceof AutofillPaymentInstrument) {
                 // Log the change of credit card.
-                mJourneyLogger.incrementSelectionChanges(JourneyLogger.SECTION_CREDIT_CARDS);
+                mJourneyLogger.incrementSelectionChanges(Section.CREDIT_CARDS);
                 AutofillPaymentInstrument card = (AutofillPaymentInstrument) option;
 
                 if (!card.isComplete()) {
                     editCard(card);
                     return PaymentRequestUI.SELECTION_RESULT_EDITOR_LAUNCH;
                 }
             }
 
             updateOrderSummary((PaymentInstrument) option);
             mPaymentMethodsSection.setSelectedItem(option);
@@ skipping 30 matching lines @@
     }
 
     @Override
     @PaymentRequestUI.SelectionResult
     public int onSectionAddOption(
             @PaymentRequestUI.DataType int optionType, Callback<PaymentInformation> callback) {
         if (optionType == PaymentRequestUI.TYPE_SHIPPING_ADDRESSES) {
             editAddress(null);
             mPaymentInformationCallback = callback;
             // Log the add of shipping address.
-            mJourneyLogger.incrementSelectionAdds(JourneyLogger.SECTION_SHIPPING_ADDRESS);
+            mJourneyLogger.incrementSelectionAdds(Section.SHIPPING_ADDRESS);
             return PaymentRequestUI.SELECTION_RESULT_ASYNCHRONOUS_VALIDATION;
         } else if (optionType == PaymentRequestUI.TYPE_CONTACT_DETAILS) {
             editContact(null);
             // Log the add of contact info.
-            mJourneyLogger.incrementSelectionAdds(JourneyLogger.SECTION_CONTACT_INFO);
+            mJourneyLogger.incrementSelectionAdds(Section.CONTACT_INFO);
             return PaymentRequestUI.SELECTION_RESULT_EDITOR_LAUNCH;
         } else if (optionType == PaymentRequestUI.TYPE_PAYMENT_METHODS) {
             editCard(null);
             // Log the add of credit card.
-            mJourneyLogger.incrementSelectionAdds(JourneyLogger.SECTION_CREDIT_CARDS);
+            mJourneyLogger.incrementSelectionAdds(Section.CREDIT_CARDS);
             return PaymentRequestUI.SELECTION_RESULT_EDITOR_LAUNCH;
         }
 
         return PaymentRequestUI.SELECTION_RESULT_NONE;
     }
 
     private void editAddress(final AutofillAddress toEdit) {
         if (toEdit != null) {
             // Log the edit of a shipping address.
-            mJourneyLogger.incrementSelectionEdits(JourneyLogger.SECTION_SHIPPING_ADDRESS);
+            mJourneyLogger.incrementSelectionEdits(Section.SHIPPING_ADDRESS);
         }
         mAddressEditor.edit(toEdit, new Callback<AutofillAddress>() {
             @Override
             public void onResult(AutofillAddress editedAddress) {
                 if (mUI == null) return;
 
                 if (editedAddress != null) {
                     // Sets or updates the shipping address label.
                     editedAddress.setShippingAddressLabelWithCountry();
 
@@ skipping 27 matching lines @@
                 } else {
                     providePaymentInformation();
                 }
             }
         });
     }
 
     private void editContact(final AutofillContact toEdit) {
         if (toEdit != null) {
             // Log the edit of a contact info.
-            mJourneyLogger.incrementSelectionEdits(JourneyLogger.SECTION_CONTACT_INFO);
+            mJourneyLogger.incrementSelectionEdits(Section.CONTACT_INFO);
         }
         mContactEditor.edit(toEdit, new Callback<AutofillContact>() {
             @Override
             public void onResult(AutofillContact editedContact) {
                 if (mUI == null) return;
 
                 if (editedContact != null) {
                     // A partial or complete contact came back from the editor (could have been from
                     // adding/editing or cancelling out of the edit flow).
                     if (!editedContact.isComplete()) {
@@ skipping 12 matching lines @@
                 // action to take (if a contact was selected in the UI, it will stay selected).
 
                 mUI.updateSection(PaymentRequestUI.TYPE_CONTACT_DETAILS, mContactSection);
             }
         });
     }
 
     private void editCard(final AutofillPaymentInstrument toEdit) {
         if (toEdit != null) {
             // Log the edit of a credit card.
-            mJourneyLogger.incrementSelectionEdits(JourneyLogger.SECTION_CREDIT_CARDS);
+            mJourneyLogger.incrementSelectionEdits(Section.CREDIT_CARDS);
         }
         mCardEditor.edit(toEdit, new Callback<AutofillPaymentInstrument>() {
             @Override
             public void onResult(AutofillPaymentInstrument editedCard) {
                 if (mUI == null) return;
 
                 if (editedCard != null) {
                     // A partial or complete card came back from the editor (could have been from
                     // adding/editing or cancelling out of the edit flow).
                     if (!editedCard.isComplete()) {
@@ skipping 52 matching lines @@
             }
             if (mModifiers != null && mModifiers.containsKey(instrumentMethodName)) {
                 modifiers.put(instrumentMethodName, mModifiers.get(instrumentMethodName));
             }
         }
 
         instrument.invokePaymentApp(mId, mMerchantName, mTopLevelOrigin, mPaymentRequestOrigin,
                 mCertificateChain, Collections.unmodifiableMap(methodData), mRawTotal,
                 mRawLineItems, Collections.unmodifiableMap(modifiers), this);
 
-        mJourneyLogger.setEventOccurred(JourneyLogger.EVENT_PAY_CLICKED);
+        mJourneyLogger.setEventOccurred(Event.PAY_CLICKED);
         return !(instrument instanceof AutofillPaymentInstrument);
     }
 
     @Override
     public void onDismiss() {
-        mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_ABORTED_BY_USER);
+        mJourneyLogger.setAborted(AbortReason.ABORTED_BY_USER);
         disconnectFromClientWithDebugMessage("Dialog dismissed");
     }
 
     private void disconnectFromClientWithDebugMessage(String debugMessage) {
         disconnectFromClientWithDebugMessage(debugMessage, PaymentErrorReason.USER_CANCEL);
     }
 
     private void disconnectFromClientWithDebugMessage(String debugMessage, int reason) {
         Log.d(TAG, debugMessage);
         if (mClient != null) mClient.onError(reason);
         closeClient();
         closeUI(true);
     }
 
     /**
      * Called by the merchant website to abort the payment.
      */
     @Override
     public void abort() {
         if (mClient == null) return;
         mClient.onAbort(!mPaymentAppRunning);
         if (mPaymentAppRunning) {
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceUnableToAbort();
         } else {
             closeClient();
             closeUI(true);
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_ABORTED_BY_MERCHANT);
+            mJourneyLogger.setAborted(AbortReason.ABORTED_BY_MERCHANT);
         }
     }
 
     /**
      * Called when the merchant website has processed the payment.
      */
     @Override
     public void complete(int result) {
         if (mClient == null) return;
         mJourneyLogger.setCompleted();
@@ skipping 11 matching lines @@
         PaymentPreferencesUtil.setPaymentInstrumentLastUseDate(
                 selectedPaymentMethod.getIdentifier(), System.currentTimeMillis());
 
         closeUI(PaymentComplete.FAIL != result);
     }
 
     @Override
     public void onCardAndAddressSettingsClicked() {
         Context context = ChromeActivity.fromWebContents(mWebContents);
         if (context == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_OTHER);
+            mJourneyLogger.setAborted(AbortReason.OTHER);
             disconnectFromClientWithDebugMessage("Unable to find Chrome activity");
             return;
         }
 
         Intent intent = PreferencesLauncher.createIntentForSettingsPage(
                 context, AutofillAndPaymentsPreferences.class.getName());
         context.startActivity(intent);
-        mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_ABORTED_BY_USER);
+        mJourneyLogger.setAborted(AbortReason.ABORTED_BY_USER);
         disconnectFromClientWithDebugMessage("Card and address settings clicked");
     }
 
     /**
      * Called by the merchant website to check if the user has complete payment instruments.
      */
     @Override
     public void canMakePayment() {
         if (mClient == null) return;
 
@@ skipping 70 matching lines @@
     }
 
     /**
      * Called when the renderer closes the Mojo connection.
      */
     @Override
     public void close() {
         if (mClient == null) return;
         closeClient();
         closeUI(true);
-        mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_MOJO_RENDERER_CLOSING);
+        mJourneyLogger.setAborted(AbortReason.MOJO_RENDERER_CLOSING);
     }
 
     /**
      * Called when the Mojo connection encounters an error.
      */
     @Override
     public void onConnectionError(MojoException e) {
         if (mClient == null) return;
         closeClient();
         closeUI(true);
-        mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_MOJO_CONNECTION_ERROR);
+        mJourneyLogger.setAborted(AbortReason.MOJO_CONNECTION_ERROR);
     }
 
     /**
      * Called after retrieving the list of payment instruments in an app.
      */
     @Override
     public void onInstrumentsReady(PaymentApp app, List<PaymentInstrument> instruments) {
         if (mClient == null) return;
         mPendingApps.remove(app);
 
@@ skipping 51 matching lines @@
         // > Complete autofill instruments.
         // > Incomplete autofill instruments.
         Collections.sort(mPendingAutofillInstruments, COMPLETENESS_COMPARATOR);
         Collections.sort(mPendingInstruments, APP_FRECENCY_COMPARATOR);
         if (!mPendingAutofillInstruments.isEmpty()) {
             mPendingInstruments.add(mPendingAutofillInstruments);
         }
 
         // Log the number of suggested credit cards.
         mJourneyLogger.setNumberOfSuggestionsShown(
-                JourneyLogger.SECTION_CREDIT_CARDS, mPendingAutofillInstruments.size());
+                Section.CREDIT_CARDS, mPendingAutofillInstruments.size());
 
         // Possibly pre-select the first instrument on the list.
         int selection = SectionInformation.NO_SELECTION;
         if (!mPendingInstruments.isEmpty()) {
             PaymentInstrument first = mPendingInstruments.get(0).get(0);
             if (first instanceof AutofillPaymentInstrument) {
                 AutofillPaymentInstrument creditCard = (AutofillPaymentInstrument) first;
                 if (creditCard.isComplete()) selection = 0;
             } else {
                 // If a payment app is available, then PaymentRequest.canMakePayment() returns true.
@@ skipping 36 matching lines @@
         boolean foundPaymentMethods = mPaymentMethodsSection != null
                 && !mPaymentMethodsSection.isEmpty();
         boolean userCanAddCreditCard = mMerchantSupportsAutofillPaymentInstruments
                 && !ChromeFeatureList.isEnabled(ChromeFeatureList.NO_CREDIT_CARD_ABORT);
 
         if (!mArePaymentMethodsSupported || (!foundPaymentMethods && !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.
             mJourneyLogger.setNotShown(mArePaymentMethodsSupported
-                            ? JourneyLogger.NO_SHOW_NO_MATCHING_PAYMENT_METHOD
-                            : JourneyLogger.NO_SHOW_NO_SUPPORTED_PAYMENT_METHOD);
+                            ? NotShownReason.NO_MATCHING_PAYMENT_METHOD
+                            : NotShownReason.NO_SUPPORTED_PAYMENT_METHOD);
             disconnectFromClientWithDebugMessage("Requested payment methods have no instruments",
                     mIsIncognito ? PaymentErrorReason.USER_CANCEL
                                  : PaymentErrorReason.NOT_SUPPORTED);
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return true;
         }
 
         return false;
     }
 
@@ skipping 11 matching lines @@
 
         // Record the payment method used to complete the transaction. If the payment method was an
         // Autofill credit card with an identifier, record its use.
         PaymentOption selectedPaymentMethod = mPaymentMethodsSection.getSelectedItem();
         if (selectedPaymentMethod instanceof AutofillPaymentInstrument) {
             if (!selectedPaymentMethod.getIdentifier().isEmpty()) {
                 PersonalDataManager.getInstance().recordAndLogCreditCardUse(
                         selectedPaymentMethod.getIdentifier());
             }
             PaymentRequestMetrics.recordSelectedPaymentMethodHistogram(
-                    PaymentRequestMetrics.SELECTED_METHOD_CREDIT_CARD);
+                    SelectedPaymentMethod.CREDIT_CARD);
         } else if (methodName.equals(ANDROID_PAY_METHOD_NAME)
                 || methodName.equals(PAY_WITH_GOOGLE_METHOD_NAME)) {
             PaymentRequestMetrics.recordSelectedPaymentMethodHistogram(
-                    PaymentRequestMetrics.SELECTED_METHOD_ANDROID_PAY);
+                    SelectedPaymentMethod.ANDROID_PAY);
         } else {
             PaymentRequestMetrics.recordSelectedPaymentMethodHistogram(
-                    PaymentRequestMetrics.SELECTED_METHOD_OTHER_PAYMENT_APP);
+                    SelectedPaymentMethod.OTHER_PAYMENT_APP);
         }
 
         // Showing the payment request UI if we were previously skipping it so the loading
         // spinner shows up until the merchant notifies that payment was completed.
         if (mShouldSkipShowingPaymentRequestUi) mUI.showProcessingMessageAfterUiSkip();
 
-        mJourneyLogger.setEventOccurred(JourneyLogger.EVENT_RECEIVED_INSTRUMENT_DETAILS);
+        mJourneyLogger.setEventOccurred(Event.RECEIVED_INSTRUMENT_DETAILS);
 
         mPaymentResponseHelper.onInstrumentDetailsReceived(methodName, stringifiedDetails);
     }
 
     @Override
     public void onPaymentResponseReady(PaymentResponse response) {
         mClient.onPaymentResponse(response);
         mPaymentResponseHelper = null;
     }
 
@@ skipping 32 matching lines @@
 
         mUI.updateSection(PaymentRequestUI.TYPE_SHIPPING_ADDRESSES, mShippingAddressesSection);
     }
 
     @Override
     public void onAddressNormalized(AutofillProfile profile) {
         ChromeActivity chromeActivity = ChromeActivity.fromWebContents(mWebContents);
 
         // Can happen if the tab is closed during the normalization process.
         if (chromeActivity == null) {
-            mJourneyLogger.setAborted(JourneyLogger.ABORT_REASON_OTHER);
+            mJourneyLogger.setAborted(AbortReason.OTHER);
             disconnectFromClientWithDebugMessage("Unable to find Chrome activity");
             if (sObserverForTest != null) sObserverForTest.onPaymentRequestServiceShowFailed();
             return;
         }
 
         // Don't reuse the selected address because it is formatted for display.
         AutofillAddress shippingAddress = new AutofillAddress(chromeActivity, profile);
 
         // This updates the line items and the shipping options asynchronously.
         mClient.onShippingAddressChange(shippingAddress.toPaymentAddress());
@@ skipping 102 matching lines @@
 
     /**
      * The frecency score is calculated according to use count and last use date. The formula is
      * the same as the one used in GetFrecencyScore in autofill_data_model.cc.
      */
     private static final double getFrecencyScore(int count, long date) {
         long currentTime = System.currentTimeMillis();
         return -Math.log((currentTime - date) / (24 * 60 * 60 * 1000) + 2) / Math.log(count + 2);
     }
 }