Keep the top-of-window views revealed when clicking on the top-of-window views with a bubble open

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

 // Copyright 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 "chrome/browser/ui/views/frame/immersive_mode_controller_ash.h"
 
 #include <set>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 322 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);
+      UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_NO);
       UpdateFocusRevealedLock();
     }
   } else {
     // Stop cursor-at-top tracking.
     top_edge_hover_timer_.Stop();
     // Snap immediately to the closed state.
     reveal_state_ = CLOSED;
     EnablePaintToLayer(false);
     delegate_->SetImmersiveStyle(false);
     SetRenderWindowTopInsetsForTouch(0);
@@ skipping 66 matching lines @@
   // |native_window_| is inactive.
   if (!views::Widget::GetWidgetForNativeWindow(native_window_)->IsActive())
     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;
 
   if (IsRevealed())
-    UpdateLocatedEventRevealedLock(event);
+    UpdateLocatedEventRevealedLock(event, 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)
     UpdateTopEdgeHoverTimer(event);
 }
 
 void ImmersiveModeControllerAsh::OnTouchEvent(ui::TouchEvent* event) {
   if (!enabled_ || event->type() != ui::ET_TOUCH_PRESSED)
     return;
 
-  UpdateLocatedEventRevealedLock(event);
+  UpdateLocatedEventRevealedLock(event, REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::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())
     return;
@@ skipping 20 matching lines @@
       break;
   }
 }
 
 void ImmersiveModeControllerAsh::OnWillChangeFocus(views::View* focused_before,
                                                    views::View* focused_now) {
 }
 
 void ImmersiveModeControllerAsh::OnDidChangeFocus(views::View* focused_before,
                                                   views::View* focused_now) {
-  scoped_ptr<ImmersiveRevealedLock> lock;
-  if (reveal_state_ == REVEALED || reveal_state_ == SLIDING_OPEN) {
-    // Acquire a lock so that if UpdateLocatedEventRevealedLock() or
-    // UpdateFocusRevealedLock() ends the reveal, it occurs after the
-    // function terminates. This is useful in tests.
-    lock.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
-  }
-
-  UpdateLocatedEventRevealedLock(NULL);

[pkotwicz, 2013/08/05 19:14:07]

This is no longer necessary given that it is now ok to update the
|located_event_revealed_lock_| slightly after the top-of-window views have
started unrevealing.
Bubbles are also way more common than transient windows. (So the amount of
scenarios where this code would have avoided a couple extra layout calls is
minimal)

   UpdateFocusRevealedLock();
 }
 
 void ImmersiveModeControllerAsh::OnWidgetDestroying(views::Widget* widget) {
   EnableWindowObservers(false);
   native_window_ = NULL;
 
   // Set |enabled_| to false such that any calls to MaybeStartReveal() and
   // MaybeEndReveal() have no effect.
   enabled_ = false;
 }
 
 void ImmersiveModeControllerAsh::OnWidgetActivationChanged(
     views::Widget* widget,
     bool active) {
-  scoped_ptr<ImmersiveRevealedLock> lock;
-  if (reveal_state_ == REVEALED || reveal_state_ == SLIDING_OPEN) {
-    // Acquire a lock so that if UpdateLocatedEventRevealedLock() or
-    // UpdateFocusRevealedLock() ends the reveal, it occurs after the
-    // function terminates. This is useful in tests.
-    lock.reset(GetRevealedLock(ANIMATE_REVEAL_YES));
-  }
-
   // Mouse hover should not initiate revealing the top-of-window views while
   // |native_window_| is inactive.
   top_edge_hover_timer_.Stop();
 
-  UpdateLocatedEventRevealedLock(NULL);
   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 activate

[James Cook, 2013/08/06 23:32:42]

activate -> activated

+  // at that time.
+  UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_YES);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Animation delegate:
 
 void ImmersiveModeControllerAsh::AnimationEnded(
     const ui::Animation* animation) {
   if (reveal_state_ == SLIDING_OPEN) {
     // AnimationProgressed() is called immediately before AnimationEnded()
     // and does a layout.
@@ skipping 72 matching lines @@
   if (force)
     tab_indicator_visibility_ = TAB_INDICATORS_FORCE_HIDE;
   else if (tab_indicator_visibility_ == TAB_INDICATORS_FORCE_HIDE)
     tab_indicator_visibility_ = TAB_INDICATORS_HIDE;
   UpdateUseMinimalChrome(LAYOUT_YES);
 }
 
 void ImmersiveModeControllerAsh::StartRevealForTest(bool hovered) {
   MaybeStartReveal(ANIMATE_NO);
   MoveMouse(top_container_, hovered);
-  UpdateLocatedEventRevealedLock(NULL);
+  UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::SetMouseHoveredForTest(bool hovered) {
   MoveMouse(top_container_, hovered);
-  UpdateLocatedEventRevealedLock(NULL);
+  UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::DisableAnimationsForTest() {
   animations_disabled_for_test_ = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // private:
 
 void ImmersiveModeControllerAsh::EnableWindowObservers(bool enable) {
@@ skipping 94 matching lines @@
   // Timer is stopped when |this| is destroyed, hence Unretained() is safe.
   top_edge_hover_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(
           ImmersiveFullscreenConfiguration::immersive_mode_reveal_delay_ms()),
       base::Bind(&ImmersiveModeControllerAsh::AcquireLocatedEventRevealedLock,
                  base::Unretained(this)));
 }
 
 void ImmersiveModeControllerAsh::UpdateLocatedEventRevealedLock(
-    ui::LocatedEvent* event) {
+    ui::LocatedEvent* event,
+    RevealWhileClosing reveal_while_closing) {
   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_ == SLIDING_CLOSED || reveal_state_ == CLOSED)
+  if (reveal_state_ == CLOSED ||
+      (reveal_state_ == SLIDING_CLOSED &&
+       reveal_while_closing == REVEAL_WHILE_CLOSING_NO)) {
     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;
   }
 
   // Ignore all events while a window has capture. This keeps the top-of-window
   // views revealed during a drag.
@@ skipping 106 matching lines @@
     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);
+      UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_NO);
       UpdateFocusRevealedLock();
     }
   }
   return false;
 }
 
 void ImmersiveModeControllerAsh::UpdateUseMinimalChrome(Layout layout) {
   // May be NULL in tests.
   FullscreenController* fullscreen_controller =
       delegate_->GetFullscreenController();
@@ skipping 115 matching lines @@
 
 void ImmersiveModeControllerAsh::OnSlideOpenAnimationCompleted(Layout layout) {
   DCHECK_EQ(SLIDING_OPEN, reveal_state_);
   reveal_state_ = REVEALED;
 
   if (layout == LAYOUT_YES)
     top_container_->parent()->Layout();
 
   // 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);
+  UpdateLocatedEventRevealedLock(NULL, REVEAL_WHILE_CLOSING_NO);
 }
 
 void ImmersiveModeControllerAsh::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 92 matching lines @@
     aura::Window* transient_child = transient_children[i];
     views::BubbleDelegateView* bubble_delegate =
         AsBubbleDelegate(transient_child);
     if (bubble_delegate &&
         bubble_delegate->anchor_view() &&
         top_container_->Contains(bubble_delegate->anchor_view())) {
       bubble_manager_->StartObserving(transient_child);
     }
   }
 }