Fix Android accessibility focus not being drawn over transparent view.

ui/android/java/src/org/chromium/ui/base/WindowAndroid.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.ui.base;
 
 import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
+import android.os.Build;
 import android.os.Bundle;
 import android.util.Log;
 import android.util.SparseArray;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityManager;
 import android.widget.Toast;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 import org.chromium.ui.VSyncMonitor;
 
 import java.lang.ref.WeakReference;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 
 /**
  * The window base class that has the minimum functionality.
  */
 @JNINamespace("ui")
 public class WindowAndroid {
     private static final String TAG = "WindowAndroid";
 
+    @TargetApi(Build.VERSION_CODES.KITKAT)
+    private class TouchExplorationMonitor {
+        // Listener that tells us when touch exploration is enabled or disabled.
+        private AccessibilityManager.TouchExplorationStateChangeListener mTouchExplorationListener;
+
+        TouchExplorationMonitor() {
+            mTouchExplorationListener =
+                    new AccessibilityManager.TouchExplorationStateChangeListener() {
+                public void onTouchExplorationStateChanged(boolean enabled) {
+                    mIsTouchExplorationEnabled =
+                            mAccessibilityManager.isTouchExplorationEnabled();
+                    refreshWillNotDraw();
+                }
+            };
+            mAccessibilityManager.addTouchExplorationStateChangeListener(mTouchExplorationListener);
+        }
+
+        void destroy() {
+            mAccessibilityManager.removeTouchExplorationStateChangeListener(
+                    mTouchExplorationListener);
+        }
+    }
+
     // Native pointer to the c++ WindowAndroid object.
     private long mNativeWindowAndroid = 0;
     private final VSyncMonitor mVSyncMonitor;
 
     // A string used as a key to store intent errors in a bundle
     static final String WINDOW_CALLBACK_ERRORS = "window_callback_errors";
 
     // Error code returned when an Intent fails to start an Activity.
     public static final int START_INTENT_FAILURE = -1;
 
     protected Context mApplicationContext;
     protected SparseArray<IntentCallback> mOutstandingIntents;
 
     // Ideally, this would be a SparseArray<String>, but there's no easy way to store a
     // SparseArray<String> in a bundle during saveInstanceState(). So we use a HashMap and suppress
     // the Android lint warning "UseSparseArrays".
     protected HashMap<Integer, String> mIntentErrors;
 
     // We track all animations over content and provide a drawing placeholder for them.
     private HashSet<Animator> mAnimationsOverContent = new HashSet<Animator>();
     private View mAnimationPlaceholderView;
 
     private ViewGroup mKeyboardAccessoryView;
 
     private boolean mIsKeyboardShowing = false;
 
+    // System accessibility service.
+    private final AccessibilityManager mAccessibilityManager;
+
+    // Whether touch exploration is enabled.
+    private boolean mIsTouchExplorationEnabled;
+
+    // On KitKat and higher, a class that monitors the touch exploration state.
+    private TouchExplorationMonitor mTouchExplorationMonitor;
+
     /**
      * An interface to notify listeners of changes in the soft keyboard's visibility.
      */
     public interface KeyboardVisibilityListener {
         public void keyboardVisibilityChanged(boolean isShowing);
     }
     private LinkedList<KeyboardVisibilityListener> mKeyboardVisibilityListeners =
             new LinkedList<KeyboardVisibilityListener>();
 
     private final VSyncMonitor.Listener mVSyncListener = new VSyncMonitor.Listener() {
@@ skipping 18 matching lines @@
     /**
      * @param context The application context.
      */
     @SuppressLint("UseSparseArrays")
     public WindowAndroid(Context context) {
         assert context == context.getApplicationContext();
         mApplicationContext = context;
         mOutstandingIntents = new SparseArray<IntentCallback>();
         mIntentErrors = new HashMap<Integer, String>();
         mVSyncMonitor = new VSyncMonitor(context, mVSyncListener);
+        mAccessibilityManager = (AccessibilityManager)
+                context.getSystemService(Context.ACCESSIBILITY_SERVICE);
     }
 
     /**
      * Shows an intent and returns the results to the callback object.
      * @param intent   The PendingIntent that needs to be shown.
      * @param callback The object that will receive the results for the intent.
      * @param errorId  The ID of error string to be show if activity is paused before intent
      *                 results, or null if no message is required.
      * @return Whether the intent was shown.
      */
@@ skipping 198 matching lines @@
     }
 
     /**
      * Destroys the c++ WindowAndroid object if one has been created.
      */
     public void destroy() {
         if (mNativeWindowAndroid != 0) {
             nativeDestroy(mNativeWindowAndroid);
             mNativeWindowAndroid = 0;
         }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            if (mTouchExplorationMonitor != null) mTouchExplorationMonitor.destroy();
+        }
     }
 
     /**
      * Returns a pointer to the c++ AndroidWindow object and calls the initializer if
      * the object has not been previously initialized.
      * @return A pointer to the c++ AndroidWindow.
      */
     public long getNativePointer() {
         if (mNativeWindowAndroid == 0) {
             mNativeWindowAndroid = nativeInit();
         }
         return mNativeWindowAndroid;
     }
 
     /**
      * Set the animation placeholder view, which we set to 'draw' during animations, such that
      * animations aren't clipped by the SurfaceView 'hole'. This can be the SurfaceView itself
      * or a view directly on top of it. This could be extended to many views if we ever need it.
      */
     public void setAnimationPlaceholderView(View view) {
         mAnimationPlaceholderView = view;
+
+        // The accessibility focus ring also gets clipped by the SurfaceView 'hole', so
+        // make sure the animation placeholder view is in place if touch exploration is on.
+        mIsTouchExplorationEnabled = mAccessibilityManager.isTouchExplorationEnabled();
+        refreshWillNotDraw();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            mTouchExplorationMonitor = new TouchExplorationMonitor();
+        }
     }
 
     /**
      * Sets the keyboard accessory view.
      * @param view This view sits at the bottom of the content area and pushes the content up rather
      *             than overlaying it. Currently used as a container for Autofill suggestions.
      */
     public void setKeyboardAccessoryView(ViewGroup view) {
         mKeyboardAccessoryView = view;
     }
@@ skipping 52 matching lines @@
         if (animation.isStarted()) throw new IllegalArgumentException("Already started.");
         boolean added = mAnimationsOverContent.add(animation);
         if (!added) throw new IllegalArgumentException("Already Added.");
 
         // We start the animation in this method to help guarantee that we never get stuck in this
         // state or leak objects into the set. Starting the animation here should guarantee that we
         // get an onAnimationEnd callback, and remove this animation.
         animation.start();
 
         // When the first animation starts, make the placeholder 'draw' itself.
-        if (mAnimationPlaceholderView.willNotDraw()) {
-            mAnimationPlaceholderView.setWillNotDraw(false);
-        }
+        refreshWillNotDraw();
 
         // When the last animation ends, remove the placeholder view,
         // returning to the default optimized state.
         animation.addListener(new AnimatorListenerAdapter() {
             @Override
             public void onAnimationEnd(Animator animation) {
                 animation.removeListener(this);
                 mAnimationsOverContent.remove(animation);
-                if (mAnimationsOverContent.isEmpty()) {
-                    mAnimationPlaceholderView.setWillNotDraw(true);
-                }
+                refreshWillNotDraw();
             }
         });
     }
 
+    /**
+     * Update whether the placeholder is 'drawn' based on whether an animation is running
+     * or touch exploration is enabled - if either of those are true, we call
+     * setWillNotDraw(false) to ensure that the animation is drawn over the SurfaceView,
+     * and otherwise we call setWillNotDraw(true).
+     */
+    private void refreshWillNotDraw() {
+        boolean willNotDraw = !mIsTouchExplorationEnabled && mAnimationsOverContent.isEmpty();
+        if (mAnimationPlaceholderView.willNotDraw() != willNotDraw) {
+            mAnimationPlaceholderView.setWillNotDraw(willNotDraw);
+        }
+    }
+
     private native long nativeInit();
     private native void nativeOnVSync(long nativeWindowAndroid,
                                       long vsyncTimeMicros,
                                       long vsyncPeriodMicros);
     private native void nativeOnActivityPaused(long nativeWindowAndroid);
     private native void nativeOnActivityResumed(long nativeWindowAndroid);
     private native void nativeDestroy(long nativeWindowAndroid);
 
 }