Prevent a user from hiding the shelf via a gesture when there are no visible windows part 2

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 <cstring>
 #include <string>
@@ skipping 18 matching lines @@
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "ui/aura/client/activation_client.h"
+#include "ui/aura/client/cursor_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_handler.h"
 #include "ui/base/ui_base_switches.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/gfx/screen.h"
 #include "ui/views/widget/widget.h"
@@ skipping 140 matching lines @@
   // Shelf we're in. NULL if deleted before we're deleted.
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
     : root_window_(shelf->GetNativeView()->GetRootWindow()),
-      in_layout_(false),
+      updating_bounds_(false),
       auto_hide_behavior_(SHELF_AUTO_HIDE_BEHAVIOR_NEVER),
       alignment_(SHELF_ALIGNMENT_BOTTOM),
       shelf_(shelf),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
       mouse_over_shelf_when_auto_hide_timer_started_(false),
       bezel_event_filter_(new ShelfBezelEventFilter(this)),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
@@ skipping 54 matching lines @@
   int width = 0, height = 0;
   GetShelfSize(&width, &height);
   return SelectValueForShelfAlignment(
       gfx::Rect(bounds.x(), bounds.bottom() - height, bounds.width(), height),
       gfx::Rect(bounds.x(), bounds.y(), width, bounds.height()),
       gfx::Rect(bounds.right() - width, bounds.y(), width, bounds.height()),
       gfx::Rect(bounds.x(), bounds.y(), bounds.width(), height));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
-  base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
-  StopAnimating();
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
-  GetLayer(shelf_)->SetOpacity(target_bounds.opacity);
-  shelf_->SetWidgetBounds(
-      ScreenAsh::ConvertRectToScreen(
-          shelf_->GetNativeView()->parent(),
-          target_bounds.shelf_bounds_in_root));
-  if (shelf_->launcher())
+  UpdateBoundsAndOpacity(target_bounds, false, NULL);
+
+  if (shelf_->launcher()) {
+    // This is not part of UpdateBoundsAndOpacity() because
+    // SetLauncherViewBounds() sets the bounds immediately and does not animate.
+    // The height of the LauncherView for a horizontal shelf and the width of
+    // the LauncherView for a vertical shelf are set when |shelf_|'s bounds
+    // are changed via UpdateBoundsAndOpacity(). This sets the origin and the
+    // dimension in the other direction.
     shelf_->launcher()->SetLauncherViewBounds(
         target_bounds.launcher_bounds_in_shelf);
-  GetLayer(shelf_->status_area_widget())->SetOpacity(
-      target_bounds.status_opacity);
-  // TODO(harrym): Once status area widget is a child view of shelf
-  // this can be simplified.
-  gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
-  status_bounds.set_x(status_bounds.x() +
-                      target_bounds.shelf_bounds_in_root.x());
-  status_bounds.set_y(status_bounds.y() +
-                      target_bounds.shelf_bounds_in_root.y());
-  shelf_->status_area_widget()->SetBounds(
-      ScreenAsh::ConvertRectToScreen(
-          shelf_->status_area_widget()->GetNativeView()->parent(),
-          status_bounds));
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      root_window_, target_bounds.work_area_insets);
-  UpdateHitTestBounds();
+  }
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
   switch(auto_hide_behavior_) {
     case SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS:
       return SHELF_AUTO_HIDE;
     case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       return SHELF_VISIBLE;
     case SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
       return SHELF_HIDDEN;
@@ skipping 161 matching lines @@
   // In fullscreen with minimal chrome, the auto hide behavior affects neither
   // the visibility state nor the auto hide state. Set |gesture_drag_status_|
   // to GESTURE_DRAG_COMPLETE_IN_PROGRESS to set the auto hide state to
   // |gesture_drag_auto_hide_state_|.
   gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
   if (auto_hide_behavior_ != new_auto_hide_behavior)
     SetAutoHideBehavior(new_auto_hide_behavior);
   else
     UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
-  LayoutShelf();
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
+  gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
+  UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
-  ui::ScopedLayerAnimationSettings
-      launcher_settings(GetLayer(shelf_)->GetAnimator()),
-      status_settings(GetLayer(shelf_->status_area_widget())->GetAnimator());
-  LayoutShelf();
-  UpdateVisibilityState();
-  UpdateShelfBackground(BackgroundAnimator::CHANGE_ANIMATE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, aura::LayoutManager implementation:
 
 void ShelfLayoutManager::OnWindowResized() {
   LayoutShelf();
 }
 
 void ShelfLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
 }
 
 void ShelfLayoutManager::OnWillRemoveWindowFromLayout(aura::Window* child) {
 }
 
 void ShelfLayoutManager::OnWindowRemovedFromLayout(aura::Window* child) {
 }
 
 void ShelfLayoutManager::OnChildWindowVisibilityChanged(aura::Window* child,
                                                         bool visible) {
 }
 
 void ShelfLayoutManager::SetChildBounds(aura::Window* child,
                                         const gfx::Rect& requested_bounds) {
   SetChildBoundsDirect(child, requested_bounds);
   // We may contain other widgets (such as frame maximize bubble) but they don't
   // effect the layout in anyway.
-  if (!in_layout_ &&
+  if (!updating_bounds_ &&
       ((shelf_->GetNativeView() == child) ||
        (shelf_->status_area_widget()->GetNativeView() == child))) {
     LayoutShelf();
   }
 }
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   UpdateVisibilityState();
 }
 
@@ skipping 36 matching lines @@
     return;
 
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
   state.is_screen_locked =
       Shell::GetInstance()->session_state_delegate()->IsScreenLocked();
   state.window_state = workspace_controller_ ?
       workspace_controller_->GetWindowState() : WORKSPACE_WINDOW_STATE_DEFAULT;
 
-  if (state_.Equals(state))
+  // Force an update because gesture drags affect the shelf bounds and we
+  // should animate back to the normal bounds at the end of a gesture.
+  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));
 
   if (state.visibility_state == SHELF_AUTO_HIDE) {
     // When state is SHELF_AUTO_HIDE we need to track when the mouse is over the
     // launcher to unhide the shelf. 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;
-  TargetBounds target_bounds;
-  CalculateTargetBounds(state_, &target_bounds);
-
-  ui::ScopedLayerAnimationSettings launcher_animation_setter(
-      GetLayer(shelf_)->GetAnimator());
-  launcher_animation_setter.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
-  launcher_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
-  launcher_animation_setter.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-  GetLayer(shelf_)->SetBounds(
-      target_bounds.shelf_bounds_in_root);
-  GetLayer(shelf_)->SetOpacity(target_bounds.opacity);
-  ui::ScopedLayerAnimationSettings status_animation_setter(
-      GetLayer(shelf_->status_area_widget())->GetAnimator());
-  status_animation_setter.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
-  status_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
-  status_animation_setter.SetPreemptionStrategy(
-      ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   BackgroundAnimator::ChangeType change_type =
       BackgroundAnimator::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
   //   in maximized mode.
   // - Going from an auto hidden shelf in maximized mode to a visible shelf in
   //   maximized mode.
   if (state.visibility_state == SHELF_VISIBLE &&
       state.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED &&
       old_state.visibility_state != SHELF_VISIBLE) {
     change_type = BackgroundAnimator::CHANGE_IMMEDIATE;
   } else {
     // Delay the animation when the shelf was hidden, and has just been made
     // visible (e.g. using a gesture-drag).
     if (state.visibility_state == SHELF_VISIBLE &&
         old_state.visibility_state == SHELF_AUTO_HIDE &&
         old_state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
       delay_background_change = true;
     }
   }
 
   if (delay_background_change) {
     if (update_shelf_observer_)
       update_shelf_observer_->Detach();
     // UpdateShelfBackground deletes itself when the animation is done.
     update_shelf_observer_ = new UpdateShelfObserver(this);
-    status_animation_setter.AddObserver(update_shelf_observer_);
   } else {
     UpdateShelfBackground(change_type);
   }
 
   shelf_->SetDimsShelf(
       state.visibility_state == SHELF_VISIBLE &&
       state.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
-  ui::Layer* layer = GetLayer(shelf_->status_area_widget());
-  // TODO(harrym): Remove when status_area is view (crbug.com/180422).
-  gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
-  status_bounds.set_x(status_bounds.x() +
-                      target_bounds.shelf_bounds_in_root.x());
-  status_bounds.set_y(status_bounds.y() +
-                      target_bounds.shelf_bounds_in_root.y());
-  layer->SetBounds(status_bounds);
-  layer->SetOpacity(target_bounds.status_opacity);
-  Shell::GetInstance()->SetDisplayWorkAreaInsets(
-      root_window_, target_bounds.work_area_insets);
-  UpdateHitTestBounds();
+  TargetBounds target_bounds;
+  CalculateTargetBounds(state_, &target_bounds);
+  UpdateBoundsAndOpacity(target_bounds, true,
+      delay_background_change ? update_shelf_observer_ : NULL);
 
   // OnAutoHideStateChanged Should be emitted when:
   //  - firstly state changed to auto-hide from other state
   //  - or, auto_hide_state has changed
   if ((old_state.visibility_state != state_.visibility_state &&
        state_.visibility_state == SHELF_AUTO_HIDE) ||
       old_state.auto_hide_state != state_.auto_hide_state) {
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                       OnAutoHideStateChanged(state_.auto_hide_state));
   }
 }
 
+void ShelfLayoutManager::UpdateBoundsAndOpacity(
+    const TargetBounds& target_bounds,
+    bool animate,
+    ui::ImplicitAnimationObserver* observer) {
+  base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
+
+  ui::ScopedLayerAnimationSettings launcher_animation_setter(
+      GetLayer(shelf_)->GetAnimator());
+  ui::ScopedLayerAnimationSettings status_animation_setter(
+      GetLayer(shelf_->status_area_widget())->GetAnimator());
+  if (animate) {
+    launcher_animation_setter.SetTransitionDuration(
+        base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
+    launcher_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
+    launcher_animation_setter.SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+    status_animation_setter.SetTransitionDuration(
+        base::TimeDelta::FromMilliseconds(kCrossFadeDurationMS));
+    status_animation_setter.SetTweenType(ui::Tween::EASE_OUT);
+    status_animation_setter.SetPreemptionStrategy(
+        ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
+  } else {
+    StopAnimating();
+    launcher_animation_setter.SetTransitionDuration(base::TimeDelta());
+    status_animation_setter.SetTransitionDuration(base::TimeDelta());
+  }
+  if (observer)
+    status_animation_setter.AddObserver(observer);
+
+  GetLayer(shelf_)->SetOpacity(target_bounds.opacity);
+  shelf_->SetBounds(ScreenAsh::ConvertRectToScreen(
+       shelf_->GetNativeView()->parent(),
+       target_bounds.shelf_bounds_in_root));
+
+  GetLayer(shelf_->status_area_widget())->SetOpacity(
+      target_bounds.status_opacity);
+  // TODO(harrym): Once status area widget is a child view of shelf
+  // this can be simplified.
+  gfx::Rect status_bounds = target_bounds.status_bounds_in_shelf;
+  status_bounds.set_x(status_bounds.x() +
+                      target_bounds.shelf_bounds_in_root.x());
+  status_bounds.set_y(status_bounds.y() +
+                      target_bounds.shelf_bounds_in_root.y());
+  shelf_->status_area_widget()->SetBounds(
+      ScreenAsh::ConvertRectToScreen(
+          shelf_->status_area_widget()->GetNativeView()->parent(),
+          status_bounds));
+  Shell::GetInstance()->SetDisplayWorkAreaInsets(
+      root_window_, target_bounds.work_area_insets);
+  UpdateHitTestBounds();
+}
+
 void ShelfLayoutManager::StopAnimating() {
   GetLayer(shelf_)->GetAnimator()->StopAnimating();
   GetLayer(shelf_->status_area_widget())->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::GetShelfSize(int* width, int* height) {
   *width = *height = 0;
   gfx::Size status_size(
       shelf_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
@@ skipping 258 matching lines @@
   // TODO: Figure out if we need any special handling when the keyboard is
   // visible.
   return show_shelf_region_in_screen;
 }
 
 ShelfAutoHideState ShelfLayoutManager::CalculateAutoHideState(
     ShelfVisibilityState visibility_state) const {
   if (visibility_state != SHELF_AUTO_HIDE || !shelf_)
     return SHELF_AUTO_HIDE_HIDDEN;
 
-  if (gesture_drag_status_ == GESTURE_DRAG_COMPLETE_IN_PROGRESS)
-    return gesture_drag_auto_hide_state_;
-
   Shell* shell = Shell::GetInstance();
   if (shell->GetAppListTargetVisibility())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->status_area_widget() &&
       shelf_->status_area_widget()->ShouldShowLauncher())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->launcher() && shelf_->launcher()->IsShowingMenu())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->launcher() && shelf_->launcher()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->IsActive() || shelf_->status_area_widget()->IsActive())
     return SHELF_AUTO_HIDE_SHOWN;
 
+  const std::vector<aura::Window*> windows =
+      ash::MruWindowTracker::BuildWindowList(false);
+
+  // Process the window list and check if there are any visible windows.
+  bool visible_window = false;
+  for (size_t i = 0; i < windows.size(); ++i) {
+    if (windows[i] && windows[i]->IsVisible() &&
+        !ash::wm::IsWindowMinimized(windows[i]) &&
+        root_window_ == windows[i]->GetRootWindow()) {
+      visible_window = true;
+      break;
+    }
+  }
+  // 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())
     return SHELF_AUTO_HIDE_HIDDEN;
 
+  // Ignore the mouse position if mouse events are disabled.
+  aura::client::CursorClient* cursor_client = aura::client::GetCursorClient(
+      shelf_->GetNativeWindow()->GetRootWindow());
+  if (!cursor_client->IsMouseEventsEnabled())
+    return SHELF_AUTO_HIDE_HIDDEN;

[sadrul, 2013/08/13 17:21:34]

This parts are from another CL, right?

[pkotwicz, 2013/08/14 17:03:21]

That CL has now landed, rebasing is easier :)

+
   gfx::Rect shelf_region = shelf_->GetWindowBoundsInScreen();
   if (shelf_->status_area_widget() &&
       shelf_->status_area_widget()->IsMessageBubbleShown() &&
       IsVisible()) {
     // Increase the the hit test area to prevent the shelf from disappearing
     // when the mouse is over the bubble gap.
     shelf_region.Inset(alignment_ == SHELF_ALIGNMENT_RIGHT ?
                            -kNotificationBubbleGapHeight : 0,
                        alignment_ == SHELF_ALIGNMENT_BOTTOM ?
                            -kNotificationBubbleGapHeight : 0,
@@ skipping 20 matching lines @@
   // shelf slightly to make it easier to show the shelf in this situation. We
   // do not check |auto_hide_timer_|.IsRunning() because it returns false when
   // the timer's task is running.
   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;
   }
 
-  const std::vector<aura::Window*> windows =
-      ash::MruWindowTracker::BuildWindowList(false);
-
-  // Process the window list and check if there are any visible windows.
-  for (size_t i = 0; i < windows.size(); ++i) {
-    if (windows[i] && windows[i]->IsVisible() &&
-        !ash::wm::IsWindowMinimized(windows[i]) &&
-        root_window_ == windows[i]->GetRootWindow())
-      return SHELF_AUTO_HIDE_HIDDEN;
-  }
-
-  // If there are no visible windows do not hide the shelf.
-  return SHELF_AUTO_HIDE_SHOWN;
+  return SHELF_AUTO_HIDE_HIDDEN;
 }
 
 void ShelfLayoutManager::UpdateHitTestBounds() {
   gfx::Insets mouse_insets;
   gfx::Insets touch_insets;
   if (state_.visibility_state == SHELF_VISIBLE) {
     // Let clicks at the very top of the launcher through so windows can be
     // resized with the bottom-right corner and bottom edge.
     mouse_insets = GetInsetsForAlignment(kWorkspaceAreaVisibleInset);
   } else if (state_.visibility_state == SHELF_AUTO_HIDE) {
@@ skipping 55 matching lines @@
       return gfx::Insets(0, distance, 0, 0);
     case SHELF_ALIGNMENT_TOP:
       return gfx::Insets(0, 0, distance, 0);
   }
   NOTREACHED();
   return gfx::Insets();
 }
 
 }  // namespace internal
 }  // namespace ash