Implements logging in the new compact translate UI.

chrome/android/java/src/org/chromium/chrome/browser/infobar/TranslateCompactInfoBar.java

 // Copyright 2017 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.infobar;
 
 import android.support.design.widget.TabLayout;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.LinearLayout;
 
 import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.infobar.translate.TranslateMenu;
 import org.chromium.chrome.browser.infobar.translate.TranslateMenuHelper;
 import org.chromium.chrome.browser.infobar.translate.TranslateTabLayout;
 import org.chromium.chrome.browser.snackbar.Snackbar;
 import org.chromium.chrome.browser.snackbar.SnackbarManager.SnackbarController;
 import org.chromium.chrome.browser.widget.TintedImageButton;
 import org.chromium.ui.widget.Toast;
 
 /**
  * Java version of the compcat translate infobar
  */
 class TranslateCompactInfoBar extends InfoBar
         implements TabLayout.OnTabSelectedListener, TranslateMenuHelper.TranslateMenuListener {
     public static final int TRANSLATING_INFOBAR = 1;
 
     private static final int SOURCE_TAB_INDEX = 0;
     private static final int TARGET_TAB_INDEX = 1;
 
     private final int mInitialStep;
     private final TranslateOptions mOptions;
 
     private long mNativeTranslateInfoBarPtr;
     private TranslateTabLayout mTabLayout;
 
+    private static final String INFOBAR_HISTOGRAM_TRANSLATE_LANGUAGE =
+            "Translate.CompactInfobar.Language.Translate";
+    private static final String INFOBAR_HISTOGRAM_MORE_LANGUAGES_LANGUAGE =
+            "Translate.CompactInfobar.Language.MoreLanguages";
+    private static final String INFOBAR_HISTOGRAM_PAGE_NOT_IN_LANGUAGE =
+            "Translate.CompactInfobar.Language.PageNotIn";
+    private static final String INFOBAR_HISTOGRAM_ALWAYS_TRANSLATE_LANGUAGE =
+            "Translate.CompactInfobar.Language.AlwaysTranslate";
+    private static final String INFOBAR_HISTOGRAM_NEVER_TRANSLATE_LANGUAGE =
+            "Translate.CompactInfobar.Language.NeverTranslate";
+    private static final String INFOBAR_HISTOGRAM = "Translate.CompactInfobar.Event";
+
+    /**
+     * This is used to back a UMA histogram, so it should be treated as
+     * append-only. The values should not be changed or reused, and
+     * INFOBAR_HISTOGRAM_BOUNDARY should be the last.
+     */
+    private static final Integer INFOBAR_IMPRESSION = 0;
+    private static final Integer INFOBAR_TRANSLATE = 1;
+    private static final Integer INFOBAR_DECLINE = 2;
+    private static final Integer INFOBAR_OPTIONS = 3;
+    private static final Integer INFOBAR_MORE_LANGUAGES = 4;
+    private static final Integer INFOBAR_MORE_LANGUAGES_TRANSLATE = 5;
+    private static final Integer INFOBAR_PAGE_NOT_IN = 6;
+    private static final Integer INFOBAR_ALWAYS_TRANSLATE = 7;
+    private static final Integer INFOBAR_NEVER_TRANSLATE = 8;
+    private static final Integer INFOBAR_NEVER_TRANSLATE_SITE = 9;
+    private static final Integer INFOBAR_SCROLL_HIDE = 10;
+    private static final Integer INFOBAR_SCROLL_SHOW = 11;
+    private static final Integer INFOBAR_REVERT = 12;
+    private static final Integer INFOBAR_SNACKBAR_ALWAYS_TRANSLATE_IMPRESSION = 13;
+    private static final Integer INFOBAR_SNACKBAR_NEVER_TRANSLATE_IMPRESSION = 14;
+    private static final Integer INFOBAR_SNACKBAR_NEVER_TRANSLATE_SITE_IMPRESSION = 15;
+    private static final Integer INFOBAR_SNACKBAR_CANCEL_ALWAYS = 16;
+    private static final Integer INFOBAR_SNACKBAR_CANCEL_NEVER_SITE = 17;
+    private static final Integer INFOBAR_SNACKBAR_CANCEL_NEVER = 18;
+    private static final Integer INFOBAR_HISTOGRAM_BOUNDARY = 19;
+
     // Need 2 instances of TranslateMenuHelper to prevent a race condition bug which happens when
     // showing language menu after dismissing overflow menu.
     private TranslateMenuHelper mOverflowMenuHelper;
     private TranslateMenuHelper mLanguageMenuHelper;
 
     private TintedImageButton mMenuButton;
 
     /** The controller for translate UI snackbars. */
     class TranslateSnackbarController implements SnackbarController {
         private final int mMenuItemId;
 
         public TranslateSnackbarController(int menuItemId) {
             mMenuItemId = menuItemId;
         }
 
         @Override
         public void onDismissNoAction(Object actionData) {
             handleTranslateOptionPostSnackbar(mMenuItemId);
         }
 
         @Override
         public void onAction(Object actionData) {
-            // TODO(ramyasharma): Add logging metric to track cancel actions.
-            // Do nothing.
+            switch (mMenuItemId) {
+                case TranslateMenu.ID_OVERFLOW_ALWAYS_TRANSLATE:
+                    recordInfobarAction(INFOBAR_SNACKBAR_CANCEL_ALWAYS);
+                    return;
+                case TranslateMenu.ID_OVERFLOW_NEVER_LANGUAGE:
+                    recordInfobarAction(INFOBAR_SNACKBAR_CANCEL_NEVER);
+                    return;
+                case TranslateMenu.ID_OVERFLOW_NEVER_SITE:
+                    recordInfobarAction(INFOBAR_SNACKBAR_CANCEL_NEVER_SITE);
+                    return;
+            }
         }
     };
 
     @CalledByNative
     private static InfoBar create(int initialStep, String sourceLanguageCode,
             String targetLanguageCode, boolean alwaysTranslate, boolean triggeredFromMenu,
-            String[] languages, String[] codes) {
+            String[] languages, String[] codes, int[] hashCodes) {
+        recordInfobarAction(INFOBAR_IMPRESSION);
         return new TranslateCompactInfoBar(initialStep, sourceLanguageCode, targetLanguageCode,
-                alwaysTranslate, triggeredFromMenu, languages, codes);
+                alwaysTranslate, triggeredFromMenu, languages, codes, hashCodes);
     }
 
     TranslateCompactInfoBar(int initialStep, String sourceLanguageCode, String targetLanguageCode,
-            boolean alwaysTranslate, boolean triggeredFromMenu, String[] languages,
-            String[] codes) {
+            boolean alwaysTranslate, boolean triggeredFromMenu, String[] languages, String[] codes,
+            int[] hashCodes) {
         super(R.drawable.infobar_translate_compact, null, null);
+
         mInitialStep = initialStep;
         mOptions = TranslateOptions.create(sourceLanguageCode, targetLanguageCode, languages, codes,
-                alwaysTranslate, triggeredFromMenu);
+                alwaysTranslate, triggeredFromMenu, hashCodes);
     }
 
     @Override
     protected boolean usesCompactLayout() {
         return true;
     }
 
     @Override
     protected void createCompactLayoutContent(InfoBarCompactLayout parent) {
         LinearLayout content =
                 (LinearLayout) LayoutInflater.from(getContext())
                         .inflate(R.layout.infobar_translate_compact_content, parent, false);
 
         mTabLayout = (TranslateTabLayout) content.findViewById(R.id.translate_infobar_tabs);
         mTabLayout.addTabs(mOptions.sourceLanguageName(), mOptions.targetLanguageName());
 
         // Set translating status in the beginning for pages translated automatically.
         if (mInitialStep == TRANSLATING_INFOBAR) {
             mTabLayout.getTabAt(TARGET_TAB_INDEX).select();
             mTabLayout.showProgressBarOnTab(TARGET_TAB_INDEX);
         }
 
         mTabLayout.addOnTabSelectedListener(this);
 
         mMenuButton = (TintedImageButton) content.findViewById(R.id.translate_infobar_menu_button);
         mMenuButton.setOnClickListener(new OnClickListener() {
             @Override
             public void onClick(View v) {
+                recordInfobarAction(INFOBAR_OPTIONS);
                 initMenuHelper(TranslateMenu.MENU_OVERFLOW);
                 mOverflowMenuHelper.show(TranslateMenu.MENU_OVERFLOW);
             }
         });
 
         parent.addContent(content, 1.0f);
     }
 
     private void initMenuHelper(int menuType) {
         switch (menuType) {
@@ skipping 49 matching lines @@
     @Override
     protected void onNativeDestroyed() {
         mNativeTranslateInfoBarPtr = 0;
         super.onNativeDestroyed();
     }
 
     @Override
     public void onTabSelected(TabLayout.Tab tab) {
         switch (tab.getPosition()) {
             case SOURCE_TAB_INDEX:
+                recordInfobarAction(INFOBAR_REVERT);
                 onButtonClicked(ActionType.TRANSLATE_SHOW_ORIGINAL);
                 return;
             case TARGET_TAB_INDEX:
+                recordInfobarAction(INFOBAR_TRANSLATE);
+                recordSparseInfobarLanguageData(
+                        INFOBAR_HISTOGRAM_TRANSLATE_LANGUAGE, mOptions.targetLanguageCode());
                 startTranslating(TARGET_TAB_INDEX);
                 return;
             default:
                 assert false : "Unexpected Tab Index";
         }
     }
 
     @Override
     public void onTabUnselected(TabLayout.Tab tab) {}
 
     @Override
     public void onTabReselected(TabLayout.Tab tab) {}
 
     @Override
     public void onOverflowMenuItemClicked(int itemId) {
         switch (itemId) {
             case TranslateMenu.ID_OVERFLOW_MORE_LANGUAGE:
+                recordInfobarAction(INFOBAR_MORE_LANGUAGES);
                 initMenuHelper(TranslateMenu.MENU_TARGET_LANGUAGE);
                 mLanguageMenuHelper.show(TranslateMenu.MENU_TARGET_LANGUAGE);
                 return;
             case TranslateMenu.ID_OVERFLOW_ALWAYS_TRANSLATE:
+                recordInfobarAction(INFOBAR_ALWAYS_TRANSLATE);
+                recordSparseInfobarLanguageData(
+                        INFOBAR_HISTOGRAM_ALWAYS_TRANSLATE_LANGUAGE, mOptions.sourceLanguageCode());
                 // Only show snackbar when "Always Translate" is enabled.
                 if (!mOptions.alwaysTranslateLanguageState()) {
                     createAndShowSnackbar(
                             getContext().getString(R.string.translate_snackbar_always_translate,
                                     mOptions.sourceLanguageName(), mOptions.targetLanguageName()),
                             Snackbar.UMA_TRANSLATE_ALWAYS, itemId);
                 } else {
                     handleTranslateOptionPostSnackbar(itemId);
                 }
                 return;
             case TranslateMenu.ID_OVERFLOW_NEVER_LANGUAGE:
+                recordInfobarAction(INFOBAR_NEVER_TRANSLATE);
+                recordSparseInfobarLanguageData(
+                        INFOBAR_HISTOGRAM_NEVER_TRANSLATE_LANGUAGE, mOptions.sourceLanguageCode());
                 createAndShowSnackbar(
                         getContext().getString(R.string.translate_snackbar_language_never,
                                 mOptions.sourceLanguageName()),
                         Snackbar.UMA_TRANSLATE_NEVER, itemId);
                 return;
             case TranslateMenu.ID_OVERFLOW_NEVER_SITE:
+                recordInfobarAction(INFOBAR_NEVER_TRANSLATE_SITE);
                 createAndShowSnackbar(
                         getContext().getString(R.string.translate_snackbar_site_never),
                         Snackbar.UMA_TRANSLATE_NEVER_SITE, itemId);
                 return;
             case TranslateMenu.ID_OVERFLOW_NOT_THIS_LANGUAGE:
+                recordInfobarAction(INFOBAR_PAGE_NOT_IN);
                 initMenuHelper(TranslateMenu.MENU_SOURCE_LANGUAGE);
                 mLanguageMenuHelper.show(TranslateMenu.MENU_SOURCE_LANGUAGE);
                 return;
             default:
                 assert false : "Unexpected overflow menu code";
         }
     }
 
     @Override
     public void onTargetMenuItemClicked(String code) {
         // Reset target code in both UI and native.
         if (mOptions.setTargetLanguage(code)) {
+            recordSparseInfobarLanguageData(
+                    INFOBAR_HISTOGRAM_MORE_LANGUAGES_LANGUAGE, mOptions.targetLanguageCode());
             nativeApplyStringTranslateOption(
                     mNativeTranslateInfoBarPtr, TranslateOption.TARGET_CODE, code);
             // Adjust UI.
             mTabLayout.replaceTabTitle(TARGET_TAB_INDEX, mOptions.getRepresentationFromCode(code));
             startTranslating(mTabLayout.getSelectedTabPosition());
         }
     }
 
     @Override
     public void onSourceMenuItemClicked(String code) {
         // Reset source code in both UI and native.
         if (mOptions.setSourceLanguage(code)) {
+            recordSparseInfobarLanguageData(
+                    INFOBAR_HISTOGRAM_PAGE_NOT_IN_LANGUAGE, mOptions.sourceLanguageCode());
             nativeApplyStringTranslateOption(
                     mNativeTranslateInfoBarPtr, TranslateOption.SOURCE_CODE, code);
             // Adjust UI.
             mTabLayout.replaceTabTitle(SOURCE_TAB_INDEX, mOptions.getRepresentationFromCode(code));
             startTranslating(mTabLayout.getSelectedTabPosition());
         }
     }
 
     private void createAndShowSnackbar(String title, int umaType, int itemId) {
         if (getSnackbarManager() == null) {
             // Directly apply menu option, if snackbar system is not working.
             handleTranslateOptionPostSnackbar(itemId);
             return;
         }
+        switch (itemId) {
+            case TranslateMenu.ID_OVERFLOW_ALWAYS_TRANSLATE:
+                recordInfobarAction(INFOBAR_SNACKBAR_ALWAYS_TRANSLATE_IMPRESSION);
+                break;
+            case TranslateMenu.ID_OVERFLOW_NEVER_LANGUAGE:
+                recordInfobarAction(INFOBAR_SNACKBAR_NEVER_TRANSLATE_IMPRESSION);
+                break;
+            case TranslateMenu.ID_OVERFLOW_NEVER_SITE:
+                recordInfobarAction(INFOBAR_SNACKBAR_NEVER_TRANSLATE_SITE_IMPRESSION);
+                break;
+        }
+
         getSnackbarManager().showSnackbar(
                 Snackbar.make(title, new TranslateSnackbarController(itemId),
                                 Snackbar.TYPE_NOTIFICATION, umaType)
                         .setSingleLine(false)
                         .setAction(
                                 getContext().getString(R.string.translate_snackbar_cancel), null));
     }
 
     private void handleTranslateOptionPostSnackbar(int itemId) {
         switch (itemId) {
             case TranslateMenu.ID_OVERFLOW_ALWAYS_TRANSLATE:
                 mOptions.toggleAlwaysTranslateLanguageState(
                         !mOptions.alwaysTranslateLanguageState());
                 nativeApplyBoolTranslateOption(mNativeTranslateInfoBarPtr,
                         TranslateOption.ALWAYS_TRANSLATE, mOptions.alwaysTranslateLanguageState());
                 return;
             case TranslateMenu.ID_OVERFLOW_NEVER_LANGUAGE:
                 nativeApplyBoolTranslateOption(
                         mNativeTranslateInfoBarPtr, TranslateOption.NEVER_TRANSLATE, true);
                 return;
             case TranslateMenu.ID_OVERFLOW_NEVER_SITE:
                 nativeApplyBoolTranslateOption(
                         mNativeTranslateInfoBarPtr, TranslateOption.NEVER_TRANSLATE_SITE, true);
                 return;
         }
     }
 
+    private static void recordInfobarAction(int action) {
+        RecordHistogram.recordEnumeratedHistogram(
+                INFOBAR_HISTOGRAM, action, INFOBAR_HISTOGRAM_BOUNDARY);
+    }
+
+    private void recordSparseInfobarLanguageData(String histogram, String langCode) {

[Ilya Sherman, 2017/05/11 20:25:05]

Optional nit: "Sparse" seems like an implementation detail, so I'd omit it from
this method name.

[ramyasharma, 2017/05/12 01:50:10]

Done.

+        Integer hashCode = mOptions.getUMAHashCodeRepresentationFromCode(langCode);
+        if (hashCode != null) {
+            RecordHistogram.recordSparseSlowlyHistogram(histogram, hashCode);
+        }
+    }
+
     private native void nativeApplyStringTranslateOption(
             long nativeTranslateCompactInfoBar, int option, String value);
     private native void nativeApplyBoolTranslateOption(
             long nativeTranslateCompactInfoBar, int option, boolean value);
 }