Revert auto-hide-invisible mode for ARC++

ash/common/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/common/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 184 matching lines @@
       return SHELF_HIDDEN;
   }
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   // Bail out early before the shelf is initialized or after it is destroyed.
   WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
   if (in_shutdown_ || !wm_shelf_->IsShelfInitialized() || !shelf_window)
     return;
-  bool was_invisible_auto_hide_shelf = invisible_auto_hide_shelf_;
-  // Always reset to be safe.
-  invisible_auto_hide_shelf_ = false;
   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(
         shelf_window->GetRootWindowController()->GetWorkspaceWindowState());
     switch (window_state) {
       case wm::WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
-        switch (GetShelfModeForFullscreen()) {
-          case wm::WindowState::SHELF_HIDDEN:
-            SetState(SHELF_HIDDEN);
-            break;
-          case wm::WindowState::SHELF_AUTO_HIDE_INVISIBLE:
-            invisible_auto_hide_shelf_ = true;
-          case wm::WindowState::SHELF_AUTO_HIDE_VISIBLE:
-            if (was_invisible_auto_hide_shelf != invisible_auto_hide_shelf_ &&
-                state_.visibility_state == SHELF_AUTO_HIDE) {
-              // A hack to swtich the visibility state correctly
-              // between auto hide visible to auto hide invisible.
-              // TODO(oshima): Remove this once MD ash is launched.
-              SetState(SHELF_HIDDEN);
-            }
-            SetState(SHELF_AUTO_HIDE);
-            break;
+        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;
       }
-
       case wm::WORKSPACE_WINDOW_STATE_MAXIMIZED:
         SetState(CalculateShelfVisibility());
         break;
 
       case wm::WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF:
       case wm::WORKSPACE_WINDOW_STATE_DEFAULT:
         SetState(CalculateShelfVisibility());
         SetWindowOverlapsShelf(
             window_state == wm::WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF);
         break;
@@ skipping 517 matching lines @@
   if (resist) {
     float diff = fabsf(gesture_drag_amount_) - resistance_free_region;
     diff = std::min(diff, sqrtf(diff));
     if (gesture_drag_amount_ < 0)
       translate = -resistance_free_region - diff;
     else
       translate = resistance_free_region + diff;
   } else {
     translate = gesture_drag_amount_;
   }
-  int shelf_insets = GetShelfInsetsForAutoHide();
+  int shelf_insets = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   if (horizontal) {
     // Move and size the shelf with the gesture.
     int shelf_height = target_bounds->shelf_bounds_in_root.height() - translate;
     shelf_height = std::max(shelf_height, shelf_insets);
     target_bounds->shelf_bounds_in_root.set_height(shelf_height);
     if (IsHorizontalAlignment()) {
       target_bounds->shelf_bounds_in_root.set_y(available_bounds.bottom() -
                                                 shelf_height);
     }
 
@@ skipping 170 matching lines @@
   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)
     return size;
   if (state.visibility_state == SHELF_AUTO_HIDE)
-    return GetShelfInsetsForAutoHide();
+    return GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   return 0;
 }
 
 void ShelfLayoutManager::OnDockBoundsChanging(
     const gfx::Rect& dock_bounds,
     DockedWindowLayoutManagerObserver::Reason reason) {
   // Skip shelf layout in case docked notification originates from this class.
   if (reason == DISPLAY_INSETS_CHANGED)
     return;
   if (dock_bounds_ != dock_bounds) {
@@ skipping 36 matching lines @@
 }
 
 float ShelfLayoutManager::ComputeTargetOpacity(const State& state) {
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS ||
       state.visibility_state == SHELF_VISIBLE) {
     return 1.0f;
   }
   // In Chrome OS Material Design, when shelf is hidden during auto hide state,
   // target bounds are also hidden. So the window can extend to the edge of
   // screen.
-  if (ash::MaterialDesignController::IsImmersiveModeMaterial() ||
-      invisible_auto_hide_shelf_) {
+  if (ash::MaterialDesignController::IsImmersiveModeMaterial()) {
     return (state.visibility_state == SHELF_AUTO_HIDE &&
             state.auto_hide_state == SHELF_AUTO_HIDE_SHOWN)
                ? 1.0f
                : 0.0f;
   }
   return (state.visibility_state == SHELF_AUTO_HIDE) ? 1.0f : 0.0f;
 }
 
-ash::wm::WindowState::FullscreenShelfMode
-ShelfLayoutManager::GetShelfModeForFullscreen() const {
-  const WmWindow* fullscreen_window = wm::GetWindowForFullscreenMode(
-      WmLookup::Get()->GetWindowForWidget(shelf_widget_));
-  return fullscreen_window->GetWindowState()->shelf_mode_in_fullscreen();
-}
-
 bool ShelfLayoutManager::IsShelfHiddenForFullscreen() const {
   const WmWindow* fullscreen_window = wm::GetWindowForFullscreenMode(
       WmLookup::Get()->GetWindowForWidget(shelf_widget_));
   return fullscreen_window &&
-         fullscreen_window->GetWindowState()->shelf_mode_in_fullscreen() ==
-             ash::wm::WindowState::SHELF_HIDDEN;
+         fullscreen_window->GetWindowState()->hide_shelf_when_fullscreen();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture functions:
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
   gesture_drag_status_ = GESTURE_DRAG_IN_PROGRESS;
   gesture_drag_amount_ = 0.f;
   gesture_drag_auto_hide_state_ = visibility_state() == SHELF_AUTO_HIDE
                                       ? auto_hide_state()
@@ skipping 76 matching lines @@
     UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
-int ShelfLayoutManager::GetShelfInsetsForAutoHide() const {
-  if (invisible_auto_hide_shelf_)
-    return 0;
-  return GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
-}
-
 }  // namespace ash