ash: Refactor autoclick common code to ash/autoclick/common.

ash/autoclick/autoclick_controller.cc

Index: ash/autoclick/autoclick_controller.cc
diff --git a/ash/autoclick/autoclick_controller.cc b/ash/autoclick/autoclick_controller.cc
index b0f715d6805d4348437f396974b93b69c956a892..d38d07b3ebc3b2bec6ce641ce8b9bd15caaafb7b 100644
--- a/ash/autoclick/autoclick_controller.cc
+++ b/ash/autoclick/autoclick_controller.cc
@@ -5,37 +5,22 @@
 #include "ash/autoclick/autoclick_controller.h"
 
 #include "ash/aura/wm_window_aura.h"
+#include "ash/autoclick/common/autoclick_controller_common.h"
+#include "ash/common/shell_window_ids.h"
 #include "ash/common/wm/root_window_finder.h"
 #include "ash/shell.h"
 #include "base/timer/timer.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event.h"
-#include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_utils.h"
-#include "ui/gfx/geometry/point.h"
-#include "ui/gfx/geometry/vector2d.h"
+#include "ui/views/widget/widget.h"
 #include "ui/wm/core/coordinate_conversion.h"
 
 namespace ash {
 
-namespace {
-
-// The threshold of mouse movement measured in DIP that will
-// initiate a new autoclick.
-const int kMovementThreshold = 20;
-
-bool IsModifierKey(ui::KeyboardCode key_code) {
-  return key_code == ui::VKEY_SHIFT || key_code == ui::VKEY_LSHIFT ||
-         key_code == ui::VKEY_CONTROL || key_code == ui::VKEY_LCONTROL ||
-         key_code == ui::VKEY_RCONTROL || key_code == ui::VKEY_MENU ||
-         key_code == ui::VKEY_LMENU || key_code == ui::VKEY_RMENU;
-}
-
-}  // namespace
-
 // static.
 base::TimeDelta AutoclickController::GetDefaultAutoclickDelay() {
   return base::TimeDelta::FromMilliseconds(int64_t{kDefaultAutoclickDelayMs});
@@ -51,7 +36,6 @@ class AutoclickControllerImpl : public AutoclickController,
 
  private:
   // AutoclickController overrides:
-  void SetDelegate(std::unique_ptr<Delegate> delegate) override;
   void SetEnabled(bool enabled) override;
   bool IsEnabled() const override;
   void SetAutoclickDelay(base::TimeDelta delay) override;
@@ -64,23 +48,13 @@ class AutoclickControllerImpl : public AutoclickController,
   void OnGestureEvent(ui::GestureEvent* event) override;
   void OnScrollEvent(ui::ScrollEvent* event) override;
 
-  void StartRingDisplay();
-  void StopRingDisplay();
-  void ChangeRingDisplayCenter();
-
   void InitClickTimer();
 
   void DoAutoclick();
 
   bool enabled_;
   base::TimeDelta delay_;
-  int mouse_event_flags_;
-  std::unique_ptr<base::Timer> autoclick_timer_;
-  std::unique_ptr<Delegate> delegate_;
-  // The position in screen coordinates used to determine
-  // the distance the mouse has moved.
-  gfx::Point anchor_location_;
-  gfx::Point current_mouse_location_;
+  std::unique_ptr<AutoclickControllerCommon> autoclick_controller_common_;
 
   DISALLOW_COPY_AND_ASSIGN(AutoclickControllerImpl);
 };
@@ -88,18 +62,12 @@ class AutoclickControllerImpl : public AutoclickController,
 AutoclickControllerImpl::AutoclickControllerImpl()
     : enabled_(false),
       delay_(GetDefaultAutoclickDelay()),
-      mouse_event_flags_(ui::EF_NONE),
-      delegate_(nullptr),
-      anchor_location_(-kMovementThreshold, -kMovementThreshold) {
+      autoclick_controller_common_(new AutoclickControllerCommon()) {
   InitClickTimer();
 }
 
 AutoclickControllerImpl::~AutoclickControllerImpl() {}
 
-void AutoclickControllerImpl::SetDelegate(std::unique_ptr<Delegate> delegate) {
-  delegate_ = std::move(delegate);
-}
-
 void AutoclickControllerImpl::SetEnabled(bool enabled) {
   if (enabled_ == enabled)
     return;
@@ -107,7 +75,7 @@ void AutoclickControllerImpl::SetEnabled(bool enabled) {
 
   if (enabled_) {
     Shell::GetInstance()->AddPreTargetHandler(this);
-    autoclick_timer_->Stop();
+    autoclick_controller_common_->StopAutoclickTimer();
   } else {
     Shell::GetInstance()->RemovePreTargetHandler(this);
   }
@@ -126,88 +94,50 @@ base::TimeDelta AutoclickControllerImpl::GetAutoclickDelay() const {
   return delay_;
 }
 
-void AutoclickControllerImpl::StartRingDisplay() {
-  if (delegate_)
-    delegate_->StartGesture(delay_, anchor_location_);
-}
-
-void AutoclickControllerImpl::StopRingDisplay() {
-  if (delegate_)
-    delegate_->StopGesture();
-}
-
-void AutoclickControllerImpl::ChangeRingDisplayCenter() {
-  if (delegate_)
-    delegate_->SetGestureCenter(current_mouse_location_);
-}
-
 void AutoclickControllerImpl::InitClickTimer() {
-  autoclick_timer_.reset(new base::Timer(
+  autoclick_controller_common_->ResetAutoclickTimer(new base::Timer(
       FROM_HERE, delay_,
       base::Bind(&AutoclickControllerImpl::DoAutoclick, base::Unretained(this)),
       false));
 }
 
 void AutoclickControllerImpl::OnMouseEvent(ui::MouseEvent* event) {
-  if (event->type() == ui::ET_MOUSE_MOVED &&
-      !(event->flags() & ui::EF_IS_SYNTHESIZED)) {
-    mouse_event_flags_ = event->flags();
-
-    gfx::Point mouse_location = event->location();
-    ::wm::ConvertPointToScreen(static_cast<aura::Window*>(event->target()),
-                               &mouse_location);
-
-    // The distance between the mouse location and the anchor location
-    // must exceed a certain threshold to initiate a new autoclick countdown.
-    // This ensures that mouse jitter caused by poor motor control does not
-    // 1. initiate an unwanted autoclick from rest
-    // 2. prevent the autoclick from ever occuring when the mouse
-    //    arrives at the target.
-    gfx::Vector2d delta = mouse_location - anchor_location_;
-    if (delta.LengthSquared() >= kMovementThreshold * kMovementThreshold) {
-      anchor_location_ = mouse_location;
-      autoclick_timer_->Reset();
-      StartRingDisplay();
-    } else if (autoclick_timer_->IsRunning()) {
-      current_mouse_location_ = mouse_location;
-      ChangeRingDisplayCenter();
-    }
-  } else if (event->type() == ui::ET_MOUSE_PRESSED) {
-    autoclick_timer_->Stop();
-    StopRingDisplay();
-  } else if (event->type() == ui::ET_MOUSEWHEEL &&
-             autoclick_timer_->IsRunning()) {
-    autoclick_timer_->Reset();
-    StartRingDisplay();
-  }
+  gfx::Point mouse_location = event->location();
+  aura::Window* target =
+      WmWindowAura::GetAuraWindow(ash::wm::GetRootWindowAt(mouse_location));
+  aura::Window* root_window = target->GetRootWindow();
+
+  views::Widget* widget = new views::Widget;
+  views::Widget::InitParams params;
+  params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
+  params.accept_events = false;
+  params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.context = root_window;
+  params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+  params.parent =
+      Shell::GetContainer(root_window, kShellWindowId_OverlayContainer);
+  widget->Init(params);
+  widget->SetOpacity(1.f);

[sadrul, 2016/07/29 20:13:35]

Why do we need to create a new Widget for each mouse event?

[riajiang, 2016/08/04 16:51:20]

They were doing this every time StartAnimation is called (which is when a new
mouse event happens and then a new AutoclickRingView is created). I think the
only difference for these widgets is that they have different context and parent
(based on different root_window). But I was not very sure whether all mouse
click locations have the same root window so I kept it like this. 

Update: Changed it to create a new widget only for the first time and reparent
if root_window is different.

+
+  autoclick_controller_common_->HandleMouseEvent(*event, target, widget,
+                                                 delay_);
 }
 
 void AutoclickControllerImpl::OnKeyEvent(ui::KeyEvent* event) {
-  int modifier_mask = ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN |
-                      ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN |
-                      ui::EF_IS_EXTENDED_KEY;
-  int new_modifiers = event->flags() & modifier_mask;
-  mouse_event_flags_ = (mouse_event_flags_ & ~modifier_mask) | new_modifiers;
-
-  if (!IsModifierKey(event->key_code())) {
-    autoclick_timer_->Stop();
-    StopRingDisplay();
-  }
+  autoclick_controller_common_->HandleKeyEvent(*event);
 }
 
 void AutoclickControllerImpl::OnTouchEvent(ui::TouchEvent* event) {
-  autoclick_timer_->Stop();
-  StopRingDisplay();
+  autoclick_controller_common_->HandleTouchEvent(*event);
 }
 
 void AutoclickControllerImpl::OnGestureEvent(ui::GestureEvent* event) {
-  autoclick_timer_->Stop();
-  StopRingDisplay();
+  autoclick_controller_common_->HandleGestureEvent(*event);
 }
 
 void AutoclickControllerImpl::OnScrollEvent(ui::ScrollEvent* event) {
-  autoclick_timer_->Stop();
-  StopRingDisplay();
+  autoclick_controller_common_->HandleScrollEvent(*event);
 }
 
 void AutoclickControllerImpl::DoAutoclick() {
@@ -217,19 +147,20 @@ void AutoclickControllerImpl::DoAutoclick() {
   DCHECK(root_window) << "Root window not found while attempting autoclick.";
 
   gfx::Point click_location(screen_location);
-  anchor_location_ = click_location;
+  autoclick_controller_common_->UpdateAnchorLocation(click_location);
 
   ::wm::ConvertPointFromScreen(root_window, &click_location);
   aura::WindowTreeHost* host = root_window->GetHost();
   host->ConvertPointToHost(&click_location);
 
+  int mouse_event_flags = autoclick_controller_common_->GetMouseEventFlags();
   ui::MouseEvent press_event(ui::ET_MOUSE_PRESSED, click_location,
                              click_location, ui::EventTimeForNow(),
-                             mouse_event_flags_ | ui::EF_LEFT_MOUSE_BUTTON,
+                             mouse_event_flags | ui::EF_LEFT_MOUSE_BUTTON,
                              ui::EF_LEFT_MOUSE_BUTTON);
   ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, click_location,
                                click_location, ui::EventTimeForNow(),
-                               mouse_event_flags_ | ui::EF_LEFT_MOUSE_BUTTON,
+                               mouse_event_flags | ui::EF_LEFT_MOUSE_BUTTON,
                                ui::EF_LEFT_MOUSE_BUTTON);
 
   ui::EventDispatchDetails details =