mash: Partially migrate WorkspaceController 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_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_layout_manager_observer.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"
 #include "ui/keyboard/keyboard_util.h"
@@ skipping 97 matching lines @@
   WmRootWindowController* root_window_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(RootWindowControllerObserverImpl);
 };
 
 // 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),
       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;
-  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 33 matching lines @@
       return SHELF_AUTO_HIDE;
     case SHELF_AUTO_HIDE_BEHAVIOR_NEVER:
       return SHELF_VISIBLE;
     case SHELF_AUTO_HIDE_ALWAYS_HIDDEN:
       return SHELF_HIDDEN;
   }
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
-  // Bail out early when there is no |workspace_controller_|, which happens
-  // during shutdown after PrepareForShutdown. Also bail before a shelf exists.
-  if (!workspace_controller_ || !shelf_widget_->shelf())
+  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmRootWindowController* controller = shelf_window->GetRootWindowController();

[James Cook, 2016/08/12 01:52:50]

optional: I liked the old name better, |controller| is a bit generic. Up to you.
Maybe this makes the line wrapping better.

[msw, 2016/08/12 04:01:57]

Acknowledged; I'll leave it as-is.

+  // Bail out early before the shelf is initialized or after it is destroyed.
+  if (!controller || !shelf_widget_->shelf() || in_shutdown_)
     return;
 
   if (state_.is_screen_locked || state_.is_adding_user_screen) {
     SetState(SHELF_VISIBLE);
   } else if (WmShell::Get()->IsPinned()) {
     SetState(SHELF_HIDDEN);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
     wm::WorkspaceWindowState window_state(
-        workspace_controller_->GetWindowState());
+        controller->GetWorkspaceWindowState());
     switch (window_state) {
       case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
         if (IsShelfHiddenForFullscreen()) {
           SetState(SHELF_HIDDEN);
         } else {
           // The shelf is sometimes not hidden when in immersive fullscreen.
           // Force the shelf to be auto hidden in this case.
           SetState(SHELF_AUTO_HIDE);
         }
         break;
@@ skipping 203 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 ShelfLayoutManager::TargetBounds::TargetBounds()
     : opacity(0.0f), status_opacity(0.0f) {}
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
-  if (!shelf_widget_->GetNativeView())
-    return;
-
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
-  state.window_state = workspace_controller_
-                           ? workspace_controller_->GetWindowState()
-                           : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
+
+  WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
+  WmRootWindowController* controller = shelf_window->GetRootWindowController();
+  state.window_state = controller ? controller->GetWorkspaceWindowState()
+                                  : wm::WORKSPACE_WINDOW_STATE_DEFAULT;
   // Preserve the log in screen states.
   state.is_adding_user_screen = state_.is_adding_user_screen;
   state.is_screen_locked = state_.is_screen_locked;
 
   // 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);
 
@@ skipping 365 matching lines @@
   else
     show_shelf_region_in_screen.set_width(kMaxAutoHideShowShelfRegionSize);
 
   // 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_widget_ ||

[James Cook, 2016/08/12 01:52:49]

optional: Maybe not needed?

[msw, 2016/08/12 04:01:57]

We can remove these separately.

       !shelf_widget_->shelf())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   const int64_t shelf_display_id = WmLookup::Get()
                                        ->GetWindowForWidget(shelf_widget_)
                                        ->GetDisplayNearestWindow()
                                        .id();
 
   // Unhide the shelf only on the active screen when the AppList is shown
   // (crbug.com/312445).
@@ skipping 82 matching lines @@
        mouse_over_shelf_when_auto_hide_timer_started_) &&
       GetAutoHideShowShelfRegionInScreen().Contains(
           cursor_position_in_screen)) {
     return SHELF_AUTO_HIDE_SHOWN;
   }
 
   return SHELF_AUTO_HIDE_HIDDEN;
 }
 
 bool ShelfLayoutManager::IsShelfWindow(WmWindow* window) {
   if (!window || !shelf_widget_)

[James Cook, 2016/08/12 01:52:49]

optional: I also wondered if this one was needed.

[msw, 2016/08/12 04:01:57]

We can remove these separately.

     return false;
   WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
   WmWindow* status_window =
       WmLookup::Get()->GetWindowForWidget(shelf_widget_->status_area_widget());
   return (shelf_window && shelf_window->Contains(window)) ||
          (status_window && status_window->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaInsets(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
@@ skipping 127 matching lines @@
                                        gesture.details().velocity_x() < 0);
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
   if (shelf_widget_) {

[James Cook, 2016/08/12 01:52:50]

optional: This one too.

[msw, 2016/08/12 04:01:57]

We can remove these separately.

     shelf_widget_->Deactivate();
     shelf_widget_->status_area_widget()->Deactivate();
   }
   gesture_drag_auto_hide_state_ =
       gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN
           ? SHELF_AUTO_HIDE_HIDDEN
           : SHELF_AUTO_HIDE_SHOWN;
   ShelfAutoHideBehavior new_auto_hide_behavior =
       gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN
           ? SHELF_AUTO_HIDE_BEHAVIOR_NEVER
@@ skipping 12 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