Removes most of aura dependencies from DefaultState

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 261 matching lines @@
   // 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_->shelf())
     return;
 
   if (state_.is_screen_locked || state_.is_adding_user_screen) {
     SetState(SHELF_VISIBLE);
   } else {
     // TODO(zelidrag): Verify shelf drag animation still shows on the device
     // when we are in SHELF_AUTO_HIDE_ALWAYS_HIDDEN.
-    WorkspaceWindowState window_state(workspace_controller_->GetWindowState());
+    wm::WorkspaceWindowState window_state(
+        workspace_controller_->GetWindowState());
     switch (window_state) {
-      case WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
+      case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
         const aura::Window* fullscreen_window = GetRootWindowController(
             root_window_)->GetWindowForFullscreenMode();
         if (fullscreen_window && wm::GetWindowState(fullscreen_window)->
                 hide_shelf_when_fullscreen()) {
           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;
       }
 
-      case WORKSPACE_WINDOW_STATE_MAXIMIZED:
+      case wm::WORKSPACE_WINDOW_STATE_MAXIMIZED:
         SetState(CalculateShelfVisibility());
         break;
 
-      case WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF:
-      case WORKSPACE_WINDOW_STATE_DEFAULT:
+      case wm::WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF:
+      case wm::WORKSPACE_WINDOW_STATE_DEFAULT:
         SetState(CalculateShelfVisibility());
-        SetWindowOverlapsShelf(window_state ==
-                               WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF);
+        SetWindowOverlapsShelf(
+            window_state == wm::WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF);
         break;
     }
   }
 }
 
 void ShelfLayoutManager::UpdateAutoHideState() {
   ShelfAutoHideState auto_hide_state =
       CalculateAutoHideState(state_.visibility_state);
   if (auto_hide_state != state_.auto_hide_state) {
     if (auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
@@ skipping 192 matching lines @@
 
 ShelfLayoutManager::TargetBounds::~TargetBounds() {}
 
 void ShelfLayoutManager::SetState(ShelfVisibilityState visibility_state) {
   if (!shelf_->GetNativeView())
     return;
 
   State state;
   state.visibility_state = visibility_state;
   state.auto_hide_state = CalculateAutoHideState(visibility_state);
-  state.window_state = workspace_controller_ ?
-      workspace_controller_->GetWindowState() : WORKSPACE_WINDOW_STATE_DEFAULT;
+  state.window_state = workspace_controller_
+                           ? workspace_controller_->GetWindowState()
+                           : 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 19 matching lines @@
 
   BackgroundAnimatorChangeType change_type = BACKGROUND_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 &&
+      state.window_state == wm::WORKSPACE_WINDOW_STATE_MAXIMIZED &&
       old_state.visibility_state != SHELF_VISIBLE) {
     change_type = BACKGROUND_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);
   } else {
     UpdateShelfBackground(change_type);
   }
 
-  shelf_->SetDimsShelf(
-      state.visibility_state == SHELF_VISIBLE &&
-      state.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED);
+  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);
 
   // 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 &&
@@ skipping 273 matching lines @@
 void ShelfLayoutManager::UpdateShelfBackground(
     BackgroundAnimatorChangeType type) {
   const ShelfBackgroundType background_type(GetShelfBackgroundType());
   shelf_->SetPaintsBackground(background_type, type);
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     OnBackgroundUpdated(background_type, type));
 }
 
 ShelfBackgroundType ShelfLayoutManager::GetShelfBackgroundType() const {
   if (state_.visibility_state != SHELF_AUTO_HIDE &&
-      state_.window_state == WORKSPACE_WINDOW_STATE_MAXIMIZED) {
+      state_.window_state == wm::WORKSPACE_WINDOW_STATE_MAXIMIZED) {
     return 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 SHELF_BACKGROUND_OVERLAP;
   }
 
@@ skipping 208 matching lines @@
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 void ShelfLayoutManager::UpdateShelfVisibilityAfterLoginUIChange() {
   UpdateVisibilityState();
   LayoutShelf();
 }
 
 }  // namespace ash