Add debug loggings to figure out a snackbar crash

chrome/android/java/src/org/chromium/chrome/browser/snackbar/SnackbarManager.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.snackbar;
 
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.content.Context;
 import android.graphics.Rect;
+import android.os.Build;
 import android.os.Handler;
+import android.util.AttributeSet;
 import android.view.Gravity;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewTreeObserver.OnGlobalLayoutListener;
-import android.view.Window;
+import android.widget.LinearLayout;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeActivity;
 import org.chromium.chrome.browser.device.DeviceClassManager;
 import org.chromium.ui.UiUtils;
 import org.chromium.ui.base.DeviceFormFactor;
 
 import java.util.HashSet;
 import java.util.Stack;
 
 /**
  * Manager for the snackbar showing at the bottom of activity.
  * <p/>
  * There should be only one SnackbarManager and one snackbar in the activity. The manager maintains
  * a stack to store all entries that should be displayed. When showing a new snackbar, old entry
  * will be pushed to stack and text/button will be updated to the newest entry.
  * <p/>
  * When action button is clicked, this manager will call
  * {@link SnackbarController#onAction(Object)} in corresponding listener, and show the next
  * entry in stack. Otherwise if no action is taken by user during
  * {@link #DEFAULT_SNACKBAR_DURATION_MS} milliseconds, it will clear the stack and call
  * {@link SnackbarController#onDismissNoAction(Object)} to all listeners.
  */
 public class SnackbarManager implements OnClickListener, OnGlobalLayoutListener {
 
+    private static RuntimeException sWindowDetachTrace;
+
+    /**
+     * A {@link LinearLayout} that logs the stack trace when {@link #onDetachedFromWindow()} is
+     * called.
+     */
+    public static class WindowDismissalAwareLayout extends LinearLayout {
+        // TODO(ianwen): remove this class after crbug.com/553569 is fixed.
+        /**
+         * Constructor for XML inflation.
+         */
+        public WindowDismissalAwareLayout(Context context, AttributeSet attrs) {
+            super(context, attrs);
+        }
+
+        @Override
+        protected void onDetachedFromWindow() {
+            super.onDetachedFromWindow();
+            sWindowDetachTrace = new RuntimeException(
+                    "Stacktrace for Snackbar view to be detached from window");
+        }
+    }
+
     /**
      * Interface that shows the ability to provide a unified snackbar manager.
      */
     public interface SnackbarManageable {
         /**
          * @return The snackbar manager that has a proper anchor view.
          */
         SnackbarManager getSnackbarManager();
     }
 
@@ skipping 24 matching lines @@
          * Notify each SnackbarControllers instance only once immediately before the snackbar is
          * dismissed. This function is likely to be used for controllers to do user metrics for
          * dismissal.
          * @param isTimeout Whether this dismissal is triggered by timeout.
          */
         void onDismissForEachType(boolean isTimeout);
     }
 
     private static final int DEFAULT_SNACKBAR_DURATION_MS = 3000;
     private static final int ACCESSIBILITY_MODE_SNACKBAR_DURATION_MS = 6000;
+    private static final String TAG = "cr_snackbar";
 
     // Used instead of the constant so tests can override the value.
     private static int sSnackbarDurationMs = DEFAULT_SNACKBAR_DURATION_MS;
     private static int sAccessibilitySnackbarDurationMs = ACCESSIBILITY_MODE_SNACKBAR_DURATION_MS;
 
     private final boolean mIsTablet;
 
+    private Activity mActivity;
     private View mDecor;
     private final Handler mUIThreadHandler;
     private Stack<Snackbar> mStack = new Stack<Snackbar>();
     private SnackbarPopupWindow mPopup;
     private final Runnable mHideRunnable = new Runnable() {
         @Override
         public void run() {
             dismissAllSnackbars(true);
         }
     };
 
     // Variables used and reused in local calculations.
     private int[] mTempDecorPosition = new int[2];
     private Rect mTempVisibleDisplayFrame = new Rect();
 
     /**
      * Constructs a SnackbarManager to show snackbars in the given window.
      */
-    public SnackbarManager(Window window) {
-        mDecor = window.getDecorView();
+    public SnackbarManager(Activity activity) {
+        mActivity = activity;
+        mDecor = activity.getWindow().getDecorView();
         mUIThreadHandler = new Handler();
         mIsTablet = DeviceFormFactor.isTablet(mDecor.getContext());
     }
 
     /**
      * Shows a snackbar at the bottom of the screen, or above the keyboard if the keyboard is
      * visible.
      */
     public void showSnackbar(Snackbar snackbar) {
         int durationMs = snackbar.getDuration();
@@ skipping 21 matching lines @@
      * Warning: Calling this method might cause cascading destroy loop, because you might trigger
      * callbacks for other {@link SnackbarController}. This method is only meant to be used during
      * {@link ChromeActivity}'s destruction routine. For other purposes, use
      * {@link #dismissSnackbars(SnackbarController)} instead.
      * <p>
      * Dismisses all snackbars in stack. This will call
      * {@link SnackbarController#onDismissNoAction(Object)} for every closing snackbar.
      *
      * @param isTimeout Whether dismissal was triggered by timeout.
      */
+    @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
     public void dismissAllSnackbars(boolean isTimeout) {
         mUIThreadHandler.removeCallbacks(mHideRunnable);
 
         if (mPopup != null) {
-            mPopup.dismiss();
+            // TODO(ianwen): remove the try catch after crbug.com/553569 is fixed.
+            try {
+                mPopup.dismiss();
+            } catch (IllegalArgumentException ex) {
+                if (mActivity != null) {
+                    android.util.Log.d(TAG, "Activity.toString()? " + mActivity);
+                    android.util.Log.d(TAG, "Activity is finishing? " + mActivity.isFinishing());
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+                        android.util.Log.d(TAG, "Activity is destroyed?" + mActivity.isDestroyed());
+                    }
+                }
+                if (sWindowDetachTrace != null) {
+                    throw sWindowDetachTrace;

[newt (away), 2015/11/18 01:46:54]

If you throw sWindowDetachTrace then Chrome will crash immediately and the
IllegalArgumentException ex won't be thrown. Not what we want.

Instead, you should log sWindowDetachTrace:

    android.util.Log.d(TAG, "blah blah", sWindowDetachTrace);

[Ian Wen, 2015/11/18 01:56:26]

Done.

+                }
+                throw ex;
+            }
+
             mPopup = null;
         }
 
         HashSet<SnackbarController> controllers = new HashSet<SnackbarController>();
 
         while (!mStack.isEmpty()) {
             Snackbar snackbar = mStack.pop();
             if (!controllers.contains(snackbar.getController())) {
                 snackbar.getController().onDismissForEachType(isTimeout);
                 controllers.add(snackbar.getController());
@@ skipping 128 matching lines @@
     /**
      * Overrides the default snackbar duration with a custom value for testing.
      * @param durationMs The duration to use in ms.
      */
     @VisibleForTesting
     public static void setDurationForTesting(int durationMs) {
         sSnackbarDurationMs = durationMs;
         sAccessibilitySnackbarDurationMs = durationMs;
     }
 }