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 performing pinch gesture or not.
+  bool is_performing_pinch_gesture_;
+
   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_performing_pinch_gesture_(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::kEnableTouchSupportForScreenMagnification)) {
+    return;
+  }
+
+  const ui::GestureEventDetails& details = event->details();
+  if (details.type() == ui::ET_GESTURE_SCROLL_UPDATE &&
+      details.touch_points() == 2 && !is_performing_pinch_gesture_) {
+    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) {
+    // Set this flag to prevent scrolling while user is changing zoom level.
+    is_performing_pinch_gesture_ = true;
+    event->SetHandled();
+  } else if (details.type() == ui::ET_GESTURE_PINCH_END) {
+    is_performing_pinch_gesture_ = 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();

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

Should we move the mouse cursor to the point of interest here (or in
GESTURE_PINCH_END handler)? Otherwise the magnification window may jump suddenly
from here to the mouse cursor position just after user moves mouse, I think.

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

I don't think we need to do it. IIUC, the mouse cursor is managed in the actual
(physical) screen coordinate, i.e. the cursor will stick to the current physical
location on the screen even if we change zoom level or scroll.

[yoshiki, 2017/02/06 17:22:07]

Thank you for explanation. Then, ok.

+    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