[Android] Focus/Blur contents when window focus changes

content/public/android/java/src/org/chromium/content/browser/ContentViewCore.java

 // Copyright 2012 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.content.browser;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.assist.AssistStructure.ViewNode;
 import android.content.ClipData;
@@ skipping 94 matching lines @@
     // side would prevent garbage collection of the ContentViewCore (as that strong ref would
     // create a new GC root).
     // For that reason, we store only a weak reference to the interface object on the
     // native side. However we still need a strong reference on the Java side to
     // prevent garbage collection if the embedder doesn't maintain their own ref to the
     // interface object - the Java side ref won't create a new GC root.
     // This map stores those references. We put into the map on addJavaScriptInterface()
     // and remove from it in removeJavaScriptInterface(). The annotation class is stored for
     // the purpose of migrating injected objects from one instance of CVC to another, which
     // is used by Android WebView to support WebChromeClient.onCreateWindow scenario.
-    private final Map<String, Pair<Object, Class>> mJavaScriptInterfaces =
-            new HashMap<String, Pair<Object, Class>>();
+    private final Map<String, Pair<Object, Class>> mJavaScriptInterfaces = new HashMap<>();

[aelias_OOO_until_Jul13, 2017/03/30 02:06:55]

I assume you made these changes because of a presubmit warning or something? 
Could you keep them out of this patch and ignore the warning?  This makes the
git history confusing and a revert (if needed) more annoying.

[mthiesse, 2017/03/30 14:51:51]

My editor automatically makes these changes, and I can't convince it not to.
It's really annoying having to undo them every time I save the file.

 
     // Additionally, we keep track of all Java bound JS objects that are in use on the
     // current page to ensure that they are not garbage collected until the page is
     // navigated. This includes interface objects that have been removed
     // via the removeJavaScriptInterface API and transient objects returned from methods
     // on the interface object. Note we use HashSet rather than Set as the native side
     // expects HashSet (no bindings for interfaces).
-    private final HashSet<Object> mRetainedJavaScriptObjects = new HashSet<Object>();
+    private final HashSet<Object> mRetainedJavaScriptObjects = new HashSet<>();
 
     /**
      * A {@link WebContentsObserver} that listens to frame navigation events.
      */
     private static class ContentViewWebContentsObserver extends WebContentsObserver {
         // Using a weak reference avoids cycles that might prevent GC of WebView's WebContents.
         private final WeakReference<ContentViewCore> mWeakContentViewCore;
 
         ContentViewWebContentsObserver(ContentViewCore contentViewCore) {
             super(contentViewCore.getWebContents());
-            mWeakContentViewCore = new WeakReference<ContentViewCore>(contentViewCore);
+            mWeakContentViewCore = new WeakReference<>(contentViewCore);
         }
 
         @Override
         public void didFinishNavigation(String url, boolean isInMainFrame, boolean isErrorPage,
                 boolean hasCommitted, boolean isSameDocument, boolean isFragmentNavigation,
                 Integer pageTransition, int errorCode, String errorDescription,
                 int httpStatusCode) {
             determinedProcessVisibility();
 
             if (hasCommitted && isInMainFrame && !isSameDocument) {
@@ skipping 218 matching lines @@
     // screen orientation.
     private boolean mFullscreenRequiredForOrientationLock = true;
 
     // A ViewAndroidDelegate that delegates to the current container view.
     private ViewAndroidDelegate mViewAndroidDelegate;
 
     // NOTE: This object will not be released by Android framework until the matching
     // ResultReceiver in the InputMethodService (IME app) gets gc'ed.
     private ShowKeyboardResultReceiver mShowKeyboardResultReceiver;
 
+    // Whether this ContentViewCore has view focus.
+    private boolean mHasViewFocus;
+    // Whether this ContentViewCore has window focus.
+    private boolean mHasWindowFocus;
+
     // The list of observers that are notified when ContentViewCore changes its WindowAndroid.
     private final ObserverList<WindowAndroidChangedObserver> mWindowAndroidChangedObservers;
 
     /**
      * @param webContents The {@link WebContents} to find a {@link ContentViewCore} of.
      * @return            A {@link ContentViewCore} that is connected to {@code webContents} or
      *                    {@code null} if none exists.
      */
     public static ContentViewCore fromWebContents(WebContents webContents) {
         return nativeFromWebContentsAndroid(webContents);
     }
 
     /**
      * Constructs a new ContentViewCore. Embedders must call initialize() after constructing
      * a ContentViewCore and before using it.
      *
      * @param context The context used to create this.
      */
     public ContentViewCore(Context context, String productVersion) {
         mContext = context;
         mProductVersion = productVersion;
         mRenderCoordinates = new RenderCoordinates();
         mAccessibilityManager = (AccessibilityManager)
                 getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
         mSystemCaptioningBridge = CaptioningBridgeFactory.getSystemCaptioningBridge(mContext);
-        mGestureStateListeners = new ObserverList<GestureStateListener>();
+        mGestureStateListeners = new ObserverList<>();
         mGestureStateListenersIterator = mGestureStateListeners.rewindableIterator();
 
-        mWindowAndroidChangedObservers = new ObserverList<WindowAndroidChangedObserver>();
+        mWindowAndroidChangedObservers = new ObserverList<>();
     }
 
     /**
      * @return The context used for creating this ContentViewCore.
      */
     @CalledByNative
     public Context getContext() {
         return mContext;
     }
 
@@ skipping 256 matching lines @@
      */
     public void setContainerView(ViewGroup containerView) {
         try {
             TraceEvent.begin("ContentViewCore.setContainerView");
             if (mContainerView != null) {
                 hideSelectPopupWithCancelMessage();
                 mPopupZoomer.hide(false);
             }
 
             mContainerView = containerView;
+            onFocusChangedInternal(getRealWindowFocusedState(), containerView.hasFocus(),
+                    false /* hideKeyboardOnBlur */);
             mContainerView.setClickable(true);
             if (mSelectionPopupController != null) {
                 mSelectionPopupController.setContainerView(containerView);
             }
         } finally {
             TraceEvent.end("ContentViewCore.setContainerView");
         }
     }
 
+    /**
+     * Note: We don't use View#hasWindowFocus() because it returns incorrect values when the View
+     * doesn't have View focus.
+     * @return Whether the containerView actually has Window focus.
+     */
+    private boolean getRealWindowFocusedState() {
+        boolean hasWindowFocus = false;
+        int[] states = mContainerView.getDrawableState();
+        for (int state : states) {
+            if ((state & android.R.attr.state_window_focused) != 0) hasWindowFocus = true;
+        }
+        return hasWindowFocus;
+    }
+
     @CalledByNative
     private void onNativeContentViewCoreDestroyed(long nativeContentViewCore) {
         assert nativeContentViewCore == mNativeContentViewCore;
         mNativeContentViewCore = 0;
     }
 
     /**
      * Set the Container view Internals.
      * @param internalDispatcher Handles dispatching all hidden or super methods to the
      *                           containerView.
@@ skipping 629 matching lines @@
     private void cancelRequestToScrollFocusedEditableNodeIntoView() {
         // Zero-ing the rect will prevent |updateAfterSizeChanged()| from
         // issuing the delayed form focus event.
         mFocusPreOSKViewportRect.setEmpty();
     }
 
     /**
      * @see View#onWindowFocusChanged(boolean)
      */
     public void onWindowFocusChanged(boolean hasWindowFocus) {
+        if (mHasWindowFocus == hasWindowFocus) return;
         mImeAdapter.onWindowFocusChanged(hasWindowFocus);
         if (!hasWindowFocus) resetGestureDetection();
         mSelectionPopupController.onWindowFocusChanged(hasWindowFocus);
         for (mGestureStateListenersIterator.rewind(); mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onWindowFocusChanged(hasWindowFocus);
         }
+        onFocusChangedInternal(hasWindowFocus, mHasViewFocus, true /* hideKeyboardOnBlur */);
     }
 
     public void onFocusChanged(boolean gainFocus, boolean hideKeyboardOnBlur) {

[aelias_OOO_until_Jul13, 2017/03/30 02:06:55]

Please rename "gainFocus" to "hasViewFocus"

[mthiesse, 2017/03/30 14:51:51]

Done.

-        mImeAdapter.onViewFocusChanged(gainFocus, hideKeyboardOnBlur);
+        if (mHasViewFocus == gainFocus) return;
+        onFocusChangedInternal(mHasWindowFocus, gainFocus, hideKeyboardOnBlur);
+    }
+
+    @VisibleForTesting
+    public void onFocusChangedInternal(
+            boolean hasWindowFocus, boolean hasViewFocus, boolean hideKeyboardOnBlur) {
+        boolean hadInputFocus = mHasWindowFocus && mHasViewFocus;
+        boolean hasInputFocus = hasWindowFocus && hasViewFocus;
+        mHasWindowFocus = hasWindowFocus;
+        mHasViewFocus = hasViewFocus;
+        if (hasInputFocus == hadInputFocus) return;

[aelias_OOO_until_Jul13, 2017/03/30 02:06:55]

This early-return seems to do nothing given the others.  I suggest deleting this
one, and putting the assignments right below the early-returns in
onWindowFocusChanged and onFocusChanged.

[mthiesse, 2017/03/30 14:51:51]

It doesn't do nothing - it stops us from doing work when we go from (false,
false) to (false, true).

+        mImeAdapter.onViewFocusChanged(hasInputFocus, hideKeyboardOnBlur);
 
         // Used in test that bypasses initialize().
         if (mJoystickScrollProvider != null) {
-            mJoystickScrollProvider.setEnabled(gainFocus && !isFocusedNodeEditable());
+            mJoystickScrollProvider.setEnabled(hasInputFocus && !isFocusedNodeEditable());
         }
 
-        if (gainFocus) {
+        if (hasInputFocus) {
             restoreSelectionPopupsIfNecessary();
         } else {
             cancelRequestToScrollFocusedEditableNodeIntoView();
             if (mPreserveSelectionOnNextLossOfFocus) {
                 mPreserveSelectionOnNextLossOfFocus = false;
                 hidePopupsAndPreserveSelection();
             } else {
                 hidePopupsAndClearSelection();
                 // Clear the selection. The selection is cleared on destroying IME
                 // and also here since we may receive destroy first, for example
                 // when focus is lost in webview.
                 clearSelection();
             }
         }
-        if (mNativeContentViewCore != 0) nativeSetFocus(mNativeContentViewCore, gainFocus);
+        if (mNativeContentViewCore != 0) nativeSetFocus(mNativeContentViewCore, hasInputFocus);
     }
 
     /**
      * @see View#onKeyUp(int, KeyEvent)
      */
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         if (mPopupZoomer.isShowing() && keyCode == KeyEvent.KEYCODE_BACK) {
             mPopupZoomer.backButtonPressed();
             return true;
         }
@@ skipping 436 matching lines @@
         if (mContainerView.getParent() == null || mContainerView.getVisibility() != View.VISIBLE) {
             mNativeSelectPopupSourceFrame = nativeSelectPopupSourceFrame;
             selectPopupMenuItems(null);
             return;
         }
 
         hidePopupsAndClearSelection();
         assert mNativeSelectPopupSourceFrame == 0 : "Zombie popup did not clear the frame source";
 
         assert items.length == enabled.length;
-        List<SelectPopupItem> popupItems = new ArrayList<SelectPopupItem>();
+        List<SelectPopupItem> popupItems = new ArrayList<>();
         for (int i = 0; i < items.length; i++) {
             popupItems.add(new SelectPopupItem(items[i], enabled[i]));
         }
         if (DeviceFormFactor.isTablet(mContext) && !multiple && !isTouchExplorationEnabled()) {
             mSelectPopup = new SelectPopupDropdown(
                     this, anchorView, popupItems, selectedIndices, rightAligned);
         } else {
             if (getWindowAndroid() == null) return;
             Context windowContext = getWindowAndroid().getContext().get();
             if (windowContext == null) return;
@@ skipping 840 matching lines @@
     private native void nativeSetTextTrackSettings(long nativeContentViewCoreImpl,
             boolean textTracksEnabled, String textTrackBackgroundColor, String textTrackFontFamily,
             String textTrackFontStyle, String textTrackFontVariant, String textTrackTextColor,
             String textTrackTextShadow, String textTrackTextSize);
 
     private native void nativeSetBackgroundOpaque(long nativeContentViewCoreImpl, boolean opaque);
     private native boolean nativeIsTouchDragDropEnabled(long nativeContentViewCoreImpl);
     private native void nativeOnDragEvent(long nativeContentViewCoreImpl, int action, int x, int y,
             int screenX, int screenY, String[] mimeTypes, String content);
 }