Fixes tab dragging out of a window with maximzied bounds

ash/wm/default_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/default_state.h"
 
 #include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 13 matching lines @@
 #include "ui/gfx/geometry/rect.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // This specifies how much percent (30%) of a window rect
 // must be visible when the window is added to the workspace.
 const float kMinimumPercentOnScreenArea = 0.3f;
 
+// When a window that has restore bounds at least as large as a work area is
+// unmaximized, inset the bounds slightly so that they are not exactly the same.
+// This makes it easier to resize the window.
+const int kMaximizedWindowInset = 10;  // Pixels.

[sky, 2015/06/06 17:59:30]

Is this really pixels?

[varkha, 2015/06/06 20:13:17]

I thought so. Isn't that what window bounds are expressed in?

[sky, 2015/06/07 00:05:20]

It may depend upon the platform, but I have to look. Certainly on chromeos they
are DIPs.

[oshima, 2015/06/07 01:19:02]

This is DIP.

+
 bool IsMinimizedWindowState(const WindowStateType state_type) {
   return state_type == WINDOW_STATE_TYPE_MINIMIZED ||
          state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED;
 }
 
 void MoveToDisplayForRestore(WindowState* window_state) {
   if (!window_state->HasRestoreBounds())
     return;
   const gfx::Rect& restore_bounds = window_state->GetRestoreBoundsInScreen();
 
@@ skipping 592 matching lines @@
       gfx::Rect work_area_in_parent =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
             bounds_in_parent.width() >= work_area_in_parent.width() &&
             bounds_in_parent.height() >= work_area_in_parent.height()) {
-          // Inset the bounds slightly so that they are not exactly same as
-          // the work area bounds and it is easier to resize the window.
           bounds_in_parent = work_area_in_parent;
-          bounds_in_parent.Inset(10, 10, 10, 10);
+          bounds_in_parent.Inset(kMaximizedWindowInset, kMaximizedWindowInset,
+                                 kMaximizedWindowInset, kMaximizedWindowInset);
         }
       } else {
         bounds_in_parent = window->bounds();
       }
       // Make sure that part of the window is always visible.
       AdjustBoundsToEnsureMinimumWindowVisibility(
           work_area_in_parent, &bounds_in_parent);
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
@@ skipping 73 matching lines @@
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash