Use MD-ash's auto hide behavior for arc++ windows.

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>
 
@@ skipping 221 matching lines @@
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   WmWindow* shelf_window = WmLookup::Get()->GetWindowForWidget(shelf_widget_);
   WmRootWindowController* controller = shelf_window->GetRootWindowController();
   // Bail out early before the shelf is initialized or after it is destroyed.
   if (!controller || !shelf_widget_->shelf() || in_shutdown_)
     return;
 
+  // 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(
         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);
+        switch (GetShelfModeForFullscreen()) {
+          case wm::WindowState::SHELF_HIDDEN:
+            SetState(SHELF_HIDDEN);
+            break;
+          case wm::WindowState::SHELF_AUTO_HIDE_VISIBLE:
+            // 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.
+            if (state_.visibility_state == SHELF_AUTO_HIDE)
+              SetState(SHELF_HIDDEN);
+
+            SetState(SHELF_AUTO_HIDE);
+            break;
+          case wm::WindowState::SHELF_AUTO_HIDE_INVISIBLE:
+            // 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.
+            if (state_.visibility_state == SHELF_AUTO_HIDE)
+              SetState(SHELF_HIDDEN);
+
+            invisible_auto_hide_shelf_ = true;
+            SetState(SHELF_AUTO_HIDE);
+            break;

[tdanderson, 2016/08/15 19:51:37]

Is it possible to simplify as follows or do you need to leave as-is for things
to work?

case wm::WindowState::SHELF_AUTO_HIDE_INVISIBLE:
  invisible_auto_hide_shelf_ = true;
case wm::WindowState::SHELF_AUTO_HIDE_VISIBLE:
  // A hack to...
  ...
  break;

[oshima, 2016/08/15 20:01:50]

Done.

         }
         break;
       }
 
       case wm::WORKSPACE_WINDOW_STATE_MAXIMIZED:
         SetState(CalculateShelfVisibility());
         break;
 
       case wm::WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF:
       case wm::WORKSPACE_WINDOW_STATE_DEFAULT:
@@ skipping 519 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 = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
+  int shelf_insets = GetShelfInsetsForAutoHide();
   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 172 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 GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
+    return GetShelfInsetsForAutoHide();
   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::IsShelfMaterial()) {
+  if (ash::MaterialDesignController::IsShelfMaterial() ||
+      invisible_auto_hide_shelf_) {
     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()->hide_shelf_when_fullscreen();
+         fullscreen_window->GetWindowState()->shelf_mode_in_fullscreen() ==
+             ash::wm::WindowState::SHELF_HIDDEN;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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 77 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