Move MaximizeModeWindowManager to the controller

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>
 #include <vector>
 
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/session/session_state_delegate.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_bezel_event_filter.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/lock_state_controller.h"
+#include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.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/cursor_client.h"
 #include "ui/aura/window_event_dispatcher.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"
@@ skipping 136 matching lines @@
   ShelfLayoutManager* shelf_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateShelfObserver);
 };
 
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
     : root_window_(shelf->GetNativeView()->GetRootWindow()),
       updating_bounds_(false),
-      force_shelf_always_visibile_(
-          Shell::GetInstance()->IsMaximizeModeWindowManagerEnabled()),
       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 86 matching lines @@
     // The height of the ShelfView for a horizontal shelf and the width of
     // the ShelfView 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_->shelf()->SetShelfViewBounds(
         target_bounds.shelf_bounds_in_shelf);
   }
 }
 
 ShelfVisibilityState ShelfLayoutManager::CalculateShelfVisibility() {
-  switch(auto_hide_behavior_) {
+  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;
   }
   return SHELF_VISIBLE;
 }
 
@@ skipping 244 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;
   shelf_->SetAlignment(locked ? SHELF_ALIGNMENT_BOTTOM : alignment_);
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 void ShelfLayoutManager::OnMaximizeModeStarted() {
-  DCHECK(!force_shelf_always_visibile_);
-  force_shelf_always_visibile_ = true;
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnMaximizeModeEnded() {
-  DCHECK(force_shelf_always_visibile_);
-  // Note: At this time Ash::Shell::IsMaximizeModeWindowManagerEnabled() will
-  // report true, even though it is in progress of shut down. To address this
-  // |force_shelf_always_visibile_| will be read.
-  force_shelf_always_visibile_ = false;
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::OnWindowActivated(aura::Window* gained_active,
                                            aura::Window* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 bool ShelfLayoutManager::IsHorizontalAlignment() const {
   return GetAlignment() == SHELF_ALIGNMENT_BOTTOM ||
@@ skipping 211 matching lines @@
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     if (IsHorizontalAlignment())
       shelf_height = kAutoHideSize;
     else
       shelf_width = kAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
-      (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()))
-  {
+      (!keyboard_bounds_.IsEmpty() &&
+       !keyboard::IsKeyboardOverscrollEnabled())) {
     if (IsHorizontalAlignment())
       shelf_height = 0;
     else
       shelf_width = 0;
   }
 
   int bottom_shelf_vertical_offset = available_bounds.bottom();
   if (keyboard_bounds_.IsEmpty())
     bottom_shelf_vertical_offset -= shelf_height;
   else
@@ skipping 314 matching lines @@
 
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 bool ShelfLayoutManager::IsShelfForcedToBeVisible() const {
+  bool force_shelf_always_visibile = Shell::GetInstance()->
+      maximize_mode_controller()->IsMaximizeModeWindowManagerEnabled();
   // Bail out early when there is no |workspace_controller_|, which happens
   // during shutdown after PrepareForShutdown.
   if (!workspace_controller_)
-    return force_shelf_always_visibile_;
+    return force_shelf_always_visibile;
 
-  return force_shelf_always_visibile_ &&
+  return force_shelf_always_visibile &&
       workspace_controller_->GetWindowState() !=
           WORKSPACE_WINDOW_STATE_FULL_SCREEN;
 }
 
 void ShelfLayoutManager::OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) {
   bool keyboard_is_about_to_hide = false;
   if (new_bounds.IsEmpty() && !keyboard_bounds_.IsEmpty())
     keyboard_is_about_to_hide = true;
 
   keyboard_bounds_ = new_bounds;
@@ skipping 34 matching lines @@
 
 void ShelfLayoutManager::SessionStateChanged(
     SessionStateDelegate::SessionState state) {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 }  // namespace ash