Fullscreen/immersive mode is allowed in touch view mode, the shelf gets hidden and an edge swipe br…

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 296 matching lines @@
   return SHELF_VISIBLE;
 }
 
 void ShelfLayoutManager::UpdateVisibilityState() {
   // Bail out early when there is no |workspace_controller_|, which happens
   // during shutdown after PrepareForShutdown.
   if (!workspace_controller_)
     return;
 
   if (Shell::GetInstance()->session_state_delegate()->IsScreenLocked() ||
-      force_shelf_always_visibile_) {
+      IsShelfForcedToBeVisible()) {
     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());
     switch (window_state) {
       case WORKSPACE_WINDOW_STATE_FULL_SCREEN: {
         const aura::Window* fullscreen_window = GetRootWindowController(
             root_window_)->GetWindowForFullscreenMode();
         if (fullscreen_window && wm::GetWindowState(fullscreen_window)->
@@ skipping 54 matching lines @@
 }
 
 void ShelfLayoutManager::RemoveObserver(ShelfLayoutManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, Gesture functions:
 
 void ShelfLayoutManager::OnGestureEdgeSwipe(const ui::GestureEvent& gesture) {
-  if (force_shelf_always_visibile_)
+  if (IsShelfForcedToBeVisible())
     return;
 
   if (visibility_state() == SHELF_AUTO_HIDE) {
     gesture_drag_auto_hide_state_ = SHELF_AUTO_HIDE_SHOWN;
     gesture_drag_status_ = GESTURE_DRAG_COMPLETE_IN_PROGRESS;
     UpdateVisibilityState();
     gesture_drag_status_ = GESTURE_DRAG_NONE;
   }
 }
 
 void ShelfLayoutManager::StartGestureDrag(const ui::GestureEvent& gesture) {
-  if (force_shelf_always_visibile_)
+  if (IsShelfForcedToBeVisible())
     return;
   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() : SHELF_AUTO_HIDE_SHOWN;
   UpdateShelfBackground(BACKGROUND_CHANGE_ANIMATE);
 }
 
 ShelfLayoutManager::DragState ShelfLayoutManager::UpdateGestureDrag(
     const ui::GestureEvent& gesture) {
-  if (force_shelf_always_visibile_)
+  if (IsShelfForcedToBeVisible())
     return DRAG_SHELF;
   bool horizontal = IsHorizontalAlignment();
   gesture_drag_amount_ += horizontal ? gesture.details().scroll_y() :
                                        gesture.details().scroll_x();
   LayoutShelf();
 
   // Start reveling the status menu when:
   //   - dragging up on an already visible shelf
   //   - dragging up on a hidden shelf, but it is currently completely visible.
   if (horizontal && gesture.details().scroll_y() < 0) {
     int min_height = 0;
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN && shelf_)
       min_height = shelf_->GetContentsView()->GetPreferredSize().height();
 
     if (min_height < shelf_->GetWindowBoundsInScreen().height() &&
         gesture.root_location().x() >=
         shelf_->status_area_widget()->GetWindowBoundsInScreen().x() &&
         IsDraggingTrayEnabled())
       return DRAG_TRAY;
   }
 
   return DRAG_SHELF;
 }
 
 void ShelfLayoutManager::CompleteGestureDrag(const ui::GestureEvent& gesture) {
-  if (force_shelf_always_visibile_)
+  if (IsShelfForcedToBeVisible())
     return;
   bool horizontal = IsHorizontalAlignment();
   bool should_change = false;
   if (gesture.type() == ui::ET_GESTURE_SCROLL_END) {
     // The visibility of the shelf changes only if the shelf was dragged X%
     // along the correct axis. If the shelf was already visible, then the
     // direction of the drag does not matter.
     const float kDragHideThreshold = 0.4f;
     gfx::Rect bounds = GetIdealBounds();
     float drag_ratio = fabs(gesture_drag_amount_) /
@@ skipping 549 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 (force_shelf_always_visibile_)
+  if (IsShelfForcedToBeVisible())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (visibility_state != SHELF_AUTO_HIDE || !shelf_)
     return SHELF_AUTO_HIDE_HIDDEN;
 
   Shell* shell = Shell::GetInstance();
   if (shell->GetAppListTargetVisibility())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->status_area_widget() &&
@@ skipping 94 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 {
+  // 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_ &&
+      workspace_controller_->GetWindowState() !=
+          WORKSPACE_WINDOW_STATE_FULL_SCREEN;
+}
+
 gfx::Rect ShelfLayoutManager::GetAvailableBounds() const {
   gfx::Rect bounds(root_window_->bounds());
   bounds.set_height(bounds.height() - keyboard_bounds_.height());
   return bounds;
 }
 
 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;
@@ skipping 44 matching lines @@
 
 void ShelfLayoutManager::SessionStateChanged(
     SessionStateDelegate::SessionState state) {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, true, NULL);
   UpdateVisibilityState();
 }
 
 }  // namespace ash