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"
@@ skipping 27 matching lines @@
     return workspace_size;
 
   gfx::Size size = delegate->GetMaximumSize();
   if (size.IsEmpty())
     return workspace_size;
 
   size.SetToMin(workspace_size);
   return size;
 }
 
-// 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) {
+  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 49 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:
+      ShowWindow(window_state,
+                 current_state_type_ != wm::WINDOW_STATE_TYPE_FULLSCREEN ?
+                     FULL_SCREEN : MAXIMIZED_OR_CENTERED,
+                 true);

[oshima, 2014/04/23 15:57:38]

can you refactor the code in default_state and use the same logic?

[Mr4D (OOO till 08-26), 2014/04/23 19:20:31]

Not quite sure what you want. Either way - that should be done in a different
patch?

[Mr4D (OOO till 08-26), 2014/04/25 17:36:29]

Your comment was a bit confusing. It sounded like that you wanted me to change
something in default_state. Done.

[oshima, 2014/04/25 18:46:55]

Yes, that's what I meant. The same code should work, so we should refactor and
use the same code instead of duplicating.

+      break;
+    case wm::WM_EVENT_FULLSCREEN:
+      ShowWindow(window_state, FULL_SCREEN, 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);
+      ShowWindow(window_state, MAXIMIZED_OR_CENTERED, 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);
       }
       return;
     case wm::WM_EVENT_SHOW_INACTIVE:
       return;
     case wm::WM_EVENT_SET_BOUNDS:

[oshima, 2014/04/23 15:57:38]

a window in fullscreen state or maximzied state cannot be resized, so you can
just ignore these cases.

In addition, these events (SET_BOUNS to DISPLAY_BOUNDS_CHANGED)
won't change the window state type. Can you refactor ShowState (or
MaximizeOrCenterWindow) into one that simply update the bounds based on the
current state and another that updates the state? Then I think you don't need
another ShowState enum.

[Mr4D (OOO till 08-26), 2014/04/23 19:20:31]

Not entirely correct. A window could have (changing) restrictions which can lead
to new dimensions.
Even more so I have seen that the calculator apparently creates a window first
which is maximizable and then another window gets put inside it which is not.
Then the window changes state and bounds to make it not resizable (and not
maximizable).

I moved the update state into a separate function as requested. I also removed
the enum (which I had in the past but I didn't like) which lead into the fact
that the state calculation has now be performed before entering the function
(which I tried to avoid).

[oshima, 2014/04/24 00:35:15]

I don't think that's supposed to be possible because CanMaximize is not
modifiable (that is, we don't listen to its change).
I'm guessing that you're seeing this because we set the property too late in

https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/widget/na...

?
What do you mean by "another window gets put inside"?

[Mr4D (OOO till 08-26), 2014/04/24 21:52:13]

Checked with scheib@ and this should be correct for ChromeOS. It would be a
different story for Windows though.

Done. 

       if (current_state_type_ == wm::WINDOW_STATE_TYPE_MAXIMIZED ||
           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);
+        ShowWindow(window_state,
+                   current_state_type_ == wm::WINDOW_STATE_TYPE_FULLSCREEN ?
+                       FULL_SCREEN : MAXIMIZED_OR_CENTERED,
+                   true);
       } else if (current_state_type_ != wm::WINDOW_STATE_TYPE_MINIMIZED) {
         // 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.ClampToCenteredSize(
              ScreenUtil::GetDisplayWorkAreaBoundsInParent(
                  window_state->window()).size());
         if (bounds_in_parent != window_state->window()->bounds())
           window_state->SetBoundsDirectAnimated(bounds_in_parent);
       }
       break;
     case wm::WM_EVENT_ADDED_TO_WORKSPACE:
-      MaximizeOrCenterWindow(window_state, true);
+      ShowWindow(window_state,
+                 current_state_type_ == wm::WINDOW_STATE_TYPE_FULLSCREEN ?
+                     FULL_SCREEN : MAXIMIZED_OR_CENTERED,
+                 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);
+        ShowWindow(window_state,
+                   current_state_type_ == wm::WINDOW_STATE_TYPE_FULLSCREEN ?
+                       FULL_SCREEN : MAXIMIZED_OR_CENTERED,
+                   false);
       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) {
+    ShowWindow(window_state, MAXIMIZED_OR_CENTERED, 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(
+void MaximizeModeWindowState::ShowWindow(
     wm::WindowState* window_state,
+    MaximizeModeWindowState::ShowState show_state,
     bool animated) {
   const wm::WindowStateType target_state =
-      window_state->CanMaximize() ? wm::WINDOW_STATE_TYPE_MAXIMIZED :
-                                    wm::WINDOW_STATE_TYPE_NORMAL;
+      show_state == FULL_SCREEN ? wm::WINDOW_STATE_TYPE_FULLSCREEN :
+          (window_state->CanMaximize() ? wm::WINDOW_STATE_TYPE_MAXIMIZED :
+                                         wm::WINDOW_STATE_TYPE_NORMAL);
   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()) {
@@ skipping 27 matching lines @@
       window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
 
   // Hide the window.
   window_state->window()->Hide();
   // Activate another window.
   if (window_state->IsActive())
     window_state->Deactivate();
 }
 
 }  // namespace ash