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

ash/wm/maximize_mode/maximize_mode_window_state.cc

 // Copyright 2014 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/wm/maximize_mode/maximize_mode_window_state.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
+#include "ash/wm/window_state_util.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 
 namespace ash {
@@ skipping 21 matching lines @@
 
 // Returns the centered bounds of the given bounds in the work area.
 gfx::Rect GetCenteredBounds(const gfx::Rect& bounds_in_parent,
                             wm::WindowState* state_object) {
   gfx::Rect work_area_in_parent =
       ScreenUtil::GetDisplayWorkAreaBoundsInParent(state_object->window());
   work_area_in_parent.ClampToCenteredSize(bounds_in_parent.size());
   return work_area_in_parent;
 }
 
-// Returns the maximized and centered bounds of a window.
+// Returns the maximized/full screen and/or centered bounds of a window.
 gfx::Rect GetMaximizedAndCenteredBounds(wm::WindowState* state_object) {

[oshima, 2014/04/25 20:14:59]

nit: can you come up with better name as it now also return bounds for
fullscreen. (I'm fine with something like GetBoundsInMaximizedMode)

[Mr4D (OOO till 08-26), 2014/04/25 21:00:49]

Done.

+  if (state_object->IsFullscreen())
+    return ScreenUtil::GetDisplayBoundsInParent(state_object->window());
+
   gfx::Rect bounds_in_parent;
   // Make the window as big as possible.
   if (state_object->CanMaximize() || state_object->CanResize()) {
     bounds_in_parent.set_size(GetMaximumSizeOfWindow(state_object));
   } else {
     // We prefer the user given window dimensions over the current windows
     // dimensions since they are likely to be the result from some other state
     // object logic.
     if (state_object->HasRestoreBounds())
       bounds_in_parent = state_object->GetRestoreBoundsInParent();
@@ skipping 35 matching lines @@
 
 void MaximizeModeWindowState::LeaveMaximizeMode(wm::WindowState* window_state) {
   // Note: When we return we will destroy ourselves with the |our_reference|.
   scoped_ptr<wm::WindowState::State> our_reference =
       window_state->SetStateObject(old_state_.Pass());
 }
 
 void MaximizeModeWindowState::OnWMEvent(wm::WindowState* window_state,
                                         const wm::WMEvent* event) {
   switch (event->type()) {
+    case wm::WM_EVENT_TOGGLE_FULLSCREEN:
+      ToggleFullScreen(window_state, window_state->delegate());
+      break;
+    case wm::WM_EVENT_FULLSCREEN:
+      UpdateWindow(window_state, wm::WINDOW_STATE_TYPE_FULLSCREEN, true);
+      break;
     case wm::WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case wm::WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case wm::WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
-    case wm::WM_EVENT_TOGGLE_FULLSCREEN:
     case wm::WM_EVENT_TOGGLE_MAXIMIZE:
     case wm::WM_EVENT_CENTER:
-    case wm::WM_EVENT_FULLSCREEN:
     case wm::WM_EVENT_SNAP_LEFT:
     case wm::WM_EVENT_SNAP_RIGHT:
     case wm::WM_EVENT_NORMAL:
     case wm::WM_EVENT_MAXIMIZE:
-      MaximizeOrCenterWindow(window_state, true);
+      UpdateWindow(window_state,
+                   GetMaximizedOrCenteredWindowType(window_state),
+                   true);
       return;
     case wm::WM_EVENT_MINIMIZE:
-      if (current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED) {
-        current_state_type_ = wm::WINDOW_STATE_TYPE_MINIMIZED;
-        Minimize(window_state);
-      }
+      UpdateWindow(window_state, wm::WINDOW_STATE_TYPE_MINIMIZED, true);
       return;
     case wm::WM_EVENT_SHOW_INACTIVE:
       return;
     case wm::WM_EVENT_SET_BOUNDS:
-      if (current_state_type_ == wm::WINDOW_STATE_TYPE_MAXIMIZED ||
-          window_state->CanResize()) {
+      if (window_state->CanResize()) {
         // In case the window is resizable and / or maximized we ignore the
         // requested bounds change and resize to the biggest possible size.
-        MaximizeOrCenterWindow(window_state, true);
-      } else if (current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED) {
+        UpdateBounds(window_state, true);
+      } else
+      if (current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED &&
+          current_state_type_ != wm::WINDOW_STATE_TYPE_MAXIMIZED) {
         // In all other cases (except for minimized windows) we respect the
         // requested bounds and center it to a fully visible area on the screen.
         gfx::Rect bounds_in_parent =
             (static_cast<const wm::SetBoundsEvent*>(event))->requested_bounds();
         bounds_in_parent = GetCenteredBounds(bounds_in_parent, window_state);
         if (bounds_in_parent != window_state->window()->bounds()) {
           if (window_state->window()->IsVisible())
             window_state->SetBoundsDirectAnimated(bounds_in_parent);
           else
             window_state->SetBoundsDirect(bounds_in_parent);
         }
       }
       break;
     case wm::WM_EVENT_ADDED_TO_WORKSPACE:
-      MaximizeOrCenterWindow(window_state, true);
+      if (current_state_type_ != wm::WINDOW_STATE_TYPE_MAXIMIZED &&
+          current_state_type_ != wm::WINDOW_STATE_TYPE_FULLSCREEN &&
+          current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED) {
+        wm::WindowStateType new_state =
+            GetMaximizedOrCenteredWindowType(window_state);
+        UpdateWindow(window_state, new_state, true);
+      }
       break;
     case wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       if (current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED)
-        MaximizeOrCenterWindow(window_state, false);
+        UpdateBounds(window_state, true);
       break;
   }
 }
 
 wm::WindowStateType MaximizeModeWindowState::GetType() const {
   return current_state_type_;
 }
 
 void MaximizeModeWindowState::AttachState(
     wm::WindowState* window_state,
     wm::WindowState::State* previous_state) {
   current_state_type_ = previous_state->GetType();
 
   // Initialize the state to a good preset.
   if (current_state_type_ != wm::WINDOW_STATE_TYPE_MAXIMIZED &&
-      current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED) {
-    MaximizeOrCenterWindow(window_state, true);
+      current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED &&
+      current_state_type_ != wm::WINDOW_STATE_TYPE_FULLSCREEN) {
+    UpdateWindow(window_state,
+                 GetMaximizedOrCenteredWindowType(window_state),
+                 true);
   }
 
   window_state->set_can_be_dragged(false);
 }
 
 void MaximizeModeWindowState::DetachState(wm::WindowState* window_state) {
   window_state->set_can_be_dragged(true);
 }
 
-void MaximizeModeWindowState::MaximizeOrCenterWindow(
-    wm::WindowState* window_state,
-    bool animated) {
-  const wm::WindowStateType target_state =
-      window_state->CanMaximize() ? wm::WINDOW_STATE_TYPE_MAXIMIZED :
-                                    wm::WINDOW_STATE_TYPE_NORMAL;
+void MaximizeModeWindowState::UpdateWindow(wm::WindowState* window_state,
+                                           wm::WindowStateType target_state,
+                                           bool animated) {
+  DCHECK(target_state == wm::WINDOW_STATE_TYPE_MINIMIZED ||
+         target_state == wm::WINDOW_STATE_TYPE_MAXIMIZED ||
+         (target_state == wm::WINDOW_STATE_TYPE_NORMAL &&
+              !window_state->CanMaximize()) ||
+         target_state == wm::WINDOW_STATE_TYPE_FULLSCREEN);
+
+  if (target_state == wm::WINDOW_STATE_TYPE_MINIMIZED) {
+    if (current_state_type_ == wm::WINDOW_STATE_TYPE_MINIMIZED)
+      return;
+
+    current_state_type_ = target_state;
+    ::wm::SetWindowVisibilityAnimationType(
+        window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+    window_state->window()->Hide();
+    if (window_state->IsActive())
+      window_state->Deactivate();
+    return;
+  }
+
+  if (current_state_type_ == target_state) {
+    // If the state type did not change, update it accordingly.
+    UpdateBounds(window_state, animated);
+    return;
+  }
+
   const wm::WindowStateType old_state_type = current_state_type_;
-  gfx::Rect bounds_in_parent = GetMaximizedAndCenteredBounds(window_state);
-
-  if (current_state_type_ != target_state) {
-    current_state_type_ = target_state;
-    window_state->UpdateWindowShowStateFromStateType();
-    window_state->NotifyPreStateTypeChange(old_state_type);
-    // If we have a target bounds rectangle, we center it and set it
-    // accordingly.
-    if (!bounds_in_parent.IsEmpty()) {
-      if (current_state_type_ == wm::WINDOW_STATE_TYPE_MINIMIZED || !animated)
-        window_state->SetBoundsDirect(bounds_in_parent);
-      else
-        window_state->SetBoundsDirectAnimated(bounds_in_parent);
-    }
-    window_state->NotifyPostStateTypeChange(old_state_type);
-  } else if (!bounds_in_parent.IsEmpty() &&
-             bounds_in_parent != window_state->window()->bounds()) {
-    // Coming here, we were most probably called through a display change.
-    // Do not animate.
-    if (animated)
-      window_state->SetBoundsDirectAnimated(bounds_in_parent);
-    else
-      window_state->SetBoundsDirect(bounds_in_parent);
-  }
+  current_state_type_ = target_state;
+  window_state->UpdateWindowShowStateFromStateType();
+  window_state->NotifyPreStateTypeChange(old_state_type);
+  UpdateBounds(window_state, animated);
+  window_state->NotifyPostStateTypeChange(old_state_type);
 
   if ((window_state->window()->TargetVisibility() ||
       old_state_type == wm::WINDOW_STATE_TYPE_MINIMIZED) &&
       !window_state->window()->layer()->visible()) {
     // The layer may be hidden if the window was previously minimized. Make
     // sure it's visible.
     window_state->window()->Show();
   }
 }
 
-void MaximizeModeWindowState::Minimize(wm::WindowState* window_state) {
-  ::wm::SetWindowVisibilityAnimationType(
-      window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+wm::WindowStateType MaximizeModeWindowState::GetMaximizedOrCenteredWindowType(
+      wm::WindowState* window_state) {
+  return window_state->CanMaximize() ? wm::WINDOW_STATE_TYPE_MAXIMIZED :
+                                       wm::WINDOW_STATE_TYPE_NORMAL;
+}
 
-  // Hide the window.
-  window_state->window()->Hide();
-  // Activate another window.
-  if (window_state->IsActive())
-    window_state->Deactivate();
+void MaximizeModeWindowState::UpdateBounds(wm::WindowState* window_state,
+                                           bool animated) {
+  gfx::Rect bounds_in_parent = GetMaximizedAndCenteredBounds(window_state);
+  // If we have a target bounds rectangle, we center it and set it
+  // accordingly.
+  if (!bounds_in_parent.IsEmpty() &&
+      bounds_in_parent != window_state->window()->bounds()) {
+    if (current_state_type_ == wm::WINDOW_STATE_TYPE_MINIMIZED ||
+        !window_state->window()->IsVisible() ||
+        !animated) {
+      window_state->SetBoundsDirect(bounds_in_parent);
+    } else {
+      window_state->SetBoundsDirectAnimated(bounds_in_parent);
+    }
+  }
 }
 
 }  // namespace ash