mash: Move AutoHideEventHandler to WmShelfAura.

ash/shelf/shelf_layout_manager.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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 21 matching lines @@
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "base/i18n/rtl.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.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/keyboard/keyboard_util.h"
 #include "ui/views/border.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace {
 
 // Delay before showing the shelf. This is after the mouse stops moving.
 const int kAutoHideDelayMS = 200;
 
@@ skipping 13 matching lines @@
 // auto hidden shelf. The region is used to make it easier to trigger showing
 // the auto hidden shelf when the shelf is on the boundary between displays.
 const int kMaxAutoHideShowShelfRegionSize = 10;
 
 ui::Layer* GetLayer(views::Widget* widget) {
   return widget->GetNativeView()->layer();
 }
 
 }  // namespace
 
-// ShelfLayoutManager::AutoHideEventFilter -------------------------------------
-
-// Notifies ShelfLayoutManager any time the mouse moves. Not used on mash.
-// TODO(jamescook): Delete this once the mash implementation handles drags on
-// and off the shelf.
-class ShelfLayoutManager::AutoHideEventFilter : public ui::EventHandler {
- public:
-  explicit AutoHideEventFilter(ShelfLayoutManager* shelf);
-  ~AutoHideEventFilter() override;
-
-  // Returns true if the last mouse event was a mouse drag.
-  bool in_mouse_drag() const { return in_mouse_drag_; }
-
-  // Overridden from ui::EventHandler:
-  void OnMouseEvent(ui::MouseEvent* event) override;
-  void OnGestureEvent(ui::GestureEvent* event) override;
-
- private:
-  ShelfLayoutManager* shelf_;
-  bool in_mouse_drag_;
-  DISALLOW_COPY_AND_ASSIGN(AutoHideEventFilter);
-};
-
-ShelfLayoutManager::AutoHideEventFilter::AutoHideEventFilter(
-    ShelfLayoutManager* shelf)
-    : shelf_(shelf), in_mouse_drag_(false) {
-  Shell::GetInstance()->AddPreTargetHandler(this);
-}
-
-ShelfLayoutManager::AutoHideEventFilter::~AutoHideEventFilter() {
-  Shell::GetInstance()->RemovePreTargetHandler(this);
-}
-
-void ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
-    ui::MouseEvent* event) {
-  // This also checks IsShelfWindow() to make sure we don't attempt to hide the
-  // shelf if the mouse down occurs on the shelf.
-  in_mouse_drag_ =
-      (event->type() == ui::ET_MOUSE_DRAGGED ||
-       (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
-        event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
-      !shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()));
-  shelf_->UpdateAutoHideForMouseEvent(event);
-}
-
-void ShelfLayoutManager::AutoHideEventFilter::OnGestureEvent(
-    ui::GestureEvent* event) {
-  shelf_->UpdateAutoHideForGestureEvent(event);
-}
-
 // ShelfLayoutManager::UpdateShelfObserver -------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
@@ skipping 86 matching lines @@
   WmShell::Get()->RemoveShellObserver(this);
   WmShell::Get()->RemoveLockStateObserver(this);
   WmShell::Get()->GetSessionStateDelegate()->RemoveSessionStateObserver(this);
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   in_shutdown_ = true;
   // Clear all event filters, otherwise sometimes those filters may catch
   // synthesized mouse event and cause crashes during the shutdown.
   set_workspace_controller(NULL);
-  auto_hide_event_filter_.reset();
   bezel_event_filter_.reset();
   // Stop observing changes to avoid updating a partially destructed shelf.
   WmShell::Get()->RemoveActivationObserver(this);
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   // status_area_widget() may be NULL during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
@@ skipping 96 matching lines @@
       }
       auto_hide_timer_.Start(
           FROM_HERE, base::TimeDelta::FromMilliseconds(kAutoHideDelayMS), this,
           &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
 }
 
-void ShelfLayoutManager::UpdateAutoHideForMouseEvent(ui::MouseEvent* event) {
+void ShelfLayoutManager::UpdateAutoHideForMouseEvent(ui::MouseEvent* event,
+                                                     WmWindow* target) {
+  // This also checks IsShelfWindow() to make sure we don't attempt to hide the
+  // shelf if the mouse down occurs on the shelf.
+  in_mouse_drag_ = (event->type() == ui::ET_MOUSE_DRAGGED ||
+                    (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
+                     event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
+                   !IsShelfWindow(target);
+
   // Don't update during shutdown because synthetic mouse events (e.g. mouse
   // exit) may be generated during status area widget teardown.
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
     return;
 
   if (event->type() == ui::ET_MOUSE_MOVED ||
       event->type() == ui::ET_MOUSE_ENTERED ||
       event->type() == ui::ET_MOUSE_EXITED) {
     UpdateAutoHideState();
   }
 }
 
-void ShelfLayoutManager::UpdateAutoHideForGestureEvent(
-    ui::GestureEvent* event) {
+void ShelfLayoutManager::UpdateAutoHideForGestureEvent(ui::GestureEvent* event,
+                                                       WmWindow* target) {
   if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
     return;
 
-  aura::Window* target_window = static_cast<aura::Window*>(event->target());
-  if (IsShelfWindow(target_window) && ProcessGestureEvent(*event))
+  if (IsShelfWindow(target) && ProcessGestureEvent(*event))
     event->StopPropagation();
 }
 
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
   UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
 }
 
 void ShelfLayoutManager::AddObserver(ShelfLayoutManagerObserver* observer) {
   observers_.AddObserver(observer);
@@ skipping 158 matching lines @@
   bool force_update =
       (gesture_drag_status_ == GESTURE_DRAG_CANCEL_IN_PROGRESS ||
        gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS);
 
   if (!force_update && state_.Equals(state))
     return;  // Nothing changed.
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state));
 
-  // mash does not support global event handlers. It uses events on the shelf
-  // and status area widgets to update auto-hide.
-  if (!Shell::GetInstance()->in_mus()) {
-    if (state.visibility_state == SHELF_AUTO_HIDE) {
-      // When state is SHELF_AUTO_HIDE we need to track when the mouse is over
-      // the shelf to unhide it. AutoHideEventFilter does that for us.
-      if (!auto_hide_event_filter_)
-        auto_hide_event_filter_.reset(new AutoHideEventFilter(this));
-    } else {
-      auto_hide_event_filter_.reset(NULL);
-    }
-  }
-
   StopAutoHideTimer();
 
   State old_state = state_;
   state_ = state;
 
   BackgroundAnimatorChangeType change_type = BACKGROUND_CHANGE_ANIMATE;
   bool delay_background_change = false;
 
   // Do not animate the background when:
   // - Going from a hidden / auto hidden shelf in fullscreen to a visible shelf
@@ skipping 412 matching lines @@
     }
     // If there are no visible windows do not hide the shelf.
     if (!visible_window)
       return SHELF_AUTO_HIDE_SHOWN;
   }
 
   if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS)
     return gesture_drag_auto_hide_state_;
 
   // Don't show if the user is dragging the mouse.
-  if (auto_hide_event_filter_.get() && auto_hide_event_filter_->in_mouse_drag())
+  if (in_mouse_drag_)

[James Cook, 2016/08/09 19:47:58]

Just to double-check: This function is already checking at the top to ensure the
visibility_state is SHELF_AUTO_HIDE, which is equivalent to the old code's check
for the existence of the event filter?

[msw, 2016/08/09 19:52:58]

Yup, I went to add a |visibility_state == SHELF_AUTO_HIDE| check here, but saw
the check at the top of the function and then decided to skip a redundant check.
I'm willing to add one if you prefer.

[James Cook, 2016/08/09 19:54:28]

Nope, this is fine.

     return SHELF_AUTO_HIDE_HIDDEN;
 
   // Ignore the mouse position if mouse events are disabled.
   if (!shelf_widget_->IsMouseEventsEnabled())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = shelf_widget_->GetWindowBoundsInScreen();
   if (shelf_widget_->status_area_widget() &&
       shelf_widget_->status_area_widget()->IsMessageBubbleShown() &&
       IsVisible()) {
@@ skipping 27 matching lines @@
   if ((state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN ||
        mouse_over_shelf_when_auto_hide_timer_started_) &&
       GetAutoHideShowShelfRegionInScreen().Contains(
           cursor_position_in_screen)) {
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
-bool ShelfLayoutManager::IsShelfWindow(aura::Window* window) {
+bool ShelfLayoutManager::IsShelfWindow(WmWindow* window) {
   if (!window)
     return false;
-  return (shelf_widget_ &&
-          shelf_widget_->GetNativeWindow()->Contains(window)) ||
-         (shelf_widget_->status_area_widget() &&
-          shelf_widget_->status_area_widget()->GetNativeWindow()->Contains(
-              window));
+  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmWindow* status_window =
+      WmLookup::Get()->GetWindowForWidget(shelf_widget_->status_area_widget());

[James Cook, 2016/08/09 19:47:58]

It seems like this function should either check for a null shelf_widget_ here,
or if it cannot be null, not check |shelf_window| below.

[msw, 2016/08/09 19:52:58]

Ah yeah, good call.

+  return (shelf_window && shelf_window->Contains(window)) ||
+         (status_window && status_window->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaInsets(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   return 0;
 }
 
@@ skipping 154 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash