Fixing problem where applications are not getting centered when created after maximize mode starts

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 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 bounds = bounds_in_parent;
+  gfx::Rect work_area_in_parent =
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(state_object->window());
+  wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent, &bounds);
+
+  // Center the window over the work area.
+  int x = (work_area_in_parent.width() - bounds.width()) / 2 +
+          work_area_in_parent.x();
+  int y = (work_area_in_parent.height() - bounds.height()) / 2 +
+          work_area_in_parent.y();

[oshima, 2014/04/24 21:01:25]

I think

work_area_in_parent.ClampToCenteredSize(bounds)

should work. (the opposite does not)

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

I tried this yesterday. And it did not work. Apparently I must have done
something wrong. That said - the name of the function and the use is far from
obvious. But arguably it makes the code look simpler.

Done.

+
+  bounds.set_origin(gfx::Point(x, y));
+
+  return bounds;
+}
+
 // Returns the maximized and centered bounds of a window.
 gfx::Rect GetMaximizedAndCenteredBounds(wm::WindowState* state_object) {
   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();
     else
       bounds_in_parent = state_object->window()->bounds();
   }
-  gfx::Rect work_area_in_parent =
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(state_object->window());
-
-  wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
-                                                  &bounds_in_parent);
-
-  // Center the window over the work area.
-  int x = (work_area_in_parent.width() - bounds_in_parent.width()) / 2 +
-          work_area_in_parent.x();
-  int y = (work_area_in_parent.height() - bounds_in_parent.height()) / 2 +
-          work_area_in_parent.y();
-
-  bounds_in_parent.set_origin(gfx::Point(x, y));
-
-  return bounds_in_parent;
+  return GetCenteredBounds(bounds_in_parent, state_object);
 }
 
 }  // namespace
 
 // static
 void MaximizeModeWindowState::UpdateWindowPosition(
     wm::WindowState* window_state, bool animated) {
   gfx::Rect bounds_in_parent = GetMaximizedAndCenteredBounds(window_state);
 
   if (bounds_in_parent == window_state->window()->bounds())
@@ skipping 53 matching lines @@
       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);
       } 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);
+        bounds_in_parent = GetCenteredBounds(bounds_in_parent, window_state);
+        if (bounds_in_parent != window_state->window()->bounds()) {
+          if (window_state->window()->IsVisible())

[oshima, 2014/04/24 21:01:25]

how this can be not visible (in non minimized mode)?

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

Multi user mode for example. Before the window gets shown for the first time, ..
. But maybe I am missing something?

[oshima, 2014/04/24 21:57:52]

I see. I don't think we do this in normal mode, but this is probably better.
lgtm.

+            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);
       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);
       break;
@@ skipping 68 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