Adds ImmersiveContext and ImmersiveHandlerFactory

ash/wm/immersive_fullscreen_controller.cc

 // Copyright 2013 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_fullscreen_controller.h"
 
 #include <set>
 
 #include "ash/common/ash_constants.h"
-#include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/wm/immersive/wm_immersive_fullscreen_controller_delegate.h"
-#include "ash/common/wm/window_state.h"
-#include "ash/common/wm_lookup.h"
-#include "ash/common/wm_root_window_controller.h"
-#include "ash/common/wm_shell.h"
-#include "ash/common/wm_window.h"
+#include "ash/shared/immersive_context.h"
 #include "ash/wm/immersive_focus_watcher.h"
 #include "ash/wm/immersive_gesture_handler.h"
+#include "ash/wm/immersive_handler_factory.h"
 #include "base/metrics/histogram.h"
 #include "ui/aura/env.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/base_event_utils.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/views/bubble/bubble_dialog_delegate.h"
 #include "ui/views/view.h"
@@ skipping 22 matching lines @@
 // vertical. This is used to make sure that gesture is close to vertical instead
 // of just more vertical then horizontal.
 const int kSwipeVerticalThresholdMultiplier = 3;
 
 // The height in pixels of the region above the top edge of the display which
 // hosts the immersive fullscreen window in which mouse events are ignored
 // (cannot reveal or unreveal the top-of-window views).
 // See ShouldIgnoreMouseEventAtLocation() for more details.
 const int kHeightOfDeadRegionAboveTopContainer = 10;
 
-// Returns the bounds of the display nearest to |window| in screen coordinates.
-gfx::Rect GetDisplayBoundsInScreen(WmWindow* window) {
-  return window->GetDisplayNearestWindow().bounds();
-}
-
 }  // namespace
 
 // The height in pixels of the region below the top edge of the display in which
 // the mouse can trigger revealing the top-of-window views.
 // The height must be greater than 1px because the top pixel is used to trigger
 // moving the cursor between displays if the user has a vertical display layout
 // (primary display above/below secondary display).
 const int ImmersiveFullscreenController::kMouseRevealBoundsHeight = 3;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 16 matching lines @@
   EnableWindowObservers(false);
 }
 
 void ImmersiveFullscreenController::Init(
     WmImmersiveFullscreenControllerDelegate* delegate,
     views::Widget* widget,
     views::View* top_container) {
   delegate_ = delegate;
   top_container_ = top_container;
   widget_ = widget;
-  widget_window_ = WmLookup::Get()->GetWindowForWidget(widget_);
-  widget_window_->InstallResizeHandleWindowTargeter(this);
+  ImmersiveContext::Get()->InstallResizeHandleWindowTargeter(this);
 }
 
 void ImmersiveFullscreenController::SetEnabled(WindowType window_type,
                                                bool enabled) {
   if (enabled_ == enabled)
     return;
   enabled_ = enabled;
 
   EnableWindowObservers(enabled_);
 
-  wm::WindowState* window_state = widget_window_->GetWindowState();
-  // Auto hide the shelf in immersive fullscreen instead of hiding it.
-  window_state->set_shelf_mode_in_fullscreen(
-      enabled ? ash::wm::WindowState::SHELF_AUTO_HIDE_VISIBLE
-              : ash::wm::WindowState::SHELF_HIDDEN);
-
-  // Update the window's immersive mode state for the window manager.
-  window_state->set_in_immersive_fullscreen(enabled);
-
-  for (WmWindow* root_window : WmShell::Get()->GetAllRootWindows())
-    root_window->GetRootWindowController()->GetShelf()->UpdateVisibilityState();
+  ImmersiveContext::Get()->OnEnteringOrExitingImmersive(this, enabled);
 
   if (enabled_) {
     // Animate enabling immersive mode by sliding out the top-of-window views.
     // No animation occurs if a lock is holding the top-of-window views open.
 
     // Do a reveal to set the initial state for the animation. (And any
     // required state in case the animation cannot run because of a lock holding
     // the top-of-window views open.)
     MaybeStartReveal(ANIMATE_NO);
 
     // Reset the located event so that it does not affect whether the
     // top-of-window views are hidden.
     located_event_revealed_lock_.reset();
 
     // Try doing the animation.
     MaybeEndReveal(ANIMATE_SLOW);
 
     if (reveal_state_ == REVEALED) {
       // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
       UpdateLocatedEventRevealedLock();
-      immersive_focus_watcher_->UpdateFocusRevealedLock();
+      if (immersive_focus_watcher_)

[James Cook, 2016/08/19 00:37:14]

It looks like your implementation of CreateFocusWatcher always returns a
watcher. Do you need these if()s?

[sky, 2016/08/19 03:30:47]

The mash implementation will return null initially, and may return null always,
I have to poke at it some more.

[James Cook, 2016/08/19 15:49:59]

OK. If you end up with a mash implementation that always returns a non-null one,
please clean up these if()s, as it makes it harder for me to reason about when
the lock exists.

+        immersive_focus_watcher_->UpdateFocusRevealedLock();
     }
   } else {
     // Stop cursor-at-top tracking.
     top_edge_hover_timer_.Stop();
     reveal_state_ = CLOSED;
 
     delegate_->OnImmersiveFullscreenExited();
   }
 
   if (enabled_) {
@@ skipping 187 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveFullscreenController::EnableWindowObservers(bool enable) {
   if (observers_enabled_ == enable)
     return;
   observers_enabled_ = enable;
 
   if (enable) {
-    immersive_focus_watcher_.reset(new ImmersiveFocusWatcher(this));
-    immersive_gesture_handler_.reset(new ImmersiveGestureHandler(this));
+    immersive_focus_watcher_ =
+        ImmersiveHandlerFactory::Get()->CreateFocusWatcher(this);
+    immersive_gesture_handler_ =
+        ImmersiveHandlerFactory::Get()->CreateGestureHandler(this);
     widget_->AddObserver(this);
     const bool wants_moves = true;
-    WmShell::Get()->AddPointerWatcher(this, wants_moves);
-
+    ImmersiveContext::Get()->AddPointerWatcher(this, wants_moves);
   } else {
-    WmShell::Get()->RemovePointerWatcher(this);
+    ImmersiveContext::Get()->RemovePointerWatcher(this);
     widget_->RemoveObserver(this);
     immersive_gesture_handler_.reset();
     immersive_focus_watcher_.reset();
 
     animation_->Stop();
   }
 }
 
 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
     const ui::MouseEvent& event,
     const gfx::Point& location_in_screen,
     views::Widget* target) {
   DCHECK(enabled_);
   DCHECK(reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED);
 
   // Check whether |widget_| is the event target instead of checking for
   // activation. This allows the timer to be started when |widget_| is inactive
   // but prevents starting the timer if the mouse is over a portion of the top
   // edge obscured by an unrelated widget.
   if (!top_edge_hover_timer_.IsRunning() && target != widget_) {
     return;
   }
 
   // Mouse hover should not initiate revealing the top-of-window views while a
   // window has mouse capture.
-  if (WmShell::Get()->GetCaptureWindow())
+  if (ImmersiveContext::Get()->DoesAnyWindowHaveCapture())
     return;
 
   if (ShouldIgnoreMouseEventAtLocation(location_in_screen))
     return;
 
   // Stop the timer if the cursor left the top edge or is on a different
   // display.
-  gfx::Rect hit_bounds_in_screen = GetDisplayBoundsInScreen(widget_window_);
+  gfx::Rect hit_bounds_in_screen = GetDisplayBoundsInScreen();
   hit_bounds_in_screen.set_height(kMouseRevealBoundsHeight);
   if (!hit_bounds_in_screen.Contains(location_in_screen)) {
     top_edge_hover_timer_.Stop();
     return;
   }
 
   // The cursor is now at the top of the screen. Consider the cursor "not
   // moving" even if it moves a little bit because users don't have perfect
   // pointing precision. (The y position is not tested because
   // |hit_bounds_in_screen| is short.)
@@ skipping 28 matching lines @@
     return;
 
   // For the sake of simplicity, ignore |widget_|'s activation in computing
   // whether the top-of-window views should stay revealed. Ideally, the
   // top-of-window views would stay revealed only when the mouse cursor is
   // hovered above a non-obscured portion of the top-of-window views. The
   // top-of-window views may be partially obscured when |widget_| is inactive.
 
   // Ignore all events while a window has capture. This keeps the top-of-window
   // views revealed during a drag.
-  if (WmShell::Get()->GetCaptureWindow())
+  if (ImmersiveContext::Get()->DoesAnyWindowHaveCapture())
     return;
 
   if ((!event || event->IsMouseEvent()) &&
       ShouldIgnoreMouseEventAtLocation(location_in_screen)) {
     return;
   }
 
   // The visible bounds of |top_container_| should be contained in
   // |hit_bounds_in_screen|.
   std::vector<gfx::Rect> hit_bounds_in_screen =
@@ skipping 15 matching lines @@
     }
   }
 
   if (keep_revealed)
     AcquireLocatedEventRevealedLock();
   else
     located_event_revealed_lock_.reset();
 }
 
 void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock() {
-  if (!WmShell::Get()->IsMouseEventsEnabled()) {
+  if (!ImmersiveContext::Get()->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
     // way of retrieving the position of the user's last touch.
     return;
   }
   UpdateLocatedEventRevealedLock(
       nullptr, display::Screen::GetScreen()->GetCursorScreenPoint());
 }
 
 void ImmersiveFullscreenController::AcquireLocatedEventRevealedLock() {
@@ skipping 16 matching lines @@
   if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED) {
     if (swipe_type == SWIPE_OPEN && !located_event_revealed_lock_.get()) {
       located_event_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
       return true;
     }
   } else {
     if (swipe_type == SWIPE_CLOSE) {
       // Attempt to end the reveal. If other code is holding onto a lock, the
       // attempt will be unsuccessful.
       located_event_revealed_lock_.reset();
-      immersive_focus_watcher_->ReleaseLock();
+      if (immersive_focus_watcher_)
+        immersive_focus_watcher_->ReleaseLock();
 
       if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED) {
         widget_->GetFocusManager()->ClearFocus();
         return true;
       }
 
       // Ending the reveal was unsuccessful. Reaquire the locks if appropriate.
       UpdateLocatedEventRevealedLock();
-      immersive_focus_watcher_->UpdateFocusRevealedLock();
+      if (immersive_focus_watcher_)
+        immersive_focus_watcher_->UpdateFocusRevealedLock();
     }
   }
   return false;
 }
 
 int ImmersiveFullscreenController::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
     case ANIMATE_SLOW:
@@ skipping 104 matching lines @@
   // fullscreen window on the bottom display. It is really hard to trigger a
   // reveal in this case because:
   // - It is hard to stop the cursor in the top |kMouseRevealBoundsHeight|
   //   pixels of the bottom display.
   // - The cursor is warped to the top display if the cursor gets to the top
   //   edge of the bottom display.
   // Mouse events are ignored in the bottom few pixels of the top display
   // (Mouse events in this region cannot start or end a reveal). This allows a
   // user to overshoot the top of the bottom display and still reveal the
   // top-of-window views.
-  gfx::Rect dead_region = GetDisplayBoundsInScreen(widget_window_);
+  gfx::Rect dead_region = GetDisplayBoundsInScreen();
   dead_region.set_y(dead_region.y() - kHeightOfDeadRegionAboveTopContainer);
   dead_region.set_height(kHeightOfDeadRegionAboveTopContainer);
   return dead_region.Contains(location);
 }
 
 bool ImmersiveFullscreenController::ShouldHandleGestureEvent(
     const gfx::Point& location) const {
   DCHECK(widget_->IsActive());
   if (reveal_state_ == REVEALED) {
     std::vector<gfx::Rect> hit_bounds_in_screen(
         delegate_->GetVisibleBoundsInScreen());
     for (size_t i = 0; i < hit_bounds_in_screen.size(); ++i) {
       if (hit_bounds_in_screen[i].Contains(location))
         return true;
     }
     return false;
   }
 
   // When the top-of-window views are not fully revealed, handle gestures which
   // start in the top few pixels of the screen.
-  gfx::Rect hit_bounds_in_screen(GetDisplayBoundsInScreen(widget_window_));
+  gfx::Rect hit_bounds_in_screen(GetDisplayBoundsInScreen());
   hit_bounds_in_screen.set_height(kImmersiveFullscreenTopEdgeInset);
   if (hit_bounds_in_screen.Contains(location))
     return true;
 
   // There may be a bezel sensor off screen logically above
   // |hit_bounds_in_screen|. The check for the event not contained by the
   // closest screen ensures that the event is from a valid bezel (as opposed to
   // another screen in an extended desktop).
   gfx::Rect screen_bounds =
       display::Screen::GetScreen()->GetDisplayNearestPoint(location).bounds();
   return (!screen_bounds.Contains(location) &&
           location.y() < hit_bounds_in_screen.y() &&
           location.x() >= hit_bounds_in_screen.x() &&
           location.x() < hit_bounds_in_screen.right());
 }
 
+gfx::Rect ImmersiveFullscreenController::GetDisplayBoundsInScreen() const {
+  return ImmersiveContext::Get()->GetDisplayBoundsInScreen(widget_);
+}
+
 }  // namespace ash