Refactor handleMessage() functionality in fullscreen

chrome/android/java/src/org/chromium/chrome/browser/fullscreen/FullscreenHtmlApiHandler.java

 // Copyright 2014 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.fullscreen;
 
 import static android.view.View.SYSTEM_UI_FLAG_FULLSCREEN;
 import static android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
 import static android.view.View.SYSTEM_UI_FLAG_LOW_PROFILE;
 
 import android.content.res.Resources;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.view.Gravity;
 import android.view.View;
 import android.view.View.OnLayoutChangeListener;
 import android.view.Window;
 import android.view.WindowManager;
 
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.widget.TextBubble;
 import org.chromium.content.browser.ContentViewCore;
 
+import java.lang.ref.WeakReference;
+
 /**
  * Handles updating the UI based on requests to the HTML Fullscreen API.
  */
 public class FullscreenHtmlApiHandler {
     private static final int MSG_ID_HIDE_NOTIFICATION_BUBBLE = 1;
     private static final int MSG_ID_SET_FULLSCREEN_SYSTEM_UI_FLAGS = 2;
     private static final int MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG = 3;
 
     private static final int MAX_NOTIFICATION_DIMENSION_DP = 600;
 
@@ skipping 61 matching lines @@
          */
         void onFullscreenExited(ContentViewCore contentViewCore);
 
         /**
          * @return Whether the notification bubble should be shown. For fullscreen video in
          *         overlay mode, the notification bubble should be disabled.
          */
         boolean shouldShowNotificationBubble();
     }
 
+    // This static inner class holds a WeakReference to the outer object, to avoid triggering the
+    // lint HandlerLeak warning.
+    private static class FullscreenHandler extends Handler {
+        private final WeakReference<FullscreenHtmlApiHandler> mFullscreenHtmlApiHandler;
+
+        public FullscreenHandler(FullscreenHtmlApiHandler fullscreenHtmlApiHandler) {
+            mFullscreenHtmlApiHandler = new WeakReference<FullscreenHtmlApiHandler>(
+                    fullscreenHtmlApiHandler);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            if (msg == null) return;
+            FullscreenHtmlApiHandler fullscreenHtmlApiHandler = mFullscreenHtmlApiHandler.get();
+            switch (msg.what) {
+                case MSG_ID_HIDE_NOTIFICATION_BUBBLE:
+                    fullscreenHtmlApiHandler.hideNotificationBubble();
+                    break;
+                case MSG_ID_SET_FULLSCREEN_SYSTEM_UI_FLAGS: {
+                    assert fullscreenHtmlApiHandler.getPersistentFullscreenMode() :
+                        "Calling after we exited fullscreen";
+                    final ContentViewCore contentViewCore =
+                            fullscreenHtmlApiHandler.getContentViewCoreInFullscreen();
+                    if (contentViewCore == null) return;
+                    final View contentView = contentViewCore.getContainerView();
+                    int systemUiVisibility = contentView.getSystemUiVisibility();
+                    if ((systemUiVisibility & SYSTEM_UI_FLAG_FULLSCREEN)
+                            == SYSTEM_UI_FLAG_FULLSCREEN) {
+                        return;
+                    }
+                    systemUiVisibility |= SYSTEM_UI_FLAG_FULLSCREEN;
+                    systemUiVisibility |= SYSTEM_UI_FLAG_LOW_PROFILE;
+                    contentView.setSystemUiVisibility(systemUiVisibility);
+
+                    // Trigger a update to clear the SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN flag
+                    // once the view has been laid out after this system UI update.  Without
+                    // clearing this flag, the keyboard appearing will not trigger a relayout
+                    // of the contents, which prevents updating the overdraw amount to the
+                    // renderer.
+                    contentView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
+                        @Override
+                        public void onLayoutChange(View v, int left, int top, int right,
+                                int bottom, int oldLeft, int oldTop, int oldRight,
+                                int oldBottom) {
+                            sendEmptyMessageDelayed(MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG,
+                                    CLEAR_LAYOUT_FULLSCREEN_DELAY_MS);
+                            contentView.removeOnLayoutChangeListener(this);
+                        }
+                    });
+                    break;
+                }
+                case MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG: {
+                    // Change this assert to simply ignoring the message to work around
+                    // http://crbug/365638
+                    // TODO(aberent): Fix bug
+                    // assert mIsPersistentMode : "Calling after we exited fullscreen";
+                    if (!fullscreenHtmlApiHandler.getPersistentFullscreenMode()) return;
+                    final ContentViewCore contentViewCore =
+                            fullscreenHtmlApiHandler.getContentViewCoreInFullscreen();
+                    if (contentViewCore == null) return;
+                    final View view = contentViewCore.getContainerView();
+                    int systemUiVisibility = view.getSystemUiVisibility();
+                    if ((systemUiVisibility & SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) == 0) {
+                        return;
+                    }
+                    systemUiVisibility &= ~SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
+                    view.setSystemUiVisibility(systemUiVisibility);
+                    break;
+                }
+                default:
+                    assert false : "Unexpected message for ID: " + msg.what;
+                    break;
+            }
+        }
+    }
+
     /**
      * Constructs the handler that will manage the UI transitions from the HTML fullscreen API.
      *
      * @param window The window containing the view going to fullscreen.
      * @param delegate The delegate that allows embedders to handle fullscreen transitions.
      * @param persistentFullscreenSupported
      */
     public FullscreenHtmlApiHandler(Window window, FullscreenHtmlApiDelegate delegate,
             boolean persistentFullscreenSupported) {
         mWindow = window;
         mDelegate = delegate;
         mPersistentFullscreenSupported = persistentFullscreenSupported;
-
-        mHandler = new Handler() {
-            @Override
-            public void handleMessage(Message msg) {
-                if (msg == null) return;
-                switch (msg.what) {
-                    case MSG_ID_HIDE_NOTIFICATION_BUBBLE:
-                        hideNotificationBubble();
-                        break;
-                    case MSG_ID_SET_FULLSCREEN_SYSTEM_UI_FLAGS: {
-                        assert mIsPersistentMode : "Calling after we exited fullscreen";
-                        final ContentViewCore contentViewCore = mContentViewCoreInFullscreen;
-                        if (contentViewCore == null) return;
-                        final View contentView = contentViewCore.getContainerView();
-                        int systemUiVisibility = contentView.getSystemUiVisibility();
-                        if ((systemUiVisibility & SYSTEM_UI_FLAG_FULLSCREEN)
-                                == SYSTEM_UI_FLAG_FULLSCREEN) {
-                            return;
-                        }
-                        systemUiVisibility |= SYSTEM_UI_FLAG_FULLSCREEN;
-                        systemUiVisibility |= SYSTEM_UI_FLAG_LOW_PROFILE;
-                        contentView.setSystemUiVisibility(systemUiVisibility);
-
-                        // Trigger a update to clear the SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN flag
-                        // once the view has been laid out after this system UI update.  Without
-                        // clearing this flag, the keyboard appearing will not trigger a relayout
-                        // of the contents, which prevents updating the overdraw amount to the
-                        // renderer.
-                        contentView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
-                            @Override
-                            public void onLayoutChange(View v, int left, int top, int right,
-                                    int bottom, int oldLeft, int oldTop, int oldRight,
-                                    int oldBottom) {
-                                sendEmptyMessageDelayed(MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG,
-                                        CLEAR_LAYOUT_FULLSCREEN_DELAY_MS);
-                                contentView.removeOnLayoutChangeListener(this);
-                            }
-                        });
-                        break;
-                    }
-                    case MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG: {
-                        // Change this assert to simply ignoring the message to work around
-                        // http://crbug/365638
-                        // TODO(aberent): Fix bug
-                        // assert mIsPersistentMode : "Calling after we exited fullscreen";
-                        if (!mIsPersistentMode) return;
-                        if (mContentViewCoreInFullscreen == null) return;
-                        final View view = mContentViewCoreInFullscreen.getContainerView();
-                        int systemUiVisibility = view.getSystemUiVisibility();
-                        if ((systemUiVisibility & SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) == 0) {
-                            return;
-                        }
-                        systemUiVisibility &= ~SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
-                        view.setSystemUiVisibility(systemUiVisibility);
-                        break;
-                    }
-                    default:
-                        assert false : "Unexpected message for ID: " + msg.what;
-                        break;
-                }
-            }
-        };
-
+        mHandler = new FullscreenHandler(this);
         Resources resources = mWindow.getContext().getResources();
         float density = resources.getDisplayMetrics().density;
         mNotificationMaxDimension = (int) (density * MAX_NOTIFICATION_DIMENSION_DP);
     }
 
     /**
      * Enters or exits persistent fullscreen mode.  In this mode, the top controls will be
      * permanently hidden until this mode is exited.
      *
      * @param enabled Whether to enable persistent fullscreen mode.
@@ skipping 103 matching lines @@
                 }
                 contentView.removeOnLayoutChangeListener(this);
             }
         };
         contentView.addOnLayoutChangeListener(mFullscreenOnLayoutChangeListener);
         contentView.setSystemUiVisibility(systemUiVisibility);
         mContentViewCoreInFullscreen = contentViewCore;
     }
 
     /**
+     * Gets the fullscreen ContentViewCore.
+     */
+    public ContentViewCore getContentViewCoreInFullscreen() {
+        return mContentViewCoreInFullscreen;
+    }
+
+    /**
      * Creates (if necessary) and returns a notification bubble.
      */
     private TextBubble getOrCreateNotificationBubble() {
         if (mNotificationBubble == null) {
             Bundle b = new Bundle();
             b.putBoolean(TextBubble.BACKGROUND_INTRINSIC_PADDING, true);
             b.putBoolean(TextBubble.CENTER, true);
             b.putBoolean(TextBubble.UP_DOWN, true);
             b.putInt(TextBubble.TEXT_STYLE_ID, android.R.style.TextAppearance_DeviceDefault_Medium);
             b.putInt(TextBubble.ANIM_STYLE_ID, R.style.FullscreenNotificationBubble);
@@ skipping 60 matching lines @@
         if (!hasWindowFocus) hideNotificationBubble();
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) return;
 
         mHandler.removeMessages(MSG_ID_SET_FULLSCREEN_SYSTEM_UI_FLAGS);
         mHandler.removeMessages(MSG_ID_CLEAR_LAYOUT_FULLSCREEN_FLAG);
         if (mContentViewCoreInFullscreen == null || !mIsPersistentMode || !hasWindowFocus) return;
         mHandler.sendEmptyMessageDelayed(
                 MSG_ID_SET_FULLSCREEN_SYSTEM_UI_FLAGS, ANDROID_CONTROLS_SHOW_DURATION_MS);
     }
 }