mash: Migrate some misc ShelfLayoutManager deps to ash common.

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 <vector>
 
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_delegate.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/shell_window_ids.h"
 #include "ash/common/system/status_area_widget.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/mru_window_tracker.h"
+#include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_root_window_controller.h"
 #include "ash/common/wm_root_window_controller_observer.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/shelf/shelf.h"
-#include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
-#include "ash/shell.h"

[James Cook, 2016/08/11 00:50:06]

hooray!

[msw, 2016/08/11 02:08:51]

Acknowledged.

-#include "ash/wm/window_animations.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "base/i18n/rtl.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/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
@@ skipping 98 matching lines @@
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf_widget)
     : updating_bounds_(false),
       shelf_widget_(shelf_widget),
       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),
       update_shelf_observer_(NULL),
       chromevox_panel_height_(0),
       duration_override_in_ms_(0),
       root_window_controller_observer_(
           new RootWindowControllerObserverImpl(this)) {
   WmShell::Get()->AddShellObserver(this);
   WmShell::Get()->AddLockStateObserver(this);
   WmShell::Get()->AddActivationObserver(this);
   WmShell::Get()->GetSessionStateDelegate()->AddSessionStateObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
     update_shelf_observer_->Detach();
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillDeleteShelfLayoutManager());
   WmShell::Get()->RemoveShellObserver(this);
   WmShell::Get()->RemoveLockStateObserver(this);
   WmShell::Get()->GetSessionStateDelegate()->RemoveSessionStateObserver(this);
 }
 
 void ShelfLayoutManager::PrepareForShutdown() {
   in_shutdown_ = true;
-  // Clear all event filters, otherwise sometimes those filters may catch
-  // synthesized mouse event and cause crashes during the shutdown.
-  set_workspace_controller(NULL);
-  bezel_event_filter_.reset();
+  set_workspace_controller(nullptr);
   // Stop observing changes to avoid updating a partially destructed shelf.
   WmShell::Get()->RemoveActivationObserver(this);
 }
 
 bool ShelfLayoutManager::IsVisible() const {
   // status_area_widget() may be NULL during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
           (state_.visibility_state == SHELF_AUTO_HIDE &&
@@ skipping 203 matching lines @@
   }
 }
 
 void ShelfLayoutManager::OnLockStateChanged(bool locked) {
   // Force the shelf to layout for alignment (bottom if locked, restore
   // the previous alignment otherwise).
   state_.is_screen_locked = locked;
   UpdateShelfVisibilityAfterLoginUIChange();
 }
 
-void ShelfLayoutManager::OnShelfAlignmentChanged(WmWindow* root_window) {
-  if (Shell::GetInstance()->in_mus())
-    LayoutShelf();
-}
-
 void ShelfLayoutManager::OnShelfAutoHideBehaviorChanged(WmWindow* root_window) {
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnPinnedStateChanged(WmWindow* pinned_window) {
   // Shelf needs to be hidden on entering to pinned mode, or restored
   // on exiting from pinned mode.
   UpdateVisibilityState();
 }
 
@@ skipping 149 matching lines @@
     bool animate,
     ui::ImplicitAnimationObserver* observer) {
   base::AutoReset<bool> auto_reset_updating_bounds(&updating_bounds_, true);
   {
     ui::ScopedLayerAnimationSettings shelf_animation_setter(
         GetLayer(shelf_widget_)->GetAnimator());
     ui::ScopedLayerAnimationSettings status_animation_setter(
         GetLayer(shelf_widget_->status_area_widget())->GetAnimator());
     if (animate) {
       int duration = duration_override_in_ms_ ? duration_override_in_ms_
-                                              : kCrossFadeDurationMS;
+                                              : wm::kCrossFadeDurationMS;
       shelf_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       shelf_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       shelf_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       status_animation_setter.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(duration));
       status_animation_setter.SetTweenType(gfx::Tween::EASE_OUT);
       status_animation_setter.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     } else {
       StopAnimating();
       shelf_animation_setter.SetTransitionDuration(base::TimeDelta());
       status_animation_setter.SetTransitionDuration(base::TimeDelta());
     }
     if (observer)
       status_animation_setter.AddObserver(observer);
 
     GetLayer(shelf_widget_)->SetOpacity(target_bounds.opacity);
-    // mash::wm::ShelfLayout manages window bounds when running in mash.
-    if (!Shell::GetInstance()->in_mus()) {
-      WmWindow* window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
-      shelf_widget_->SetBounds(window->GetParent()->ConvertRectToScreen(
-          target_bounds.shelf_bounds_in_root));
-    }
+    WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+    shelf_widget_->SetBounds(shelf_window->GetParent()->ConvertRectToScreen(
+        target_bounds.shelf_bounds_in_root));
 
     GetLayer(shelf_widget_->status_area_widget())
         ->SetOpacity(target_bounds.status_opacity);
 
     // Having a window which is visible but does not have an opacity is an
     // illegal state. We therefore hide the shelf here if required.
     if (!target_bounds.status_opacity)
       shelf_widget_->status_area_widget()->Hide();
     // Setting visibility during an animation causes the visibility property to
     // animate. Override the animation settings to immediately set the
     // visibility property. Opacity will still animate.
 
     // 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.Offset(target_bounds.shelf_bounds_in_root.OffsetFromOrigin());
-    // mash::wm::ShelfLayout manages window bounds when running mash.
-    if (!Shell::GetInstance()->in_mus()) {
-      WmWindow* window = WmLookup::Get()->GetWindowForWidget(
-          shelf_widget_->status_area_widget());
-      shelf_widget_->status_area_widget()->SetBounds(
-          window->GetParent()->ConvertRectToScreen(status_bounds));
-    }
+    WmWindow* status_window = WmLookup::Get()->GetWindowForWidget(
+        shelf_widget_->status_area_widget());
+    shelf_widget_->status_area_widget()->SetBounds(
+        status_window->GetParent()->ConvertRectToScreen(status_bounds));
+
     // For crbug.com/622431, when the shelf alignment is BOTTOM_LOCKED, we
     // don't set display work area, as it is not real user-set alignment.
     if (!state_.is_screen_locked &&
         shelf_widget_->GetAlignment() != SHELF_ALIGNMENT_BOTTOM_LOCKED) {
       gfx::Insets insets;
       // If user session is blocked (login to new user session or add user to
       // the existing session - multi-profile) then give 100% of work area only
       // if keyboard is not shown.
       if (!state_.is_adding_user_screen || !keyboard_bounds_.IsEmpty())
         insets = target_bounds.work_area_insets;
-      WmWindow* window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
-      WmShell::Get()->SetDisplayWorkAreaInsets(window, insets);
+      WmShell::Get()->SetDisplayWorkAreaInsets(shelf_window, insets);
     }
   }
 
   // Set an empty border to avoid the shelf view and status area overlapping.
   // TODO(msw): Avoid setting bounds of views within the shelf widget here.
   gfx::Rect shelf_bounds = gfx::Rect(target_bounds.shelf_bounds_in_root.size());
   shelf_widget_->GetContentsView()->SetBorder(views::Border::CreateEmptyBorder(
       shelf_bounds.InsetsFrom(target_bounds.shelf_bounds_in_shelf)));
   shelf_widget_->GetContentsView()->Layout();
 
@@ skipping 250 matching lines @@
 
   if (shelf_widget_->shelf() &&
       shelf_widget_->shelf()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_widget_->IsActive() ||
       (shelf_widget_->status_area_widget() &&
        shelf_widget_->status_area_widget()->IsActive()))
     return SHELF_AUTO_HIDE_SHOWN;
 
-  // TODO(jamescook): Track visible windows on mash via ShelfDelegate.
-  if (!Shell::GetInstance()->in_mus()) {
-    const std::vector<WmWindow*> windows =
-        WmShell::Get()->mru_window_tracker()->BuildWindowListIgnoreModal();
+  const std::vector<WmWindow*> windows =
+      WmShell::Get()->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() &&
-          !windows[i]->GetWindowState()->IsMinimized() &&
-          windows[i]->GetDisplayNearestWindow().id() == shelf_display_id) {
-        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() &&
+        !windows[i]->GetWindowState()->IsMinimized() &&
+        windows[i]->GetDisplayNearestWindow().id() == shelf_display_id) {
+      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 (in_mouse_drag_)
     return SHELF_AUTO_HIDE_HIDDEN;
 
   // Ignore the mouse position if mouse events are disabled.
   if (!shelf_widget_->IsMouseEventsEnabled())
@@ skipping 215 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash