Initial patch set to implement improved touch support for screen magnification

ash/magnifier/magnification_controller.cc

 // Copyright (c) 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.
 
 #include "ash/magnifier/magnification_controller.h"
 
 #include <memory>
 #include <utility>
 
 #include "ash/common/accelerators/accelerator_controller.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/system/tray/system_tray_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/display/root_window_transformers.h"
 #include "ash/host/ash_window_tree_host.h"
 #include "ash/host/root_window_transformer.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/timer/timer.h"
+#include "chromeos/chromeos_switches.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_observer.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
+#include "ui/events/gesture_event_details.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 namespace {
 
 const float kMaxMagnifiedScale = 4.0f;
@@ skipping 137 matching lines @@
   // Returns the size of the root window.
   gfx::Size GetHostSizeDIP() const;
 
   // Correct the given scale value if necessary.
   void ValidateScale(float* scale);
 
   // ui::EventHandler overrides:
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
   void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Moves the view port when |point| is located within
   // |x_panning_margin| and |y_pannin_margin| to the edge of the visible
   // window region. The view port will be moved so that the |point| will be
   // moved to the point where it has |x_target_margin| and |y_target_margin|
   // to the edge of the visible region.
   void MoveMagnifierWindowFollowPoint(const gfx::Point& point,
                                       int x_panning_margin,
                                       int y_panning_margin,
                                       int x_target_margin,
@@ skipping 50 matching lines @@
   // Timer for moving magnifier window when it fires.
   base::OneShotTimer move_magnifier_timer_;
 
   // Most recent caret position in |root_window_| coordinates.
   gfx::Point caret_point_;
 
   // Flag for disabling moving magnifier delay. It can only be true in testing
   // mode.
   bool disable_move_magnifier_delay_;
 
+  // Flag whether user is currently changing zoom level by touch or not.
+  bool is_changing_zoom_level_by_touch_;
+
   DISALLOW_COPY_AND_ASSIGN(MagnificationControllerImpl);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl:
 
 MagnificationControllerImpl::MagnificationControllerImpl()
     : root_window_(Shell::GetPrimaryRootWindow()),
       is_on_animation_(false),
       is_enabled_(false),
       keep_focus_centered_(false),
       move_cursor_after_animation_(false),
       scale_(kNonMagnifiedScale),
       scroll_direction_(SCROLL_NONE),
-      disable_move_magnifier_delay_(false) {
+      disable_move_magnifier_delay_(false),
+      is_changing_zoom_level_by_touch_(false) {
   Shell::GetInstance()->AddPreTargetHandler(this);
   root_window_->AddObserver(this);
   point_of_interest_ = root_window_->bounds().CenterPoint();
 }
 
 MagnificationControllerImpl::~MagnificationControllerImpl() {
   ui::InputMethod* input_method = GetInputMethod(root_window_);
   if (input_method)
     input_method->RemoveObserver(this);
 
@@ skipping 394 matching lines @@
 void MagnificationControllerImpl::OnTouchEvent(ui::TouchEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   aura::Window* current_root = target->GetRootWindow();
   if (current_root == root_window_) {
     gfx::Rect root_bounds = current_root->bounds();
     if (root_bounds.Contains(event->root_location()))
       point_of_interest_ = event->root_location();
   }
 }
 
+void MagnificationControllerImpl::OnGestureEvent(ui::GestureEvent* event) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableTouchSupportInScreenMagnification)) {
+    return;
+  }
+
+  const ui::GestureEventDetails& details = event->details();
+  if (details.type() == ui::ET_GESTURE_SCROLL_UPDATE &&
+      details.touch_points() == 2 && !is_changing_zoom_level_by_touch_) {
+    gfx::Rect viewport_rect_in_dip = GetViewportRect();
+    viewport_rect_in_dip.Offset(details.scroll_x() * -1,
+                                details.scroll_y() * -1);
+    const gfx::Rect& viewport_rect_in_pixel =
+        ui::ConvertRectToPixel(root_window_->layer(), viewport_rect_in_dip);
+    MoveWindow(viewport_rect_in_pixel.origin(), false);
+    event->SetHandled();
+  } else if (details.type() == ui::ET_GESTURE_PINCH_BEGIN &&

[yoshiki, 2017/01/19 06:30:20]

As talked offline, could you check if this logic works when the number of
touched fingers are increased (or decreased) during pinch?

[yawano, 2017/01/19 06:45:55]

I've tested this and we get gesture end event and begin event when user increase
or decrease number of fingers. But it may be safer not to check number of touch
points for toggling the flag. I'll upload new patch set to fix this.

[yawano, 2017/01/19 07:54:25]

Done.

[yoshiki, 2017/01/20 05:26:33]

If "we get gesture end event and begin event when user increase
or decrease number of fingers" is correct, I think we can remove the
"is_performing_pinch_gesture_" flag entirely, because the pinch uses 3 fingers
and scroll uses 2 fingers, right?

And could you add comments about the gesture event behavior to prevent feature
us from having same question like current us.

[yawano, 2017/02/06 06:49:04]

Removed is_performing_pinch_gesture_ flag. We can distinguish them by number of
fingers.

The logic is very simple now. If user is performing scroll with 2 fingers, we
will scroll the screen. If user is performing pinch gesture with 3 fingers, we
will change zoom level.

Do we still need to add comment about the behavior of gesture events, especially
about begin and end events? We no longer handle gesture begin and end events
here.

+             details.touch_points() == 3) {
+    // Set this flag to prevent scrolling while user is zooming.
+    is_changing_zoom_level_by_touch_ = true;
+    event->SetHandled();
+  } else if (details.type() == ui::ET_GESTURE_PINCH_END &&
+             details.touch_points() == 3) {
+    is_changing_zoom_level_by_touch_ = false;
+    event->SetHandled();
+  } else if (details.type() == ui::ET_GESTURE_PINCH_UPDATE &&
+             details.touch_points() == 3) {
+    float scale = GetScale() * details.scale();
+
+    if (scale < kMinMagnifiedScaleThreshold) {
+      scale = kMinMagnifiedScaleThreshold;
+    } else if (scale > kMaxMagnifiedScaleThreshold) {
+      scale = kMaxMagnifiedScaleThreshold;
+    }
+
+    point_of_interest_ = event->root_location();
+    SetScale(scale, false);
+    event->SetHandled();
+  }
+}
+
 void MagnificationControllerImpl::MoveMagnifierWindowFollowPoint(
     const gfx::Point& point,
     int x_panning_margin,
     int y_panning_margin,
     int x_target_margin,
     int y_target_margin) {
   DCHECK(root_window_);
   bool start_zoom = false;
 
   const gfx::Rect window_rect = GetViewportRect();
@@ skipping 154 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash