Refactor ImmersiveGestureHandler to work in Mash.

Currently, ImmersiveGestureHandlerClassic installs itself as a pretarget
handler on Shell. This is necessary to get events from bezel sensors,
which have bounds outside the immersive fs window. It also forwards
gesture events to ImmersiveFullscreenController.

Keep the part of ImmersiveGestureHandlerClassic that handles drag-
triggering gesture events in tablet mode (i.e. most of the class) and
run that within Ash in both Classic and Mash configurations.

Make ImmersiveFullscreenController a pretarget handler for the toplevel
window when it's in immersive mode. This works in either Ash or client
as ImmersiveFullscreenController doesn't need to get events outside of
the window's bounds. ImmersiveFullscreenController is now both an
EventHandler (for gesture events) and an EventObserver (for mouse and
touch events).

Bug: 624157,640374
Change-Id: I83536cb407b4ac890db63d4c6a0fe98b7912a3f4
Reviewed-on: https://chromium-review.googlesource.com/c/1300678
Commit-Queue: Evan Stade <estade@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Michael Wasserman <msw@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605733}

ash/BUILD.gn

@@ -1070,10 +1070,8 @@ component("ash") {
     "wm/gestures/overview_gesture_handler.h",
     "wm/immersive_context_ash.cc",
     "wm/immersive_context_ash.h",
-    "wm/immersive_gesture_handler_classic.cc",
-    "wm/immersive_gesture_handler_classic.h",
-    "wm/immersive_handler_factory_ash.cc",
-    "wm/immersive_handler_factory_ash.h",
+    "wm/immersive_gesture_drag_handler.cc",
+    "wm/immersive_gesture_drag_handler.h",
     "wm/lock_action_handler_layout_manager.cc",
     "wm/lock_action_handler_layout_manager.h",
     "wm/lock_layout_manager.cc",

ash/public/cpp/BUILD.gn

@@ -79,9 +79,6 @@ component("cpp") {
     "immersive/immersive_fullscreen_controller.cc",
     "immersive/immersive_fullscreen_controller.h",
     "immersive/immersive_fullscreen_controller_delegate.h",
-    "immersive/immersive_gesture_handler.h",
-    "immersive/immersive_handler_factory.cc",
-    "immersive/immersive_handler_factory.h",
     "immersive/immersive_revealed_lock.cc",
     "immersive/immersive_revealed_lock.h",
     "login_constants.h",

ash/public/cpp/immersive/immersive_context.h

@@ -39,9 +39,6 @@ class ASH_PUBLIC_EXPORT ImmersiveContext {
 
   // Returns true if any window has capture.
   virtual bool DoesAnyWindowHaveCapture() = 0;
-
-  // See Shell::IsMouseEventsEnabled() for details.
-  virtual bool IsMouseEventsEnabled() = 0;
 };
 
 }  // namespace ash

ash/public/cpp/immersive/immersive_fullscreen_controller.cc

@@ -9,13 +9,13 @@
 #include "ash/public/cpp/immersive/immersive_context.h"
 #include "ash/public/cpp/immersive/immersive_focus_watcher.h"
 #include "ash/public/cpp/immersive/immersive_fullscreen_controller_delegate.h"
-#include "ash/public/cpp/immersive/immersive_gesture_handler.h"
-#include "ash/public/cpp/immersive/immersive_handler_factory.h"
 #include "ash/public/cpp/window_properties.h"
 #include "base/metrics/histogram_macros.h"
+#include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_targeter.h"
+#include "ui/base/ui_base_features.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
@@ -126,45 +126,28 @@ ImmersiveRevealedLock* ImmersiveFullscreenController::GetRevealedLock(
                                    animate_reveal);
 }
 
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// ui::EventObserver overrides:
 
-void ImmersiveFullscreenController::OnMouseEvent(
-    const ui::MouseEvent& event,
-    const gfx::Point& location_in_screen,
-    views::Widget* target) {
-  if (!enabled_)
-    return;
-
-  if (event.type() != ui::ET_MOUSE_MOVED &&
-      event.type() != ui::ET_MOUSE_PRESSED &&
-      event.type() != ui::ET_MOUSE_RELEASED &&
-      event.type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
+void ImmersiveFullscreenController::OnEvent(const ui::Event& event) {
+  if (!event.IsLocatedEvent())
     return;
-  }
 
-  // Mouse hover can initiate revealing the top-of-window views while |widget_|
-  // is inactive.
-  if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
-    top_edge_hover_timer_.Stop();
-    UpdateLocatedEventRevealedLock(&event, location_in_screen);
-  } else if (event.type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
-    // Trigger reveal if the cursor pauses at the top of the screen for a while.
-    UpdateTopEdgeHoverTimer(event, location_in_screen, target);
+  const ui::LocatedEvent* located_event = event.AsLocatedEvent();
+  aura::Window* target = static_cast<aura::Window*>(event.target());
+  if (event.IsMouseEvent()) {
+    HandleMouseEvent(*event.AsMouseEvent(), located_event->root_location(),
+                     views::Widget::GetTopLevelWidgetForNativeView(target));
+  } else if (event.IsTouchEvent()) {
+    HandleTouchEvent(*event.AsTouchEvent(), located_event->root_location());
   }
 }
 
-void ImmersiveFullscreenController::OnTouchEvent(
-    const ui::TouchEvent& event,
-    const gfx::Point& location_in_screen) {
-  if (!enabled_ || event.type() != ui::ET_TOUCH_PRESSED)
-    return;
-
-  // Touch should not initiate revealing the top-of-window views while |widget_|
-  // is inactive.
-  if (!widget_->IsActive())
-    return;
+////////////////////////////////////////////////////////////////////////////////
+// ui::EventHandler overrides:
 
-  UpdateLocatedEventRevealedLock(&event, location_in_screen);
+void ImmersiveFullscreenController::OnEvent(ui::Event* event) {
+  ui::EventHandler::OnEvent(event);
 }
 
 void ImmersiveFullscreenController::OnGestureEvent(ui::GestureEvent* event) {
@@ -202,20 +185,6 @@ void ImmersiveFullscreenController::OnGestureEvent(ui::GestureEvent* event) {
   }
 }
 
-void ImmersiveFullscreenController::OnEvent(const ui::Event& event) {
-  if (!event.IsLocatedEvent())
-    return;
-
-  const ui::LocatedEvent* located_event = event.AsLocatedEvent();
-  aura::Window* target = static_cast<aura::Window*>(event.target());
-  if (event.IsMouseEvent()) {
-    OnMouseEvent(*event.AsMouseEvent(), located_event->root_location(),
-                 views::Widget::GetTopLevelWidgetForNativeView(target));
-  } else if (event.IsTouchEvent()) {
-    OnTouchEvent(*event.AsTouchEvent(), located_event->root_location());
-  }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
@@ -326,24 +295,66 @@ void ImmersiveFullscreenController::EnableEventObservers(bool enable) {
     return;
   event_observers_enabled_ = enable;
 
-  aura::Env* env = widget_->GetNativeWindow()->env();
+  aura::Window* window = widget_->GetNativeWindow();
+  // For Mash, handle events sent to the Mus client's root window.
+  if (features::IsUsingWindowService())
+    window = window->GetRootWindow();
+  aura::Env* env = window->env();
   if (enable) {
     immersive_focus_watcher_ = std::make_unique<ImmersiveFocusWatcher>(this);
-    immersive_gesture_handler_ =
-        ImmersiveHandlerFactory::Get()->CreateGestureHandler(this);
     std::set<ui::EventType> types = {
         ui::ET_MOUSE_MOVED, ui::ET_MOUSE_PRESSED,         ui::ET_MOUSE_RELEASED,
         ui::ET_MOUSEWHEEL,  ui::ET_MOUSE_CAPTURE_CHANGED, ui::ET_TOUCH_PRESSED};
     env->AddEventObserver(this, env, types);
+    window->AddPreTargetHandler(this);
   } else {
+    window->RemovePreTargetHandler(this);
     env->RemoveEventObserver(this);
-    immersive_gesture_handler_.reset();
     immersive_focus_watcher_.reset();
 
     animation_.Stop();
   }
 }
 
+void ImmersiveFullscreenController::HandleMouseEvent(
+    const ui::MouseEvent& event,
+    const gfx::Point& location_in_screen,
+    views::Widget* target) {
+  if (!enabled_)
+    return;
+
+  if (event.type() != ui::ET_MOUSE_MOVED &&
+      event.type() != ui::ET_MOUSE_PRESSED &&
+      event.type() != ui::ET_MOUSE_RELEASED &&
+      event.type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
+    return;
+  }
+
+  // Mouse hover can initiate revealing the top-of-window views while |widget_|
+  // is inactive.
+  if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
+    top_edge_hover_timer_.Stop();
+    UpdateLocatedEventRevealedLock(&event, location_in_screen);
+  } else if (event.type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
+    // Trigger reveal if the cursor pauses at the top of the screen for a while.
+    UpdateTopEdgeHoverTimer(event, location_in_screen, target);
+  }
+}
+
+void ImmersiveFullscreenController::HandleTouchEvent(
+    const ui::TouchEvent& event,
+    const gfx::Point& location_in_screen) {
+  if (!enabled_ || event.type() != ui::ET_TOUCH_PRESSED)
+    return;
+
+  // Touch should not initiate revealing the top-of-window views while |widget_|
+  // is inactive.
+  if (!widget_->IsActive())
+    return;
+
+  UpdateLocatedEventRevealedLock(&event, location_in_screen);
+}
+
 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
     const ui::MouseEvent& event,
     const gfx::Point& location_in_screen,
@@ -404,7 +415,7 @@ void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock(
 
   // Neither the mouse nor touch can initiate a reveal when the top-of-window
   // views are sliding closed or are closed with the following exceptions:
-  // - Hovering at y = 0 which is handled in OnMouseEvent().
+  // - Hovering at y = 0 which is handled in HandleMouseEvent().
   // - Doing a SWIPE_OPEN edge gesture which is handled in OnGestureEvent().
   if (reveal_state_ == CLOSED || reveal_state_ == SLIDING_CLOSED)
     return;
@@ -453,9 +464,11 @@ void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock(
 }
 
 void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock() {
-  if (!immersive_context_->IsMouseEventsEnabled()) {
+  if (!aura::client::GetCursorClient(
+           widget_->GetNativeWindow()->GetRootWindow())
+           ->IsMouseEventsEnabled()) {
     // If mouse events are disabled, the user's last interaction was probably
-    // via touch. Do no do further processing in this case as there is no easy
+    // via touch. Do no further processing in this case as there is no easy
     // way of retrieving the position of the user's last touch.
     return;
   }

ash/public/cpp/immersive/immersive_fullscreen_controller.h

@@ -13,6 +13,7 @@
 #include "base/macros.h"
 #include "base/timer/timer.h"
 #include "ui/aura/window_observer.h"
+#include "ui/events/event_handler.h"
 #include "ui/events/event_observer.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/slide_animation.h"
@@ -45,12 +46,12 @@ class ImmersiveContext;
 class ImmersiveFocusWatcher;
 class ImmersiveFullscreenControllerDelegate;
 class ImmersiveFullscreenControllerTestApi;
-class ImmersiveGestureHandler;
 
 class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
     : public aura::WindowObserver,
       public gfx::AnimationDelegate,
       public ui::EventObserver,
+      public ui::EventHandler,
       public views::ViewObserver,
       public ImmersiveRevealedLock::Delegate {
  public:
@@ -109,18 +110,13 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
   views::Widget* widget() { return widget_; }
   views::View* top_container() { return top_container_; }
 
-  // TODO(sky): move OnMouseEvent/OnTouchEvent to private section.
-  void OnMouseEvent(const ui::MouseEvent& event,
-                    const gfx::Point& location_in_screen,
-                    views::Widget* target);
-  void OnTouchEvent(const ui::TouchEvent& event,
-                    const gfx::Point& location_in_screen);
-  // Processes a GestureEvent. This may call SetHandled() on the supplied event.
-  void OnGestureEvent(ui::GestureEvent* event);
-
   // ui::EventObserver:
   void OnEvent(const ui::Event& event) override;
 
+  // ui::EventHandler:
+  void OnEvent(ui::Event* event) override;
+  void OnGestureEvent(ui::GestureEvent* event) override;
+
   // aura::WindowObserver:
   void OnWindowPropertyChanged(aura::Window* window,
                                const void* key,
@@ -165,6 +161,13 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
   // Enables or disables observers for mouse, touch, focus, and activation.
   void EnableEventObservers(bool enable);
 
+  // Called to handle EventObserver::OnEvent.
+  void HandleMouseEvent(const ui::MouseEvent& event,
+                        const gfx::Point& location_in_screen,
+                        views::Widget* target);
+  void HandleTouchEvent(const ui::TouchEvent& event,
+                        const gfx::Point& location_in_screen);
+
   // Updates |top_edge_hover_timer_| based on a mouse |event|. If the mouse is
   // hovered at the top of the screen the timer is started. If the mouse moves
   // away from the top edge, or moves too much in the x direction, the timer is
@@ -289,7 +292,6 @@ class ASH_PUBLIC_EXPORT ImmersiveFullscreenController
   bool animations_disabled_for_test_;
 
   std::unique_ptr<ImmersiveFocusWatcher> immersive_focus_watcher_;
-  std::unique_ptr<ImmersiveGestureHandler> immersive_gesture_handler_;
 
   // The window targeter that was in use before immersive fullscreen mode was
   // entered, if any. Will be re-installed on the window after leaving immersive

ash/public/cpp/immersive/immersive_gesture_handler.h

-// Copyright 2016 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.
-
-#ifndef ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_GESTURE_HANDLER_H_
-#define ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_GESTURE_HANDLER_H_
-
-#include "ash/public/cpp/ash_public_export.h"
-
-namespace ash {
-
-// ImmersiveGestureHandler is responsible for calling
-// ImmersiveFullscreenController::OnGestureEvent() to show/hide the title bar or
-// TabletAppModeWindowDragController::DragWindowFromTop() to drag the window
-// from the top if CanDragWindow is true when a gesture is received.
-class ASH_PUBLIC_EXPORT ImmersiveGestureHandler {
- public:
-  virtual ~ImmersiveGestureHandler() {}
-};
-
-}  // namespace ash
-
-#endif  // ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_GESTURE_HANDLER_H_

ash/public/cpp/immersive/immersive_handler_factory.cc

-// Copyright 2016 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/public/cpp/immersive/immersive_handler_factory.h"
-
-#include "base/logging.h"
-
-namespace ash {
-
-// static
-ImmersiveHandlerFactory* ImmersiveHandlerFactory::instance_ = nullptr;
-
-ImmersiveHandlerFactory::ImmersiveHandlerFactory() {
-  DCHECK(!instance_);
-  instance_ = this;
-}
-
-ImmersiveHandlerFactory::~ImmersiveHandlerFactory() {
-  DCHECK_EQ(instance_, this);
-  instance_ = nullptr;
-}
-
-}  // namespace ash

ash/public/cpp/immersive/immersive_handler_factory.h

-// Copyright 2016 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.
-
-#ifndef ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_HANDLER_FACTORY_H_
-#define ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_HANDLER_FACTORY_H_
-
-#include <memory>
-
-#include "ash/public/cpp/ash_public_export.h"
-
-namespace ash {
-
-class ImmersiveFullscreenController;
-class ImmersiveGestureHandler;
-
-// Used by ImmersiveFullscreenController to create event handlers/watchers.
-class ASH_PUBLIC_EXPORT ImmersiveHandlerFactory {
- public:
-  static ImmersiveHandlerFactory* Get() { return instance_; }
-
-  virtual std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
-      ImmersiveFullscreenController* controller) = 0;
-
- protected:
-  ImmersiveHandlerFactory();
-  virtual ~ImmersiveHandlerFactory();
-
- private:
-  static ImmersiveHandlerFactory* instance_;
-};
-
-}  // namespace ash
-
-#endif  // ASH_PUBLIC_CPP_IMMERSIVE_IMMERSIVE_HANDLER_FACTORY_H_

ash/shell.cc

@@ -131,7 +131,6 @@
 #include "ash/wm/cursor_manager_chromeos.h"
 #include "ash/wm/event_client_impl.h"
 #include "ash/wm/immersive_context_ash.h"
-#include "ash/wm/immersive_handler_factory_ash.h"
 #include "ash/wm/lock_state_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/native_cursor_manager_ash.h"
@@ -1021,8 +1020,6 @@ void Shell::Init(
 
   wallpaper_controller_ = std::make_unique<WallpaperController>();
 
-  immersive_handler_factory_ = std::make_unique<ImmersiveHandlerFactoryAsh>();
-
   window_positioner_ = std::make_unique<WindowPositioner>();
 
   native_cursor_manager_ = new NativeCursorManagerAsh;

ash/shell.h

@@ -125,7 +125,6 @@ class HighlighterController;
 class ImeController;
 class ImeFocusHandler;
 class ImmersiveContext;
-class ImmersiveHandlerFactoryAsh;
 class KeyAccessibilityEnabler;
 class KeyboardBrightnessControlDelegate;
 class AshKeyboardController;
@@ -875,8 +874,6 @@ class ASH_EXPORT Shell : public SessionObserver,
   // For testing only: simulate that a modal window is open
   bool simulate_modal_window_open_for_test_ = false;
 
-  std::unique_ptr<ImmersiveHandlerFactoryAsh> immersive_handler_factory_;
-
   std::unique_ptr<MessageCenterController> message_center_controller_;
 
   base::ObserverList<ShellObserver>::Unchecked shell_observers_;

ash/wm/immersive_context_ash.cc

@@ -12,7 +12,6 @@
 #include "base/logging.h"
 #include "ui/display/screen.h"
 #include "ui/views/widget/widget.h"
-#include "ui/wm/core/cursor_manager.h"
 
 namespace ash {
 
@@ -43,8 +42,4 @@ bool ImmersiveContextAsh::DoesAnyWindowHaveCapture() {
   return wm::GetCaptureWindow() != nullptr;
 }
 
-bool ImmersiveContextAsh::IsMouseEventsEnabled() {
-  return Shell::Get()->cursor_manager()->IsMouseEventsEnabled();
-}
-
 }  // namespace ash

ash/wm/immersive_context_ash.h

@@ -21,7 +21,6 @@ class ASH_EXPORT ImmersiveContextAsh : public ImmersiveContext {
                                     bool entering) override;
   gfx::Rect GetDisplayBoundsInScreen(views::Widget* widget) override;
   bool DoesAnyWindowHaveCapture() override;
-  bool IsMouseEventsEnabled() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ImmersiveContextAsh);

ash/wm/immersive_gesture_handler_classic.cc → ash/wm/immersive_gesture_drag_handler.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "ash/wm/immersive_gesture_handler_classic.h"
+#include "ash/wm/immersive_gesture_drag_handler.h"
 
 #include "ash/public/cpp/app_types.h"
 #include "ash/public/cpp/ash_features.h"
@@ -46,14 +46,31 @@ bool CanBeginGestureDrag(ui::GestureEvent* event) {
   // There may be a bezel sensor off screen logically above
   // |hit_bounds_in_screen|. Handles the ET_GESTURE_SCROLL_BEGIN event
   // triggerd in the bezel area too.
-  return (location_in_screen.y() < hit_bounds_in_screen.y() &&
-          location_in_screen.x() >= hit_bounds_in_screen.x() &&
-          location_in_screen.x() < hit_bounds_in_screen.right());
+  return location_in_screen.y() < hit_bounds_in_screen.y() &&
+         location_in_screen.x() >= hit_bounds_in_screen.x() &&
+         location_in_screen.x() < hit_bounds_in_screen.right();
 }
 
 }  // namespace
 
-bool ImmersiveGestureHandlerClassic::CanDrag(ui::GestureEvent* event) {
+ImmersiveGestureDragHandler::ImmersiveGestureDragHandler(aura::Window* window)
+    : window_(window) {
+  Shell::Get()->AddPreTargetHandler(this);
+}
+
+ImmersiveGestureDragHandler::~ImmersiveGestureDragHandler() {
+  Shell::Get()->RemovePreTargetHandler(this);
+}
+
+void ImmersiveGestureDragHandler::OnGestureEvent(ui::GestureEvent* event) {
+  if (CanDrag(event)) {
+    DCHECK(tablet_mode_app_window_drag_controller_);
+    if (tablet_mode_app_window_drag_controller_->DragWindowFromTop(event))
+      event->SetHandled();
+  }
+}
+
+bool ImmersiveGestureDragHandler::CanDrag(ui::GestureEvent* event) {
   if (!base::FeatureList::IsEnabled(ash::features::kDragAppsInTabletMode))
     return false;
 
@@ -62,15 +79,12 @@ bool ImmersiveGestureHandlerClassic::CanDrag(ui::GestureEvent* event) {
   if (!widget)
     return false;
 
-  aura::Window* window = widget->GetNativeWindow();
-  // Only process the event if its target has the same native window as
-  // |immersive_fullscreen_controller_->widget()|.
-  if (window != immersive_fullscreen_controller_->widget()->GetNativeWindow())
+  if (widget->GetNativeWindow() != window_)
     return false;
 
   // Maximized, fullscreened and snapped windows in tablet mode are allowed to
   // be dragged.
-  wm::WindowState* window_state = wm::GetWindowState(window);
+  wm::WindowState* window_state = wm::GetWindowState(window_);
   if (!window_state ||
       (!window_state->IsMaximized() && !window_state->IsFullscreen() &&
        !window_state->IsSnapped()) ||
@@ -83,7 +97,7 @@ bool ImmersiveGestureHandlerClassic::CanDrag(ui::GestureEvent* event) {
   // Fullscreen browser windows are not draggable. Dragging from top should show
   // the frame.
   if (window_state->IsFullscreen() &&
-      window->GetProperty(aura::client::kAppType) ==
+      window_->GetProperty(aura::client::kAppType) ==
           static_cast<int>(AppType::BROWSER)) {
     return false;
   }
@@ -107,24 +121,4 @@ bool ImmersiveGestureHandlerClassic::CanDrag(ui::GestureEvent* event) {
   return true;
 }
 
-ImmersiveGestureHandlerClassic::ImmersiveGestureHandlerClassic(
-    ImmersiveFullscreenController* controller)
-    : immersive_fullscreen_controller_(controller) {
-  Shell::Get()->AddPreTargetHandler(this);
-}
-
-ImmersiveGestureHandlerClassic::~ImmersiveGestureHandlerClassic() {
-  Shell::Get()->RemovePreTargetHandler(this);
-}
-
-void ImmersiveGestureHandlerClassic::OnGestureEvent(ui::GestureEvent* event) {
-  if (CanDrag(event)) {
-    DCHECK(tablet_mode_app_window_drag_controller_);
-    if (tablet_mode_app_window_drag_controller_->DragWindowFromTop(event))
-      event->SetHandled();
-    return;
-  }
-  immersive_fullscreen_controller_->OnGestureEvent(event);
-}
-
 }  // namespace ash

ash/wm/immersive_gesture_handler_classic.h → ash/wm/immersive_gesture_drag_handler.h

@@ -2,31 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef ASH_WM_IMMERSIVE_GESTURE_HANDLER_CLASSIC_H_
-#define ASH_WM_IMMERSIVE_GESTURE_HANDLER_CLASSIC_H_
+#ifndef ASH_WM_IMMERSIVE_GESTURE_DRAG_HANDLER_H_
+#define ASH_WM_IMMERSIVE_GESTURE_DRAG_HANDLER_H_
 
 #include <memory>
 
 #include "ash/ash_export.h"
-#include "ash/public/cpp/immersive/immersive_gesture_handler.h"
 #include "ui/events/event_handler.h"
 
+namespace aura {
+class Window;
+}
+
 namespace ash {
 
-class ImmersiveFullscreenController;
 class TabletModeAppWindowDragController;
 
 // ImmersiveGestureHandler is responsible for calling
-// ImmersiveFullscreenController::OnGestureEvent() to show/hide the title bar or
 // TabletAppModeWindowDragController::DragWindowFromTop() to drag the window
 // from the top if CanDrag is true when a gesture is received.
-class ASH_EXPORT ImmersiveGestureHandlerClassic
-    : public ImmersiveGestureHandler,
-      public ui::EventHandler {
+class ASH_EXPORT ImmersiveGestureDragHandler : public ui::EventHandler {
  public:
-  explicit ImmersiveGestureHandlerClassic(
-      ImmersiveFullscreenController* controller);
-  ~ImmersiveGestureHandlerClassic() override;
+  explicit ImmersiveGestureDragHandler(aura::Window* window);
+  ~ImmersiveGestureDragHandler() override;
 
   // ui::EventHandler:
   void OnGestureEvent(ui::GestureEvent* event) override;
@@ -35,15 +33,14 @@ class ASH_EXPORT ImmersiveGestureHandlerClassic
   // Returns true if the target of |event| can be dragged.
   bool CanDrag(ui::GestureEvent* event);
 
-  ImmersiveFullscreenController*
-      immersive_fullscreen_controller_;  // Not owned.
-
   std::unique_ptr<TabletModeAppWindowDragController>
       tablet_mode_app_window_drag_controller_;
 
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveGestureHandlerClassic);
+  aura::Window* window_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImmersiveGestureDragHandler);
 };
 
 }  // namespace ash
 
-#endif  // ASH_WM_IMMERSIVE_GESTURE_HANDLER_CLASSIC_H_
+#endif  // ASH_WM_IMMERSIVE_GESTURE_DRAG_HANDLER_H_

ash/wm/immersive_handler_factory_ash.cc

-// Copyright 2016 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/wm/immersive_handler_factory_ash.h"
-
-#include <memory>
-
-#include "ash/wm/immersive_gesture_handler_classic.h"
-
-namespace ash {
-
-ImmersiveHandlerFactoryAsh::ImmersiveHandlerFactoryAsh() = default;
-
-ImmersiveHandlerFactoryAsh::~ImmersiveHandlerFactoryAsh() = default;
-
-std::unique_ptr<ImmersiveGestureHandler>
-ImmersiveHandlerFactoryAsh::CreateGestureHandler(
-    ImmersiveFullscreenController* controller) {
-  return std::make_unique<ImmersiveGestureHandlerClassic>(controller);
-}
-
-}  // namespace ash

ash/wm/immersive_handler_factory_ash.h

-// Copyright 2016 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.
-
-#ifndef ASH_WM_IMMERSIVE_HANDLER_FACTORY_ASH_H_
-#define ASH_WM_IMMERSIVE_HANDLER_FACTORY_ASH_H_
-
-#include "ash/ash_export.h"
-#include "ash/public/cpp/immersive/immersive_handler_factory.h"
-#include "base/macros.h"
-
-namespace ash {
-
-class ASH_EXPORT ImmersiveHandlerFactoryAsh : public ImmersiveHandlerFactory {
- public:
-  ImmersiveHandlerFactoryAsh();
-  ~ImmersiveHandlerFactoryAsh() override;
-
-  // ImmersiveHandlerFactory:
-  std::unique_ptr<ImmersiveGestureHandler> CreateGestureHandler(
-      ImmersiveFullscreenController* controller) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveHandlerFactoryAsh);
-};
-
-}  // namespace ash
-
-#endif  // ASH_WM_IMMERSIVE_HANDLER_FACTORY_ASH_H_

ash/wm/window_state.cc

@@ -15,6 +15,7 @@
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/wm/default_state.h"
+#include "ash/wm/immersive_gesture_drag_handler.h"
 #include "ash/wm/pip/pip_positioner.h"
 #include "ash/wm/tablet_mode/tablet_mode_controller.h"
 #include "ash/wm/window_animations.h"
@@ -451,7 +452,7 @@ void WindowState::SetCanConsumeSystemKeys(bool can_consume_system_keys) {
 }
 
 bool WindowState::IsInImmersiveFullscreen() const {
-  return window_->GetProperty(ash::kImmersiveIsActive);
+  return window_->GetProperty(kImmersiveIsActive);
 }
 
 void WindowState::set_bounds_changed_by_user(bool bounds_changed_by_user) {
@@ -733,6 +734,7 @@ const WindowState* GetWindowState(const aura::Window* window) {
 void WindowState::OnWindowPropertyChanged(aura::Window* window,
                                           const void* key,
                                           intptr_t old) {
+  DCHECK_EQ(window_, window);
   if (key == aura::client::kShowStateKey) {
     if (!ignore_property_change_) {
       WMEvent event(WMEventTypeFromShowState(GetShowState()));
@@ -764,12 +766,22 @@ void WindowState::OnWindowPropertyChanged(aura::Window* window,
     }
     return;
   }
-  if (key == kHideShelfWhenFullscreenKey || key == ash::kImmersiveIsActive) {
+  if (key == kHideShelfWhenFullscreenKey || key == kImmersiveIsActive) {
     if (!ignore_property_change_) {
       // This change came from outside ash. Update our shelf visibility based
       // on our changed state.
       ash::Shell::Get()->UpdateShelfVisibility();
     }
+    if (key == kImmersiveIsActive) {
+      if (IsInImmersiveFullscreen()) {
+        if (!immersive_gesture_drag_handler_) {
+          immersive_gesture_drag_handler_ =
+              std::make_unique<ImmersiveGestureDragHandler>(window);
+        }
+      } else {
+        immersive_gesture_drag_handler_.reset();
+      }
+    }
     return;
   }
 }
@@ -783,6 +795,7 @@ void WindowState::OnWindowAddedToRootWindow(aura::Window* window) {
 
 void WindowState::OnWindowDestroying(aura::Window* window) {
   DCHECK_EQ(window_, window);
+  immersive_gesture_drag_handler_.reset();
   current_state_->OnWindowDestroying(this);
   delegate_.reset();
 }

ash/wm/window_state.h

@@ -26,6 +26,7 @@ class Rect;
 }
 
 namespace ash {
+class ImmersiveGestureDragHandler;
 class LockWindowState;
 class TabletModeWindowState;
 
@@ -475,6 +476,10 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
 
   std::unique_ptr<State> current_state_;
 
+  // An object that assists with dragging immersive mode windows in tablet mode.
+  // Only non-null when immersive mode is active.
+  std::unique_ptr<ImmersiveGestureDragHandler> immersive_gesture_drag_handler_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowState);
 };
 

chrome/browser/ui/BUILD.gn

@@ -1448,8 +1448,6 @@ jumbo_split_static_library("ui") {
       "views/frame/browser_non_client_frame_view_ash.h",
       "views/frame/immersive_context_mus.cc",
       "views/frame/immersive_context_mus.h",
-      "views/frame/immersive_handler_factory_mus.cc",
-      "views/frame/immersive_handler_factory_mus.h",
       "views/frame/immersive_mode_controller_ash.cc",
       "views/frame/immersive_mode_controller_ash.h",
       "views/frame/native_browser_frame_factory_chromeos.cc",

chrome/browser/ui/ash/chrome_browser_main_extra_parts_ash.cc

@@ -44,7 +44,6 @@
 #include "chrome/browser/ui/ash/vpn_list_forwarder.h"
 #include "chrome/browser/ui/ash/wallpaper_controller_client.h"
 #include "chrome/browser/ui/views/frame/immersive_context_mus.h"
-#include "chrome/browser/ui/views/frame/immersive_handler_factory_mus.h"
 #include "chrome/browser/ui/views/ime_driver/ime_driver_mus.h"
 #include "chrome/browser/ui/views/select_file_dialog_extension.h"
 #include "chrome/browser/ui/views/select_file_dialog_extension_factory.h"
@@ -188,8 +187,6 @@ void ChromeBrowserMainExtraPartsAsh::PreProfileInit() {
   if (!features::IsMultiProcessMash()) {
     ash_shell_init_ = std::make_unique<AshShellInit>();
   } else {
-    immersive_handler_factory_ = std::make_unique<ImmersiveHandlerFactoryMus>();
-
     // Enterprise support in the browser can monitor user activity. Connect to
     // the UI service to monitor activity. The ash process has its own monitor.
     // TODO(jamescook): Figure out if we need this for SingleProcessMash.

chrome/browser/ui/ash/chrome_browser_main_extra_parts_ash.h

@@ -39,7 +39,6 @@ class ChromeNewWindowClient;
 class DataPromoNotification;
 class ImeControllerClient;
 class ImmersiveContextMus;
-class ImmersiveHandlerFactoryMus;
 class LoginScreenClient;
 class MediaClient;
 class NetworkConnectDelegateChromeOS;
@@ -88,7 +87,6 @@ class ChromeBrowserMainExtraPartsAsh : public ChromeBrowserMainExtraParts {
 
   // Initialized in PreProfileInit if ash config == MASH:
   std::unique_ptr<ImmersiveContextMus> immersive_context_;
-  std::unique_ptr<ImmersiveHandlerFactoryMus> immersive_handler_factory_;
   std::unique_ptr<aura::UserActivityForwarder> user_activity_forwarder_;
   std::unique_ptr<ui::UserActivityDetector> user_activity_detector_;
 

chrome/browser/ui/views/frame/immersive_context_mus.cc

@@ -40,9 +40,3 @@ gfx::Rect ImmersiveContextMus::GetDisplayBoundsInScreen(views::Widget* widget) {
 bool ImmersiveContextMus::DoesAnyWindowHaveCapture() {
   return views::DesktopCaptureClient::GetCaptureWindowGlobal() != nullptr;
 }
-
-bool ImmersiveContextMus::IsMouseEventsEnabled() {
-  // TODO: http://crbug.com/640374.
-  NOTIMPLEMENTED();
-  return true;
-}

chrome/browser/ui/views/frame/immersive_context_mus.h

@@ -21,7 +21,6 @@ class ImmersiveContextMus : public ash::ImmersiveContext {
       bool entering) override;
   gfx::Rect GetDisplayBoundsInScreen(views::Widget* widget) override;
   bool DoesAnyWindowHaveCapture() override;
-  bool IsMouseEventsEnabled() override;
 
  private:
   static ImmersiveContextMus* instance_;

chrome/browser/ui/views/frame/immersive_handler_factory_mus.cc

-// Copyright 2016 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 "chrome/browser/ui/views/frame/immersive_handler_factory_mus.h"
-
-#include "ash/public/cpp/immersive/immersive_gesture_handler.h"
-#include "base/logging.h"
-
-ImmersiveHandlerFactoryMus::ImmersiveHandlerFactoryMus() {}
-
-ImmersiveHandlerFactoryMus::~ImmersiveHandlerFactoryMus() {}
-
-std::unique_ptr<ash::ImmersiveGestureHandler>
-ImmersiveHandlerFactoryMus::CreateGestureHandler(
-    ash::ImmersiveFullscreenController* controller) {
-  NOTIMPLEMENTED();
-  return nullptr;
-}

chrome/browser/ui/views/frame/immersive_handler_factory_mus.h

-// Copyright 2016 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.
-
-#ifndef CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_HANDLER_FACTORY_MUS_H_
-#define CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_HANDLER_FACTORY_MUS_H_
-
-#include "ash/public/cpp/immersive/immersive_handler_factory.h"
-#include "base/macros.h"
-
-class ImmersiveHandlerFactoryMus : public ash::ImmersiveHandlerFactory {
- public:
-  ImmersiveHandlerFactoryMus();
-  ~ImmersiveHandlerFactoryMus() override;
-
-  // ImmersiveHandlerFactory:
-  std::unique_ptr<ash::ImmersiveGestureHandler> CreateGestureHandler(
-      ash::ImmersiveFullscreenController* controller) override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ImmersiveHandlerFactoryMus);
-};
-
-#endif  // CHROME_BROWSER_UI_VIEWS_FRAME_IMMERSIVE_HANDLER_FACTORY_MUS_H_