[Herb] Add metrics to track button usage

chrome/android/java/src/org/chromium/chrome/browser/ChromeTabbedActivity.java

 // Copyright 2015 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;
 
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.Color;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.provider.Browser;
+import android.support.annotation.IntDef;
 import android.support.annotation.Nullable;
 import android.text.TextUtils;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowManager;
 import android.widget.FrameLayout;
 
@@ skipping 26 matching lines @@
 import org.chromium.chrome.browser.cookies.CookiesFetcher;
 import org.chromium.chrome.browser.customtabs.CustomTabActivity;
 import org.chromium.chrome.browser.customtabs.CustomTabIntentDataProvider;
 import org.chromium.chrome.browser.device.DeviceClassManager;
 import org.chromium.chrome.browser.document.ChromeLauncherActivity;
 import org.chromium.chrome.browser.document.DocumentUma;
 import org.chromium.chrome.browser.firstrun.FirstRunActivity;
 import org.chromium.chrome.browser.firstrun.FirstRunFlowSequencer;
 import org.chromium.chrome.browser.firstrun.FirstRunSignInProcessor;
 import org.chromium.chrome.browser.firstrun.FirstRunStatus;
+import org.chromium.chrome.browser.metrics.ActivityStopMetrics;
 import org.chromium.chrome.browser.metrics.LaunchMetrics;
 import org.chromium.chrome.browser.metrics.StartupMetrics;
 import org.chromium.chrome.browser.metrics.UmaUtils;
 import org.chromium.chrome.browser.ntp.NativePageAssassin;
 import org.chromium.chrome.browser.omaha.OmahaClient;
 import org.chromium.chrome.browser.omnibox.AutocompleteController;
 import org.chromium.chrome.browser.partnercustomizations.HomepageManager;
 import org.chromium.chrome.browser.partnercustomizations.PartnerBrowserCustomizations;
 import org.chromium.chrome.browser.preferences.ChromePreferenceManager;
 import org.chromium.chrome.browser.preferences.ConnectionChangeReceiver;
@@ skipping 19 matching lines @@
 import org.chromium.chrome.browser.widget.findinpage.FindToolbarManager;
 import org.chromium.content.browser.ContentVideoView;
 import org.chromium.content.browser.ContentViewCore;
 import org.chromium.content.browser.crypto.CipherFactory;
 import org.chromium.content.common.ContentSwitches;
 import org.chromium.content_public.browser.LoadUrlParams;
 import org.chromium.ui.base.DeviceFormFactor;
 import org.chromium.ui.base.PageTransition;
 import org.chromium.ui.widget.Toast;
 
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
 /**
  * This is the main activity for ChromeMobile when not running in document mode.  All the tabs
  * are accessible via a chrome specific tab switching UI.
  */
 public class ChromeTabbedActivity extends ChromeActivity implements OverviewModeObserver {
 
     private static final int FIRST_RUN_EXPERIENCE_RESULT = 101;
     private static final int CCT_RESULT = 102;
 
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({
+        BACK_PRESSED_NOTHING_HAPPENED,
+        BACK_PRESSED_HELP_URL_CLOSED,
+        BACK_PRESSED_MINIMIZED_NO_TAB_CLOSED,
+        BACK_PRESSED_MINIMIZED_TAB_CLOSED,
+        BACK_PRESSED_TAB_CLOSED,
+        BACK_PRESSED_TAB_IS_NULL,
+        BACK_PRESSED_EXITED_TAB_SWITCHER,
+        BACK_PRESSED_EXITED_FULLSCREEN,
+        BACK_PRESSED_NAVIGATED_BACK
+    })
+    private @interface BackPressedResult {}
+    private static final int BACK_PRESSED_NOTHING_HAPPENED = 0;
+    private static final int BACK_PRESSED_HELP_URL_CLOSED = 1;
+    private static final int BACK_PRESSED_MINIMIZED_NO_TAB_CLOSED = 2;
+    private static final int BACK_PRESSED_MINIMIZED_TAB_CLOSED = 3;
+    private static final int BACK_PRESSED_TAB_CLOSED = 4;
+    private static final int BACK_PRESSED_TAB_IS_NULL = 5;
+    private static final int BACK_PRESSED_EXITED_TAB_SWITCHER = 6;
+    private static final int BACK_PRESSED_EXITED_FULLSCREEN = 7;
+    private static final int BACK_PRESSED_NAVIGATED_BACK = 8;
+    private static final int BACK_PRESSED_COUNT = 9;
+
     private static final String TAG = "ChromeTabbedActivity";
 
     private static final String HELP_URL_PREFIX = "https://support.google.com/chrome/";
 
     private static final String FRE_RUNNING = "First run is running";
 
     private static final String WINDOW_INDEX = "window_index";
 
     // How long to delay closing the current tab when our app is minimized.  Have to delay this
     // so that we don't show the contents of the next tab while minimizing.
@@ skipping 11 matching lines @@
     public static final String INTENT_EXTRA_TEST_RENDER_PROCESS_LIMIT = "render_process_limit";
 
     /**
      * Sending an intent with this action to Chrome will cause it to close all tabs
      * (iff the --enable-test-intents command line flag is set). If a URL is supplied in the
      * intent data, this will be loaded and unaffected by the close all action.
      */
     private static final String ACTION_CLOSE_TABS =
             "com.google.android.apps.chrome.ACTION_CLOSE_TABS";
 
+    private final ActivityStopMetrics mActivityStopMetrics =
+            new ActivityStopMetrics("Android.Activity.ChromeTabbedActivity.StopReason");
+
     private FindToolbarManager mFindToolbarManager;
 
     private UndoBarPopupController mUndoBarPopupController;
 
     private LayoutManagerChrome mLayoutManager;
 
     private ViewGroup mContentContainer;
 
     private ToolbarControlContainer mControlContainer;
 
@@ skipping 163 matching lines @@
 
         if (getActivityTab() != null) getActivityTab().setIsAllowedToReturnToExternalApp(false);
 
         mTabModelSelectorImpl.saveState();
         try {
             getConnectionChangeReceiver().unregisterReceiver(ChromeTabbedActivity.this);
         } catch (IllegalArgumentException e) {
             // This may happen when onStop get called very early in UI test.
         }
         StartupMetrics.getInstance().recordHistogram(true);
+        mActivityStopMetrics.onStopWithNative(this);
     }
 
     @Override
     public void onStart() {
         super.onStart();
         StartupMetrics.getInstance().updateIntent(getIntent());
     }
 
     @Override
     public void onStartWithNative() {
@@ skipping 133 matching lines @@
                     addOrEditBookmark(getActivityTab());
                 }
             };
 
             getToolbarManager().initializeWithNative(mTabModelSelectorImpl, getFullscreenManager(),
                     mFindToolbarManager, mLayoutManager, mLayoutManager,
                     tabSwitcherClickHandler, newTabClickHandler, bookmarkClickHandler, null);
             getToolbarManager().getToolbar().setReturnButtonListener(new OnClickListener() {
                 @Override
                 public void onClick(View v) {
-                    if (getActivityTab() != null) handleBackPressedWithoutBackStack(true);
+                    if (getActivityTab() == null) return;
+                    mActivityStopMetrics.setStopReason(
+                            ActivityStopMetrics.STOP_REASON_RETURN_BUTTON);
+                    RecordUserAction.record("TaskManagement.ReturnButtonClicked");
+                    sendToBackground(getActivityTab());
                 }
             });
 
             removeWindowBackground();
 
             if (isTablet()) {
                 EmptyBackgroundViewWrapper bgViewWrapper = new EmptyBackgroundViewWrapper(
                         getTabModelSelector(), getTabCreator(false), ChromeTabbedActivity.this,
                         getAppMenuHandler(), mLayoutManager);
                 bgViewWrapper.initialize();
@@ skipping 117 matching lines @@
                 // Open the last URL shown in the CustomTabActivity.  Unfortunately, there isn't a
                 // good TabLaunchType to use here (FROM_EXTERNAL_APP changes back behavior, e.g.),
                 // but this shouldn't be a problem once Tab reparenting lands.
                 //
                 // TODO(dfalcantara): Use real tab reparenting here when possible.  We should fall
                 //                    back to using the TabState file or URL, in that order.
                 getTabCreator(false).createNewTab(new LoadUrlParams(
                         data.getDataString()), TabLaunchType.FROM_CHROME_UI, null);
             } else if ((resultCode == CustomTabActivity.RESULT_BACK_PRESSED
                     || resultCode == CustomTabActivity.RESULT_CLOSED) && data != null) {
+                // Herb UMA should have already been recorded by the CustomTabActivity.
                 Log.d(TAG, "Herb: Sending app to the background");
+                mActivityStopMetrics.setStopReason(
+                        ActivityStopMetrics.STOP_REASON_CUSTOM_TAB_STOPPED);
                 sendToBackground(null);
             }
             return true;
         }
         return false;
     }
 
     @Override
     public void onAccessibilityModeChanged(boolean enabled) {
         super.onAccessibilityModeChanged(enabled);
@@ skipping 136 matching lines @@
         private void openNewTab(String url, String referer, String headers,
                 String externalAppId, Intent intent, boolean forceNewTab) {
             boolean isAllowedToReturnToExternalApp = IntentUtils.safeGetBooleanExtra(intent,
                     ChromeLauncherActivity.EXTRA_IS_ALLOWED_TO_RETURN_TO_PARENT, true);
 
             String herbFlavor = FeatureUtilities.getHerbFlavor();
             if (isAllowedToReturnToExternalApp
                     && ChromeLauncherActivity.canBeHijackedByHerb(intent)
                     && TextUtils.equals(ChromeSwitches.HERB_FLAVOR_DILL, herbFlavor)) {
                 Log.d(TAG, "Sending to CustomTabActivity");
+                mActivityStopMetrics.setStopReason(
+                        ActivityStopMetrics.STOP_REASON_CUSTOM_TAB_STARTED);
 
                 Intent newIntent = ChromeLauncherActivity.createCustomTabActivityIntent(
                         ChromeTabbedActivity.this, intent, false);
                 newIntent.putExtra(Browser.EXTRA_APPLICATION_ID, getPackageName());
                 newIntent.putExtra(
                         CustomTabIntentDataProvider.EXTRA_OPENED_BY_BROWSER, true);
                 ChromeLauncherActivity.addHerbIntentExtras(ChromeTabbedActivity.this,
                         newIntent, Uri.parse(IntentHandler.getUrlFromIntent(newIntent)));
 
                 // Launch the Activity on top of this task.
@@ skipping 247 matching lines @@
                     && (!isTablet() || getCurrentTabModel().getCount() != 0);
             if (isUrlBarVisible) {
                 getToolbarManager().setUrlBarFocus(true);
             }
         } else {
             return super.onMenuOrKeyboardAction(id, fromMenu);
         }
         return true;
     }
 
+    private void recordBackPressedUma(String logMessage, @BackPressedResult int action) {
+        Log.i(TAG, "Back pressed: " + logMessage);
+        RecordHistogram.recordEnumeratedHistogram(
+                "Android.Activity.ChromeTabbedActivity.SystemBackAction",
+                action, BACK_PRESSED_COUNT);
+    }
+
     @Override
     public boolean handleBackPressed() {
+        RecordUserAction.record("SystemBack");
+
         if (!mUIInitialized) return false;
         final Tab currentTab = getActivityTab();
 
         if (currentTab == null) {
-            if (getToolbarManager().back()) {
-                RecordUserAction.record("SystemBackForNavigation");
-                RecordUserAction.record("MobileTabClobbered");
-            } else {
-                moveTaskToBack(true);
-            }
-            RecordUserAction.record("SystemBack");
-            Log.i(TAG, "handleBackPressed() - currentTab is null");
+            recordBackPressedUma("currentTab is null", BACK_PRESSED_TAB_IS_NULL);
+            moveTaskToBack(true);
             return true;
         }
 
         // If we are in overview mode and not a tablet, then leave overview mode on back.
         if (mLayoutManager.overviewVisible() && !isTablet()) {
+            recordBackPressedUma("Hid overview", BACK_PRESSED_EXITED_TAB_SWITCHER);
             mLayoutManager.hideOverview(true);
-            // TODO(benm): Record any user metrics in this case?
-            Log.i(TAG, "handleBackPressed() - hide overview");
             return true;
         }
 
         if (exitFullscreenIfShowing()) {
-            Log.i(TAG, "handleBackPressed() - exit fullscreen");
+            recordBackPressedUma("Exited fullscreen", BACK_PRESSED_EXITED_FULLSCREEN);
             return true;
         }
 
-        if (!getToolbarManager().back()) {
-            Log.i(TAG, "handleBackPressed() - no back stack");
-            if (handleBackPressedWithoutBackStack(false)) return true;
-        } else {
-            Log.i(TAG, "handleBackPressed() - moving back in navigation");
+        if (getToolbarManager().back()) {
+            recordBackPressedUma("Navigating backward", BACK_PRESSED_NAVIGATED_BACK);
             RecordUserAction.record("SystemBackForNavigation");
             RecordUserAction.record("MobileTabClobbered");
+            return true;
         }
-        RecordUserAction.record("SystemBack");
-
-        return true;
-    }
-
-    /**
-     * Additional logic for handling situations where a user hits a 'back' or 'return' button.
-     *
-     * May result in closing the foreground tab or returning to the app that opened Chrome.
-     *
-     * @param alwaysAllowTabClosure Setting this to true always allows a tab opened by an external
-     *                              app to be closed.
-     * @return Whether the tab closed was opened for a help page.
-     */
-    private boolean handleBackPressedWithoutBackStack(boolean alwaysAllowTabClosure) {
-        final Tab currentTab = getActivityTab();
-        final TabLaunchType type = currentTab.getLaunchType();
-        final int parentId = currentTab.getParentId();
-        final boolean helpUrl = currentTab.getUrl().startsWith(HELP_URL_PREFIX);
 
         // If the current tab url is HELP_URL, then the back button should close the tab to
         // get back to the previous state. The reason for startsWith check is that the
         // actual redirected URL is a different system language based help url.
+        final TabLaunchType type = currentTab.getLaunchType();
+        final boolean helpUrl = currentTab.getUrl().startsWith(HELP_URL_PREFIX);
         if (type == TabLaunchType.FROM_CHROME_UI && helpUrl) {
             getCurrentTabModel().closeTab(currentTab);
-            Log.i(TAG, "handleBackPressedWithoutBackStack() - help url");
+            recordBackPressedUma("Closed tab for help URL", BACK_PRESSED_HELP_URL_CLOSED);
             return true;
         }
 
-        // Herb: Current spec says that tabs are closed only when there is NO "X" visible, i.e. when
-        //       the tab is NOT allowed to return to the external app.
+        // The current spec says that tabs are closed only when there is NO "X" visible, i.e. when
+        // the tab is NOT allowed to return to the external app.
         boolean isAllowedToCloseTab = true;
-        if (alwaysAllowTabClosure) {
-            isAllowedToCloseTab = true;
-        } else {
-            String herbFlavor = FeatureUtilities.getHerbFlavor();
-            if (TextUtils.equals(ChromeSwitches.HERB_FLAVOR_BASIL, herbFlavor)
-                    || TextUtils.equals(ChromeSwitches.HERB_FLAVOR_CHIVE, herbFlavor)) {
-                isAllowedToCloseTab = !currentTab.isAllowedToReturnToExternalApp();
-            }
+        String herbFlavor = FeatureUtilities.getHerbFlavor();
+        if (TextUtils.equals(ChromeSwitches.HERB_FLAVOR_BASIL, herbFlavor)
+                || TextUtils.equals(ChromeSwitches.HERB_FLAVOR_CHIVE, herbFlavor)) {
+            isAllowedToCloseTab = !currentTab.isAllowedToReturnToExternalApp();
         }
 
         // [true]: Reached the bottom of the back stack on a tab the user did not explicitly
         // create (i.e. it was created by an external app or opening a link in background, etc).
         // [false]: Reached the bottom of the back stack on a tab that the user explicitly
         // created (e.g. selecting "new tab" from menu).
+        final int parentId = currentTab.getParentId();
         final boolean shouldCloseTab = type == TabLaunchType.FROM_LINK
                 || (type == TabLaunchType.FROM_EXTERNAL_APP && isAllowedToCloseTab)
                 || type == TabLaunchType.FROM_LONGPRESS_FOREGROUND
                 || type == TabLaunchType.FROM_LONGPRESS_BACKGROUND
                 || (type == TabLaunchType.FROM_RESTORE && parentId != Tab.INVALID_TAB_ID);
 
         // Minimize the app if either:
         // - we decided not to close the tab
         // - we decided to close the tab, but it was opened by an external app, so we will go
         //   exit Chrome on top of closing the tab
         final boolean minimizeApp = !shouldCloseTab || currentTab.isCreatedForExternalApp();
 
         if (minimizeApp) {
-            sendToBackground(shouldCloseTab ? currentTab : null);
+            if (shouldCloseTab) {
+                recordBackPressedUma("Minimized and closed tab", BACK_PRESSED_MINIMIZED_TAB_CLOSED);
+                mActivityStopMetrics.setStopReason(ActivityStopMetrics.STOP_REASON_BACK_BUTTON);
+                sendToBackground(currentTab);
+                return true;
+            } else {
+                recordBackPressedUma("Minimized, kept tab", BACK_PRESSED_MINIMIZED_NO_TAB_CLOSED);
+                mActivityStopMetrics.setStopReason(ActivityStopMetrics.STOP_REASON_BACK_BUTTON);
+                sendToBackground(null);
+                return true;
+            }
         } else if (shouldCloseTab) {
+            recordBackPressedUma("Tab closed", BACK_PRESSED_TAB_CLOSED);
             getCurrentTabModel().closeTab(currentTab, true, false, false);
+            return true;
         }
+
+        assert false : "The back button should have already been handled by this point";
+        recordBackPressedUma("Unhandled", BACK_PRESSED_NOTHING_HAPPENED);
         return false;
     }
 
     /**
      * Sends this Activity to the background.
      *
      * @param tabToClose Tab that will be closed once the app is not visible.
      */
     private void sendToBackground(@Nullable final Tab tabToClose) {
         Log.i(TAG, "sendToBackground(): " + tabToClose);
@@ skipping 232 matching lines @@
         if (getActivityTab() != null) {
             setStatusBarColor(getActivityTab(), getActivityTab().getThemeColor());
         }
     }
 
     @Override
     protected void setStatusBarColor(Tab tab, int color) {
         super.setStatusBarColor(tab, isInOverviewMode() ? Color.BLACK : color);
     }
 }