Support for Adaptive Handle Orientation

content/browser/android/composited_touch_handle_drawable.cc

 // 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.
 
 #include "content/browser/android/composited_touch_handle_drawable.h"
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/ui_resource_layer.h"
 #include "jni/HandleViewResources_jni.h"
 #include "ui/gfx/android/java_bitmap.h"
+#include "ui/gfx/skbitmap_operations.h"
 
 namespace content {
 
 namespace {
 
 static SkBitmap CreateSkBitmapFromJavaBitmap(
     base::android::ScopedJavaLocalRef<jobject> jbitmap) {
   return jbitmap.is_null()
              ? SkBitmap()
              : CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(jbitmap.obj()));
@@ skipping 14 matching lines @@
     JNIEnv* env = base::android::AttachCurrentThread();
     if (!context)
       context = base::android::GetApplicationContext();
 
     left_bitmap_ = CreateSkBitmapFromJavaBitmap(
         Java_HandleViewResources_getLeftHandleBitmap(env, context));
     right_bitmap_ = CreateSkBitmapFromJavaBitmap(
         Java_HandleViewResources_getRightHandleBitmap(env, context));
     center_bitmap_ = CreateSkBitmapFromJavaBitmap(
         Java_HandleViewResources_getCenterHandleBitmap(env, context));
+    left_inverted_bitmap_ = SkBitmapOperations::Rotate(

[jdduke (slow), 2015/04/14 00:00:32]

There's no need to create new assets for a transformed layer. We should just
update the layer transforms directly.

[AviD, 2015/04/23 14:45:16]

Done.

+        right_bitmap_, SkBitmapOperations::ROTATION_180_CW);
+    right_inverted_bitmap_ = SkBitmapOperations::Rotate(
+        left_bitmap_, SkBitmapOperations::ROTATION_180_CW);
+    center_inverted_bitmap_ = SkBitmapOperations::Rotate(
+        center_bitmap_, SkBitmapOperations::ROTATION_180_CW);
 
     left_bitmap_.setImmutable();
     right_bitmap_.setImmutable();
     center_bitmap_.setImmutable();
+    left_inverted_bitmap_.setImmutable();
+    right_inverted_bitmap_.setImmutable();
+    center_inverted_bitmap_.setImmutable();
   }
 
-  const SkBitmap& GetBitmap(ui::TouchHandleOrientation orientation) {
+  const SkBitmap& GetBitmap(ui::TouchHandleOrientation orientation,
+                            bool mirror_vertical,
+                            bool mirror_horizontal) {
     DCHECK(loaded_);
     switch (orientation) {
       case ui::TouchHandleOrientation::LEFT:
-        return left_bitmap_;
+        if (mirror_vertical && mirror_horizontal) {
+          // Inverted about both X and Y axes
+          return right_inverted_bitmap_;
+        } else if (mirror_vertical) {
+          // Inverted about X axis only
+          return left_inverted_bitmap_;
+        } else if (mirror_horizontal) {
+          // Inverted about Y axis only
+          return right_bitmap_;
+        } else {
+          // Normal Case
+          return left_bitmap_;
+        }
       case ui::TouchHandleOrientation::RIGHT:
-        return right_bitmap_;
+        if (mirror_vertical && mirror_horizontal) {
+          // Inverted about both X and Y axes
+          return left_inverted_bitmap_;
+        } else if (mirror_vertical) {
+          // Inverted about X axis only
+          return right_inverted_bitmap_;
+        } else if (mirror_horizontal) {
+          // Inverted about Y axis only
+          return left_bitmap_;
+        } else {
+          // Normal Case
+          return right_bitmap_;
+        }
       case ui::TouchHandleOrientation::CENTER:
-        return center_bitmap_;
+        if (mirror_vertical) {
+          // Inverted about X axis
+          return center_inverted_bitmap_;
+        } else {
+          // Normal Case
+          return center_bitmap_;
+        }
       case ui::TouchHandleOrientation::UNDEFINED:
         NOTREACHED() << "Invalid touch handle orientation.";
     };
     return center_bitmap_;
   }
 
  private:
   SkBitmap left_bitmap_;
   SkBitmap right_bitmap_;
   SkBitmap center_bitmap_;
+  SkBitmap left_inverted_bitmap_;
+  SkBitmap right_inverted_bitmap_;
+  SkBitmap center_inverted_bitmap_;
   bool loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(HandleResources);
 };
 
 base::LazyInstance<HandleResources>::Leaky g_selection_resources;
 
 }  // namespace
 
 CompositedTouchHandleDrawable::CompositedTouchHandleDrawable(
@@ skipping 13 matching lines @@
 }
 
 void CompositedTouchHandleDrawable::SetEnabled(bool enabled) {
   layer_->SetIsDrawable(enabled);
   // Force a position update in case the disabled layer's properties are stale.
   if (enabled)
     UpdateLayerPosition();
 }
 
 void CompositedTouchHandleDrawable::SetOrientation(
-    ui::TouchHandleOrientation orientation) {
+    ui::TouchHandleOrientation orientation,
+    bool mirror_vertical,
+    bool mirror_horizontal) {
   DCHECK(layer_->parent());
   orientation_ = orientation;
 
-  const SkBitmap& bitmap = g_selection_resources.Get().GetBitmap(orientation);
+  const SkBitmap& bitmap = g_selection_resources.Get().GetBitmap(
+      orientation, mirror_vertical, mirror_horizontal);
+  const int bitmap_height = bitmap.height();

[jdduke (slow), 2015/04/14 00:00:32]

To set the layer transform, you can use an approach simililar to that found
here: 

https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/an...

You simply set the transform origin, then scale the transform based on
mirror_vertical and mirror_horizontal.

[AviD, 2015/04/23 14:45:16]

Done.

+  const int bitmap_width = bitmap.width();
+  int focal_offset_x = 0;
+  int focal_offset_y = mirror_vertical ? bitmap_height : 0;
+
   layer_->SetBitmap(bitmap);
-  layer_->SetBounds(gfx::Size(bitmap.width(), bitmap.height()));
+  layer_->SetBounds(gfx::Size(bitmap_width, bitmap_height));
 
   switch (orientation_) {
     case ui::TouchHandleOrientation::LEFT:
-      focal_offset_from_origin_ = gfx::Vector2dF(bitmap.width() * 0.75f, 0);
+      focal_offset_x =
+          mirror_horizontal ? bitmap_width * 0.25f : bitmap_width * 0.75f;
+      focal_offset_from_origin_ =
+          gfx::Vector2dF(focal_offset_x, focal_offset_y);
       break;
     case ui::TouchHandleOrientation::RIGHT:
-      focal_offset_from_origin_ = gfx::Vector2dF(bitmap.width() * 0.25f, 0);
+      focal_offset_x =
+          mirror_horizontal ? bitmap_width * 0.75f : bitmap_width * 0.25f;
+      focal_offset_from_origin_ =
+          gfx::Vector2dF(focal_offset_x, focal_offset_y);
       break;
     case ui::TouchHandleOrientation::CENTER:
-      focal_offset_from_origin_ = gfx::Vector2dF(bitmap.width() * 0.5f, 0);
+      focal_offset_x = bitmap_width * 0.5f;
+      focal_offset_from_origin_ =
+          gfx::Vector2dF(focal_offset_x, focal_offset_y);
       break;
     case ui::TouchHandleOrientation::UNDEFINED:
       NOTREACHED() << "Invalid touch handle orientation.";
       break;
   };
 
   UpdateLayerPosition();
 }
 
 void CompositedTouchHandleDrawable::SetAlpha(float alpha) {
@@ skipping 25 matching lines @@
 void CompositedTouchHandleDrawable::UpdateLayerPosition() {
   layer_->SetPosition(focal_position_ - focal_offset_from_origin_);
 }
 
 // static
 bool CompositedTouchHandleDrawable::RegisterHandleViewResources(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content