Support for Adaptive Handle Orientation

content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java

Index: content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java
diff --git a/content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java b/content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java
index 56a74a86d02612a88f3eab310031a593996f1b4d..96307c239172755cdf48ddcc3289728fb26237fc 100644
--- a/content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java
+++ b/content/public/android/java/src/org/chromium/content/browser/input/PopupTouchHandleDrawable.java
@@ -8,6 +8,7 @@ import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Canvas;
 import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.animation.AnimationUtils;
@@ -143,10 +144,9 @@ public class PopupTouchHandleDrawable extends View {
     }
 
     @CalledByNative
-    private void setOrientation(int orientation) {
+    private void setOrientation(int orientation, boolean mirrorVertical, boolean mirrorHorizontal) {
         assert (orientation >= TouchHandleOrientation.LEFT
                 && orientation <= TouchHandleOrientation.UNDEFINED);
-        if (mOrientation == orientation) return;
 
         final boolean hadValidOrientation = mOrientation != TouchHandleOrientation.UNDEFINED;
         mOrientation = orientation;
@@ -154,21 +154,22 @@ public class PopupTouchHandleDrawable extends View {
         final int oldAdjustedPositionX = getAdjustedPositionX();
         final int oldAdjustedPositionY = getAdjustedPositionY();
 
+        mDrawable = getHandleDrawable(mirrorVertical, mirrorHorizontal);
+
         switch (orientation) {
             case TouchHandleOrientation.LEFT: {
-                mDrawable = HandleViewResources.getLeftHandleDrawable(mContext);
-                mHotspotX = (mDrawable.getIntrinsicWidth() * 3) / 4f;
+                int drawableWidth = mDrawable.getIntrinsicWidth();
+                mHotspotX = mirrorHorizontal ? drawableWidth / 4f : (drawableWidth * 3) / 4f;
                 break;
             }
 
             case TouchHandleOrientation.RIGHT: {
-                mDrawable = HandleViewResources.getRightHandleDrawable(mContext);
-                mHotspotX = mDrawable.getIntrinsicWidth() / 4f;
+                int drawableWidth = mDrawable.getIntrinsicWidth();
+                mHotspotX = mirrorHorizontal ? (drawableWidth * 3) / 4f : drawableWidth / 4f;
                 break;
             }
 
             case TouchHandleOrientation.CENTER: {
-                mDrawable = HandleViewResources.getCenterHandleDrawable(mContext);
                 mHotspotX = mDrawable.getIntrinsicWidth() / 2f;
                 break;
             }
@@ -177,7 +178,8 @@ public class PopupTouchHandleDrawable extends View {
             default:
                 break;
         }
-        mHotspotY = 0;
+
+        mHotspotY = mirrorVertical ? mDrawable.getIntrinsicHeight() : 0;
 
         // Force handle repositioning to accommodate the new orientation's hotspot.
         if (hadValidOrientation) setFocus(oldAdjustedPositionX, oldAdjustedPositionY);
@@ -185,6 +187,49 @@ public class PopupTouchHandleDrawable extends View {
         scheduleInvalidate();
     }
 
+    private Drawable getHandleDrawable(
+            final boolean mirrorVertical, final boolean mirrorHorizontal) {
+        final Drawable drawable;
+
+        switch (mOrientation) {
+            case TouchHandleOrientation.LEFT: {
+                drawable = HandleViewResources.getLeftHandleDrawable(mContext);
+                break;
+            }
+
+            case TouchHandleOrientation.RIGHT: {
+                drawable = HandleViewResources.getRightHandleDrawable(mContext);
+                break;
+            }
+
+            case TouchHandleOrientation.CENTER: {
+                drawable = HandleViewResources.getCenterHandleDrawable(mContext);
+                break;
+            }
+
+            case TouchHandleOrientation.UNDEFINED:
+            default:
+                drawable = HandleViewResources.getCenterHandleDrawable(mContext);
+                break;
+        }

[jdduke (slow), 2015/05/11 15:40:15]

I'd be OK early returning if mirrorHorizontal and mirrorVertical are both false.

[mfomitchev, 2015/05/13 22:33:00]

I think we should, since we can return the drawable as is instead of creating a
new one in this case.

[AviD, 2015/05/19 16:26:27]

Done.

+
+        // Invert about X or/and Y axis based on the mirror values
+        final Drawable[] drawableArray = {drawable};
+        final float scale_x = mirrorHorizontal ? -1.f : 1.f;
+        final float scale_y = mirrorVertical ? -1.f : 1.f;
+
+        return new LayerDrawable(drawableArray) {

[jdduke (slow), 2015/05/11 15:40:15]

It's a shame to create a new Drawable each time, not sure if there's any way
around this?

[mfomitchev, 2015/05/13 22:33:01]

Can we cache the current one? Since ActivateSelection is called conditionally
now I guess it doesn't matter much in practice, but would be nice to have this
layer of protection so that we don't end up creating garbage every frame in the
future.

[jdduke (slow), 2015/05/14 15:20:10]

It won't be per-frame, it would only be when the mirroring/orientation change.
Still too frequent for my liking. 

Instead, we can always reference mMirrorHorizontal/mMirrorVertical, so then we
only create a new drawable if the orientation changes, which should be
(relatively) infrequent. 

[mfomitchev, 2015/05/14 15:52:39]

It's called every time PopupTouchHandleDrawable::SetLayout is called, which is
called every time TouchHandle::UpdateLayout() is called, which is called every
time TouchHandle::SetFocus is called and top or bottom changes, which I
understand can happen every frame if the user is scrolling while the handles are
shown. Am I missing something?

[jdduke (slow), 2015/05/14 15:55:57]

Should have been more clear, I meant in the event that we actually do the right
thing and cache the values.

[mfomitchev, 2015/05/14 15:59:40]

Acknowledged.

[AviD, 2015/05/19 16:26:27]

Would it be possible to fetch the mirrored handles directly from Android
framework, similar to left, right and center handles?
(android.R.attr.textSelectHandleRightInverted/android.R.attr.textSelectHandleLeftInverted)

For now, I have cached the values and will create a new LayerDrawable only if
orientation changes. Also added TODO for a better approach(if any).

[jdduke (slow), 2015/05/19 18:59:25]

Ideally, but do they expose such values? Worst case we restrict the
inversion/flipping functionality to L+, where the handles don't have shadows and
are "flat" by design (so inverted/flipped doesn't actually change the style).
Thanks.

+            @Override
+            public void draw(final Canvas canvas) {
+                canvas.save();
+                canvas.scale(scale_x, scale_y, drawable.getBounds().width() / 2,
+                        drawable.getBounds().height() / 2);
+                super.draw(canvas);
+                canvas.restore();
+            }
+        };
+    }
+
     private void updateParentPosition(int parentPositionX, int parentPositionY) {
         if (mParentPositionX == parentPositionX && mParentPositionY == parentPositionY) return;
         mParentPositionX = parentPositionX;