mash: Preliminary support for shelf auto-hide

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 82 matching lines @@
 const int ShelfLayoutManager::kWorkspaceAreaAutoHideInset = 5;
 
 // static
 const int ShelfLayoutManager::kAutoHideSize = 3;
 
 // static
 const int ShelfLayoutManager::kShelfItemInset = 3;
 
 // ShelfLayoutManager::AutoHideEventFilter -------------------------------------
 
-// Notifies ShelfLayoutManager any time the mouse moves.
+// Notifies ShelfLayoutManager any time the mouse moves. Not used on mash.
+// TODO(jamescook): Delete this once the mash implementation handles drags on
+// and off the shelf.
 class ShelfLayoutManager::AutoHideEventFilter : public ui::EventHandler {
  public:
   explicit AutoHideEventFilter(ShelfLayoutManager* shelf);
   ~AutoHideEventFilter() override;
 
   // Returns true if the last mouse event was a mouse drag.
   bool in_mouse_drag() const { return in_mouse_drag_; }
 
   // Overridden from ui::EventHandler:
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
 
  private:
   ShelfLayoutManager* shelf_;
   bool in_mouse_drag_;
-  ShelfGestureHandler gesture_handler_;
   DISALLOW_COPY_AND_ASSIGN(AutoHideEventFilter);
 };
 
 ShelfLayoutManager::AutoHideEventFilter::AutoHideEventFilter(
     ShelfLayoutManager* shelf)
     : shelf_(shelf),
       in_mouse_drag_(false) {
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 ShelfLayoutManager::AutoHideEventFilter::~AutoHideEventFilter() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
   // This also checks IsShelfWindow() to make sure we don't attempt to hide the
   // shelf if the mouse down occurs on the shelf.
   in_mouse_drag_ = (event->type() == ui::ET_MOUSE_DRAGGED ||
                     (in_mouse_drag_ && event->type() != ui::ET_MOUSE_RELEASED &&
                      event->type() != ui::ET_MOUSE_CAPTURE_CHANGED)) &&
       !shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()));
-  if (event->type() == ui::ET_MOUSE_MOVED)
-    shelf_->UpdateAutoHideState();
-  return;
+  shelf_->UpdateAutoHideForMouseEvent(event);
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
-  aura::Window* target_window = static_cast<aura::Window*>(event->target());
-  if (shelf_->IsShelfWindow(target_window)) {
-    if (gesture_handler_.ProcessGestureEvent(*event, target_window))
-      event->StopPropagation();
-  }
+  shelf_->UpdateAutoHideForGestureEvent(event);
 }
 
 // ShelfLayoutManager:UpdateShelfObserver --------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
@@ skipping 121 matching lines @@
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   gfx::Rect rect(ScreenUtil::GetDisplayBoundsInParent(shelf_->GetNativeView()));
   return SelectValueForShelfAlignment(
       gfx::Rect(rect.x(), rect.bottom() - kShelfSize, rect.width(), kShelfSize),
       gfx::Rect(rect.x(), rect.y(), kShelfSize, rect.height()),
       gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize,
                 rect.height()));
 }
 
+gfx::Size ShelfLayoutManager::GetPreferredSize() {
+  TargetBounds target_bounds;
+  CalculateTargetBounds(state_, &target_bounds);
+  return target_bounds.shelf_bounds_in_root.size();
+}
+
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
   // Update insets in ShelfWindowTargeter when shelf bounds change.
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state()));
 }
 
@@ skipping 67 matching lines @@
       auto_hide_timer_.Start(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kAutoHideDelayMS),
           this, &ShelfLayoutManager::UpdateAutoHideStateNow);
     }
   } else {
     StopAutoHideTimer();
   }
 }
 
+void ShelfLayoutManager::UpdateAutoHideForMouseEvent(ui::MouseEvent* event) {
+  // Don't update during shutdown because synthetic mouse events (e.g. mouse
+  // exit) may be generate during status area widget teardown.

[msw, 2016/05/24 20:46:55]

nit: generated

[James Cook, 2016/05/25 00:25:43]

Whoops! Done.

+  if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)

[msw, 2016/05/24 20:46:55]

q: Where is |in_shutdown_| declared and set?

[James Cook, 2016/05/25 00:25:43]

Declared in the header, set in PrepareForShutdown(). It was added in the earlier
CL in the dependency chain.

However, as part of review feedback there I took it out and re-added it in this
CL, so the diff should be a little clearer after this latest rebase.

+    return;
+
+  if (event->type() == ui::ET_MOUSE_MOVED ||
+      event->type() == ui::ET_MOUSE_ENTERED ||
+      event->type() == ui::ET_MOUSE_EXITED)
+    UpdateAutoHideState();
+}
+
+void ShelfLayoutManager::UpdateAutoHideForGestureEvent(
+    ui::GestureEvent* event) {
+  if (visibility_state() != SHELF_AUTO_HIDE || in_shutdown_)
+    return;
+
+  aura::Window* target_window = static_cast<aura::Window*>(event->target());
+  if (IsShelfWindow(target_window)) {
+    if (gesture_handler_.ProcessGestureEvent(*event, target_window))
+      event->StopPropagation();
+  }
+}
+
 void ShelfLayoutManager::SetWindowOverlapsShelf(bool value) {
   window_overlaps_shelf_ = value;
   UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
 }
 
 void ShelfLayoutManager::AddObserver(ShelfLayoutManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfLayoutManager::RemoveObserver(ShelfLayoutManagerObserver* observer) {
@@ skipping 184 matching lines @@
   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
-    // shelf to unhide it. 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);
+  // mash does not support global event handlers. It uses events on the shelf
+  // and status area widgets to update auto-hide.
+  if (!Shell::GetInstance()->in_mus()) {
+    if (state.visibility_state == SHELF_AUTO_HIDE) {
+      // When state is SHELF_AUTO_HIDE we need to track when the mouse is over
+      // the shelf to unhide it. 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;
 
   BackgroundAnimatorChangeType change_type = BACKGROUND_CHANGE_ANIMATE;
   bool delay_background_change = false;
 
@@ skipping 27 matching lines @@
 
   shelf_->SetDimsShelf(state.visibility_state == SHELF_VISIBLE &&
                        state.window_state ==
                            wm::WORKSPACE_WINDOW_STATE_MAXIMIZED);
 
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true,
       delay_background_change ? update_shelf_observer_ : NULL);
 
+  // These observers must be notified after |state_| is updated so that they can
+  // query the new target bounds.
+  if (old_state.visibility_state != state_.visibility_state) {
+    FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
+                      DidChangeVisibilityState(this, state_.visibility_state));
+  }
+
   // 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));
+                      OnAutoHideStateChanged(this, 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 shelf_animation_setter(
@@ skipping 258 matching lines @@
 
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimatorChangeType type) {
   const wm::ShelfBackgroundType background_type(GetShelfBackgroundType());
   shelf_->SetPaintsBackground(background_type, type);
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnBackgroundUpdated(background_type, type));
 }
 
 wm::ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
+  // TODO(jamescook): Get maximized window state from the window manager.
+  if (Shell::GetInstance()->in_mus())

[msw, 2016/05/24 20:46:55]

q: Do we actually need this early return? What happens if you fall through?

[James Cook, 2016/05/25 00:25:43]

Good catch, we don't really need this.

+    return wm::SHELF_BACKGROUND_DEFAULT;
+
   if (state_.visibility_state != SHELF_AUTO_HIDE &&
       state_.window_state == wm::WORKSPACE_WINDOW_STATE_MAXIMIZED) {
     return wm::SHELF_BACKGROUND_MAXIMIZED;
   }
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
       (!state_.is_screen_locked && !state_.is_adding_user_screen &&
        window_overlaps_shelf_) ||
       (state_.visibility_state == SHELF_AUTO_HIDE)) {
     return wm::SHELF_BACKGROUND_OVERLAP;
@@ skipping 58 matching lines @@
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->shelf() && shelf_->shelf()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->IsActive() ||
       (shelf_->status_area_widget() &&
        shelf_->status_area_widget()->IsActive()))
     return SHELF_AUTO_HIDE_SHOWN;
 
-  const std::vector<aura::Window*> windows =
-      shell->mru_window_tracker()->BuildWindowListIgnoreModal();
+  // TODO(jamescook): Track visible windows on mash via ShelfDelegate.
+  if (!Shell::GetInstance()->in_mus()) {
+    const std::vector<aura::Window*> windows =
+        shell->mru_window_tracker()->BuildWindowListIgnoreModal();
 
-  // 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() &&
-        !wm::GetWindowState(windows[i])->IsMinimized() &&
-        root_window_ == windows[i]->GetRootWindow()) {
-      visible_window = true;
-      break;
+    // 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() &&
+          !wm::GetWindowState(windows[i])->IsMinimized() &&
+          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 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(
@@ skipping 118 matching lines @@
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 }  // namespace ash