Currency code exceeding 6 chars will be ellipsized.

chrome/android/java/src/org/chromium/chrome/browser/payments/CurrencyStringFormatter.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 java.text.DecimalFormatSymbols;
 import java.util.Currency;
 import java.util.Locale;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Formatter for currency strings that can be too large to parse into numbers.
  * https://w3c.github.io/browser-payment-api/specs/paymentrequest.html#currencyamount
  */
 public class CurrencyStringFormatter {
     // Amount value pattern and capture group numbers.
     private static final String AMOUNT_VALUE_PATTERN = "^(-?)([0-9]+)(\\.([0-9]+))?$";
     private static final int OPTIONAL_NEGATIVE_GROUP = 1;
     private static final int DIGITS_BETWEEN_NEGATIVE_AND_PERIOD_GROUP = 2;
     private static final int DIGITS_AFTER_PERIOD_GROUP = 4;
 
     // Max currency code length. Maximum length of currency code can be at most 2048.
     private static final int MAX_CURRENCY_CODE_LEN = 2048;
 
+    // Currency code exceeding 6 chars will be ellipsized during formatting for display.
+    private static final int MAX_CURRENCY_CHARS = 6;
+
+    // Unicode character for ellipsis.
+    private static final String ELLIPSIS = "\u2026";
+
     // Formatting constants.
     private static final int DIGIT_GROUPING_SIZE = 3;
 
     private final Pattern mAmountValuePattern;
 
     /**
+     * The currency formatted for display. Currency can be any string of at most
+     * 2048 characters.Currency code more than 6 character is formatted to first
+     * 5 characters and ellipsis.
+     */
+    public final String mFormattedCurrencyCode;
+
+    /**
      * The symbol for the currency specified on the bill. For example, the symbol for "USD" is "$".
      */
     private final String mCurrencySymbol;
 
     /**
      * The number of digits after the decimal separator for the currency specified on the bill. For
      * example, 2 for "USD" and 0 for "JPY".
      */
     private final int mDefaultFractionDigits;
 
@@ skipping 16 matching lines @@
      *                     case ASCII letters. For example, "USD". Format is not restricted. Should
      *                     not be null.
      * @param userLocale User's current locale. Should not be null.
      */
     public CurrencyStringFormatter(String currencyCode, Locale userLocale) {
         assert currencyCode != null : "currencyCode should not be null";
         assert userLocale != null : "userLocale should not be null";
 
         mAmountValuePattern = Pattern.compile(AMOUNT_VALUE_PATTERN);
 
+        mFormattedCurrencyCode = currencyCode.length() <= MAX_CURRENCY_CHARS
+                ? currencyCode
+                : currencyCode.substring(0, MAX_CURRENCY_CHARS - 1) + ELLIPSIS;

[gone, 2016/09/06 17:20:32]

Given that you're just tacking on an ellipsis, will it show up in the correct
place in RTL or BIDI languages?  Is that something that you need to be concerned
about?

[pals, 2016/09/08 04:12:14]

I guess RTL rendering is taken care by view. I have attached a screenshot here
https://bugs.chromium.org/p/chromium/issues/detail?id=636723

+
         String currencySymbol;
         int defaultFractionDigits;
         try {
             Currency currency = Currency.getInstance(currencyCode);
             currencySymbol = currency.getSymbol();
             defaultFractionDigits = currency.getDefaultFractionDigits();
         } catch (IllegalArgumentException e) {
             // The spec does not limit the currencies to official ISO 4217 currency code list, which
             // is used by java.util.Currency. For example, "BTX" (bitcoin) is not an official ISO
             // 4217 currency code, but is allowed by the spec.
@@ skipping 35 matching lines @@
     /**
      * Returns true if the currency code string is in valid format.
      *
      * @param amountCurrencyCode The currency code to check for validity.
      * @return Whether the currency code is in valid format.
      */
     public boolean isValidAmountCurrencyCode(String amountCurrencyCode) {
         return amountCurrencyCode != null && amountCurrencyCode.length() <= MAX_CURRENCY_CODE_LEN;
     }
 
+    /** @return The currency code formatted for display. */
+    public String getFormattedCurrencyCode() {
+        return mFormattedCurrencyCode;
+    }
+
     /**
      * Formats the currency string for display. Does not parse the string into a number, because it
      * might be too large. The number is formatted for the current locale and follows the symbol of
      * the currency code.
      *
      * @param amountValue The number to format. Should be in "^-?[0-9]+(\.[0-9]+)?$" format. Should
      *                    not be null.
      * @return The currency symbol followed by a space and the formatted number.
      */
     public String format(String amountValue) {
@@ skipping 23 matching lines @@
             if (null != decimals) result.append(decimals);
 
             for (int i = numberOfDecimals; i < mDefaultFractionDigits; i++) {
                 result.append("0");
             }
         }
 
         return result.toString();
     }
 }