Enable revealing the top-of-window views in immersive fullscreen when the owning window is inactive

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/shell.h"
 #include "ash/wm/window_state.h"
@@ skipping 269 matching lines @@
     // Reset the located event and the focus revealed locks so that they do not
     // affect whether the top-of-window views are hidden.
     located_event_revealed_lock_.reset();
     focus_revealed_lock_.reset();
 
     // Try doing the animation.
     MaybeEndReveal(ANIMATE_SLOW);
 
     if (reveal_state_ == REVEALED) {
       // Reveal was unsuccessful. Reacquire the revealed locks if appropriate.
-      UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
+      UpdateLocatedEventRevealedLock(NULL);
       UpdateFocusRevealedLock();
     }
   } else {
     // Stop cursor-at-top tracking.
     top_edge_hover_timer_.Stop();
     reveal_state_ = CLOSED;
 
     delegate_->OnImmersiveFullscreenExited();
   }
 }
@@ skipping 24 matching lines @@
   std::vector<gfx::Rect> bounds_in_screen(
       delegate_->GetVisibleBoundsInScreen());
   DCHECK(!bounds_in_screen.empty());
   int bottommost_in_screen = bounds_in_screen[0].bottom();
   for (size_t i = 1; i < bounds_in_screen.size(); ++i) {
     if (bounds_in_screen[i].bottom() > bottommost_in_screen)
       bottommost_in_screen = bounds_in_screen[i].bottom();
   }
   gfx::Point cursor_pos(0, bottommost_in_screen + 100);
   aura::Env::GetInstance()->set_last_mouse_location(cursor_pos);
-  UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
+  UpdateLocatedEventRevealedLock(NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ui::EventHandler overrides:
 
 void ImmersiveFullscreenController::OnMouseEvent(ui::MouseEvent* event) {
   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 should not initiate revealing the top-of-window views while
-  // |native_window_| is inactive.
-  if (!views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive())
-    return;
+  // Mouse hover can initiate revealing the top-of-window views while |widget_|
+  // is inactive.
 
-  // Mouse hover should not initiate revealing the top-of-window views while
-  // a window has mouse capture.
-  if (aura::client::GetCaptureWindow(native_window_))
-    return;
-
-  if (IsRevealed())
-    UpdateLocatedEventRevealedLock(event, ALLOW_REVEAL_WHILE_CLOSING_NO);
-
-  // Trigger a reveal if the cursor pauses at the top of the screen for a
-  // while.
-  if (event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)
+  if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
+    top_edge_hover_timer_.Stop();
+    UpdateLocatedEventRevealedLock(event);
+  } else if (event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
+    // Trigger a reveal if the cursor pauses at the top of the screen for a
+    // while.
     UpdateTopEdgeHoverTimer(event);
+  }
 }
 
 void ImmersiveFullscreenController::OnTouchEvent(ui::TouchEvent* event) {
   if (!enabled_ || event->type() != ui::ET_TOUCH_PRESSED)
     return;
 
-  UpdateLocatedEventRevealedLock(event, ALLOW_REVEAL_WHILE_CLOSING_NO);
+  // Touch should not initiate revealing the top-of-window views while |widget_|
+  // is inactive.
+  if (!widget_->IsActive())
+    return;
+
+  UpdateLocatedEventRevealedLock(event);
 }
 
 void ImmersiveFullscreenController::OnGestureEvent(ui::GestureEvent* event) {
   if (!enabled_)
     return;
 
   // Touch gestures should not initiate revealing the top-of-window views while
-  // |native_window_| is inactive.
-  if (!views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive())
+  // |widget_| is inactive.
+  if (!widget_->IsActive())
     return;
 
   switch (event->type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       if (ShouldHandleGestureEvent(GetEventLocationInScreen(*event))) {
         gesture_begun_ = true;
         event->SetHandled();
       }
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
@@ skipping 34 matching lines @@
   native_window_ = NULL;
 
   // Set |enabled_| to false such that any calls to MaybeStartReveal() and
   // MaybeEndReveal() have no effect.
   enabled_ = false;
 }
 
 void ImmersiveFullscreenController::OnWidgetActivationChanged(
     views::Widget* widget,
     bool active) {
-  // Mouse hover should not initiate revealing the top-of-window views while
-  // |native_window_| is inactive.
-  top_edge_hover_timer_.Stop();
-
   UpdateFocusRevealedLock();
-
-  // Allow the top-of-window views to stay revealed if all of the revealed locks
-  // were released in the process of activating |widget| but the mouse is still
-  // hovered above the top-of-window views. For instance, if the bubble which
-  // has been keeping the top-of-window views revealed is hidden but the mouse
-  // is hovered above the top-of-window views, the top-of-window views should
-  // stay revealed. We cannot call UpdateLocatedEventRevealedLock() from
-  // BubbleManager::UpdateRevealedLock() because |widget| is not yet active
-  // at that time.
-  UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_YES);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // gfx::AnimationDelegate overrides:
 
 void ImmersiveFullscreenController::AnimationEnded(
     const gfx::Animation* animation) {
   if (reveal_state_ == SLIDING_OPEN) {
     OnSlideOpenAnimationCompleted();
   } else if (reveal_state_ == SLIDING_CLOSED) {
@@ skipping 49 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveFullscreenController::EnableWindowObservers(bool enable) {
   if (observers_enabled_ == enable)
     return;
   observers_enabled_ = enable;
 
-  views::Widget* widget =
-      views::Widget::GetWidgetForNativeWindow(native_window_);
-  views::FocusManager* focus_manager = widget->GetFocusManager();
+  views::FocusManager* focus_manager = widget_->GetFocusManager();
 
   if (enable) {
-    widget->AddObserver(this);
+    widget_->AddObserver(this);
     focus_manager->AddFocusChangeListener(this);
     Shell::GetInstance()->AddPreTargetHandler(this);
     native_window_->AddObserver(this);
 
     RecreateBubbleManager();
   } else {
-    widget->RemoveObserver(this);
+    widget_->RemoveObserver(this);
     focus_manager->RemoveFocusChangeListener(this);
     Shell::GetInstance()->RemovePreTargetHandler(this);
     native_window_->RemoveObserver(this);
 
     // We have stopped observing whether transient children are added or removed
     // to |native_window_|. The set of bubbles that BubbleManager is observing
     // will become stale really quickly. Destroy BubbleManager and recreate it
     // when we start observing |native_window_| again.
     bubble_manager_.reset();
 
     animation_->Stop();
   }
 }
 
 void ImmersiveFullscreenController::UpdateTopEdgeHoverTimer(
     ui::MouseEvent* event) {
   DCHECK(enabled_);
-  // Stop the timer if the top-of-window views are already revealed.
-  if (reveal_state_ == SLIDING_OPEN || reveal_state_ == REVEALED) {
-    top_edge_hover_timer_.Stop();
+  DCHECK(reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED);
+
+  // Check whether |native_window_| is the event target's parent window 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() &&
+      !native_window_->Contains(static_cast<aura::Window*>(event->target()))) {
     return;
   }
 
+  // Mouse hover should not initiate revealing the top-of-window views while a
+  // window has mouse capture.
+  if (aura::client::GetCaptureWindow(native_window_))
+    return;
+
   gfx::Point location_in_screen = GetEventLocationInScreen(*event);
   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(native_window_);
   hit_bounds_in_screen.set_height(kMouseRevealBoundsHeight);
   if (!hit_bounds_in_screen.Contains(location_in_screen)) {
     top_edge_hover_timer_.Stop();
@@ skipping 15 matching lines @@
   // Timer is stopped when |this| is destroyed, hence Unretained() is safe.
   top_edge_hover_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kMouseRevealDelayMs),
       base::Bind(
           &ImmersiveFullscreenController::AcquireLocatedEventRevealedLock,
           base::Unretained(this)));
 }
 
 void ImmersiveFullscreenController::UpdateLocatedEventRevealedLock(
-    ui::LocatedEvent* event,
-    AllowRevealWhileClosing allow_reveal_while_closing) {
+    ui::LocatedEvent* event) {
   if (!enabled_)
     return;
   DCHECK(!event || event->IsMouseEvent() || event->IsTouchEvent());
 
   // 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().
   // - Doing a SWIPE_OPEN edge gesture which is handled in OnGestureEvent().
-  if (reveal_state_ == CLOSED ||
-      (reveal_state_ == SLIDING_CLOSED &&
-       allow_reveal_while_closing == ALLOW_REVEAL_WHILE_CLOSING_NO)) {
+  if (reveal_state_ == CLOSED || reveal_state_ == SLIDING_CLOSED)
     return;
-  }
 
-  // Neither the mouse nor touch should keep the top-of-window views revealed if
-  // |native_window_| is not active.
-  if (!views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive()) {
-    located_event_revealed_lock_.reset();
-    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 (aura::client::GetCaptureWindow(native_window_))
     return;
 
   gfx::Point location_in_screen;
   if (event && event->type() != ui::ET_MOUSE_CAPTURE_CHANGED) {
     location_in_screen = GetEventLocationInScreen(*event);
   } else {
@@ skipping 46 matching lines @@
   // |ImmersiveFullscreenController::animations_disabled_for_test_| is true.
   if (!located_event_revealed_lock_.get())
     located_event_revealed_lock_.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
 }
 
 void ImmersiveFullscreenController::UpdateFocusRevealedLock() {
   if (!enabled_)
     return;
 
   bool hold_lock = false;
-  views::Widget* widget =
-      views::Widget::GetWidgetForNativeWindow(native_window_);
-  if (widget->IsActive()) {
-    views::View* focused_view = widget->GetFocusManager()->GetFocusedView();
+  if (widget_->IsActive()) {
+    views::View* focused_view = widget_->GetFocusManager()->GetFocusedView();
     if (top_container_->Contains(focused_view))
       hold_lock = true;
   } else {
     aura::Window* active_window = aura::client::GetActivationClient(
         native_window_->GetRootWindow())->GetActiveWindow();
     views::BubbleDelegateView* bubble_delegate =
         AsBubbleDelegate(active_window);
     if (bubble_delegate && bubble_delegate->anchor_widget()) {
       // BubbleManager will already have locked the top-of-window views if the
       // bubble is anchored to a child of |top_container_|. Don't acquire
@@ skipping 26 matching lines @@
   }
 }
 
 bool ImmersiveFullscreenController::UpdateRevealedLocksForSwipe(
     SwipeType swipe_type) {
   if (!enabled_ || swipe_type == SWIPE_NONE)
     return false;
 
   // Swipes while |native_window_| is inactive should have been filtered out in
   // OnGestureEvent().
-  DCHECK(views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive());
+  DCHECK(widget_->IsActive());
 
   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();
       focus_revealed_lock_.reset();
 
       if (reveal_state_ == SLIDING_CLOSED || reveal_state_ == CLOSED)
         return true;
 
       // Ending the reveal was unsuccessful. Reaquire the locks if appropriate.
-      UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
+      UpdateLocatedEventRevealedLock(NULL);
       UpdateFocusRevealedLock();
     }
   }
   return false;
 }
 
 int ImmersiveFullscreenController::GetAnimationDuration(Animate animate) const {
   switch (animate) {
     case ANIMATE_NO:
       return 0;
@@ skipping 40 matching lines @@
   }
 }
 
 void ImmersiveFullscreenController::OnSlideOpenAnimationCompleted() {
   DCHECK_EQ(SLIDING_OPEN, reveal_state_);
   reveal_state_ = REVEALED;
   delegate_->SetVisibleFraction(1);
 
   // The user may not have moved the mouse since the reveal was initiated.
   // Update the revealed lock to reflect the mouse's current state.
-  UpdateLocatedEventRevealedLock(NULL, ALLOW_REVEAL_WHILE_CLOSING_NO);
+  UpdateLocatedEventRevealedLock(NULL);
 }
 
 void ImmersiveFullscreenController::MaybeEndReveal(Animate animate) {
   if (!enabled_ || revealed_lock_count_ != 0)
     return;
 
   if (animations_disabled_for_test_)
     animate = ANIMATE_NO;
 
   // Callers with ANIMATE_NO expect this function to synchronously close the
@@ skipping 51 matching lines @@
   // user to overshoot the top of the bottom display and still reveal the
   // top-of-window views.
   gfx::Rect dead_region = GetDisplayBoundsInScreen(native_window_);
   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;
   }
 
@@ skipping 26 matching lines @@
         AsBubbleDelegate(transient_child);
     if (bubble_delegate &&
         bubble_delegate->GetAnchorView() &&
         top_container_->Contains(bubble_delegate->GetAnchorView())) {
       bubble_manager_->StartObserving(transient_child);
     }
   }
 }
 
 }  // namespace ash