android_webview: Let AwContents manage TouchHandleDrawable

android_webview/java/src/org/chromium/android_webview/PopupTouchHandleDrawable.java

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2016 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.input;
+package org.chromium.android_webview;
 
 import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.os.SystemClock;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.WindowManager;
 import android.view.animation.AnimationUtils;
 import android.widget.PopupWindow;
 
+import org.chromium.base.ObserverList;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
-import org.chromium.content.browser.ContainerViewObserver;
 import org.chromium.content.browser.ContentViewCore;
 import org.chromium.content.browser.PositionObserver;
 import org.chromium.content.browser.ViewPositionObserver;
+import org.chromium.content.browser.input.HandleViewResources;
 import org.chromium.content_public.browser.GestureStateListener;
 import org.chromium.ui.touch_selection.TouchHandleOrientation;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 /**
  * View that displays a selection or insertion handle for text editing.
  *
  * While a HandleView is logically a child of some other view, it does not exist in that View's
  * hierarchy.
  *
  */
-@JNINamespace("content")
+@JNINamespace("android_webview")
 public class PopupTouchHandleDrawable extends View {
     private final PopupWindow mContainer;
     private final PositionObserver.Listener mParentPositionListener;
-    private final ContainerViewObserver mParentViewObserver;
     private ContentViewCore mContentViewCore;
     private PositionObserver mParentPositionObserver;
     private Drawable mDrawable;
 
+    // The native side of this object.
+    private final long mNativeDrawable;
+
     // The position of the handle relative to the parent view.
     private int mPositionX;
     private int mPositionY;
 
     // The position of the parent relative to the application's root view.
     private int mParentPositionX;
     private int mParentPositionY;
 
     // The mirror values based on which the handles are inverted about X and Y axes.
     private boolean mMirrorHorizontal;
@@ skipping 28 matching lines @@
     // in the same frame. Thus, to ensure the PopupWindow is seen in the right
     // location, when the PopupWindow reappears we delay the visibility update
     // by one frame after setting the position.
     private boolean mDelayVisibilityUpdateWAR;
 
     // Deferred runnable to avoid invalidating outside of frame dispatch,
     // in turn avoiding issues with sync barrier insertion.
     private Runnable mInvalidationRunnable;
     private boolean mHasPendingInvalidate;
 
-    private PopupTouchHandleDrawable(ContentViewCore contentViewCore) {
+    // List of drawables used to inform them of the container view switching.
+    private final ObserverList<PopupTouchHandleDrawable> mDrawableObserverList;
+
+    private PopupTouchHandleDrawable(ObserverList<PopupTouchHandleDrawable> drawableObserverList,
+            ContentViewCore contentViewCore, double dipScale) {
         super(contentViewCore.getContainerView().getContext());
+        mDrawableObserverList = drawableObserverList;
+        mDrawableObserverList.addObserver(this);
+
         mContentViewCore = contentViewCore;
         mContainer = new PopupWindow(mContentViewCore.getWindowAndroid().getContext().get(),
                 null, android.R.attr.textSelectHandleWindowStyle);
         mContainer.setSplitTouchEnabled(true);
         mContainer.setClippingEnabled(false);
 
         // The built-in PopupWindow animation causes jank when transitioning between
         // visibility states. We use a custom fade-in animation when necessary.
         mContainer.setAnimationStyle(0);
 
         // The SUB_PANEL window layout type improves z-ordering with respect to
         // other popup-based elements.
         setWindowLayoutType(mContainer, WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL);
         mContainer.setWidth(ViewGroup.LayoutParams.WRAP_CONTENT);
         mContainer.setHeight(ViewGroup.LayoutParams.WRAP_CONTENT);
 
         mAlpha = 1.f;
         mVisible = getVisibility() == VISIBLE;
         mFocused = mContentViewCore.getContainerView().hasWindowFocus();
 
         mParentPositionObserver = new ViewPositionObserver(mContentViewCore.getContainerView());
         mParentPositionListener = new PositionObserver.Listener() {
             @Override
             public void onPositionChanged(int x, int y) {
                 updateParentPosition(x, y);
             }
         };
-        mParentViewObserver = new ContainerViewObserver() {
-            @Override
-            public void onContainerViewChanged(ViewGroup newContainerView) {
-                // If the parent View ever changes, the parent position observer
-                // must be updated accordingly.
-                mParentPositionObserver.clearListener();
-                mParentPositionObserver = new ViewPositionObserver(newContainerView);
-                if (mContainer.isShowing()) {
-                    mParentPositionObserver.addListener(mParentPositionListener);
-                }
-            }
-        };
         mGestureStateListener = new GestureStateListener() {
             @Override
             public void onScrollStarted(int scrollOffsetX, int scrollOffsetY) {
                 setIsScrolling(true);
             }
             @Override
             public void onScrollEnded(int scrollOffsetX, int scrollOffsetY) {
                 setIsScrolling(false);
             }
             @Override
@@ skipping 11 matching lines @@
             @Override
             public void onWindowFocusChanged(boolean hasWindowFocus) {
                 setIsFocused(hasWindowFocus);
             }
             @Override
             public void onDestroyed() {
                 destroy();
             }
         };
         mContentViewCore.addGestureStateListener(mGestureStateListener);
-        mContentViewCore.addContainerViewObserver(mParentViewObserver);
+        mNativeDrawable = nativeInit(contentViewCore, (float) dipScale,
+                HandleViewResources.getHandleHorizontalPaddingRatio());
+    }
+
+    public static PopupTouchHandleDrawable create(
+            ObserverList<PopupTouchHandleDrawable> drawableObserverList,
+            ContentViewCore contentViewCore, double dipScale) {
+        return new PopupTouchHandleDrawable(drawableObserverList, contentViewCore, dipScale);
+    }
+
+    public long getNativeDrawable() {
+        return mNativeDrawable;
     }
 
     private static void setWindowLayoutType(PopupWindow window, int layoutType) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             window.setWindowLayoutType(layoutType);
             return;
         }
 
         try {
             Method setWindowLayoutTypeMethod =
@@ skipping 35 matching lines @@
         final float offsetX = event.getRawX() - event.getX() - mTempScreenCoords[0];
         final float offsetY = event.getRawY() - event.getY() - mTempScreenCoords[1];
         final MotionEvent offsetEvent = MotionEvent.obtainNoHistory(event);
         offsetEvent.offsetLocation(offsetX, offsetY);
         final boolean handled = mContentViewCore.onTouchHandleEvent(offsetEvent);
         offsetEvent.recycle();
         return handled;
     }
 
     @CalledByNative
-    private static PopupTouchHandleDrawable create(ContentViewCore contentViewCore) {
-        return new PopupTouchHandleDrawable(contentViewCore);
-    }
-
-    @CalledByNative
     private void setOrientation(int orientation, boolean mirrorVertical, boolean mirrorHorizontal) {
         assert (orientation >= TouchHandleOrientation.LEFT
                 && orientation <= TouchHandleOrientation.UNDEFINED);
 
         final boolean orientationChanged = mOrientation != orientation;
         final boolean mirroringChanged =
                 mMirrorHorizontal != mirrorHorizontal || mMirrorVertical != mirrorVertical;
         mOrientation = orientation;
         mMirrorHorizontal = mirrorHorizontal;
         mMirrorVertical = mirrorVertical;
@@ skipping 187 matching lines @@
 
     @Override
     protected void onDetachedFromWindow() {
         super.onDetachedFromWindow();
         mAttachedToWindow = false;
         onVisibilityInputChanged();
     }
 
     @CalledByNative
     private void destroy() {
+        mDrawableObserverList.removeObserver(this);
         if (mContentViewCore == null) return;
         hide();
         mContentViewCore.removeGestureStateListener(mGestureStateListener);
-        mContentViewCore.removeContainerViewObserver(mParentViewObserver);
         mContentViewCore = null;
     }
 
     @CalledByNative
     private void show() {
         if (mContentViewCore == null) return;
         if (mContainer.isShowing()) return;
 
         // While hidden, the parent position may have become stale. It must be updated before
         // checking isPositionVisible().
@@ skipping 38 matching lines @@
         mVisible = visible;
         onVisibilityInputChanged();
     }
 
     @CalledByNative
     private int getPositionX() {
         return mPositionX;
     }
 
     @CalledByNative
-    private float getHandleHorizontalPaddingRatio() {
-        return HandleViewResources.getHandleHorizontalPaddingRatio();
-    }
-
-    @CalledByNative
     private int getPositionY() {
         return mPositionY;
     }
 
     @CalledByNative
     private int getVisibleWidth() {
         if (mDrawable == null) return 0;
         return mDrawable.getIntrinsicWidth();
     }
 
     @CalledByNative
     private int getVisibleHeight() {
         if (mDrawable == null) return 0;
         return mDrawable.getIntrinsicHeight();
     }
+
+    public void onContainerViewChanged(ViewGroup newContainerView) {
+        // If the parent View ever changes, the parent position observer
+        // must be updated accordingly.
+        mParentPositionObserver.clearListener();
+        mParentPositionObserver = new ViewPositionObserver(newContainerView);
+        if (mContainer.isShowing()) {
+            mParentPositionObserver.addListener(mParentPositionListener);
+        }
+    }
+
+    private native long nativeInit(ContentViewCore contentViewCore, float dipScale,
+            float horizontalPaddingRatio);
 }