ash: Do not constrain window bounds if requested

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/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/wm/screen_pinning_controller.h"
@@ skipping 325 matching lines @@
 bool DefaultState::ProcessWorkspaceEvents(WindowState* window_state,
                                           const WMEvent* event) {
   switch (event->type()) {
     case WM_EVENT_ADDED_TO_WORKSPACE: {
       // When a window is dragged and dropped onto a different
       // root window, the bounds will be updated after they are added
       // to the root window.
       // If a window is opened as maximized or fullscreen, its bounds may be
       // empty, so update the bounds now before checking empty.
       if (window_state->is_dragged() ||
+          window_state->allow_set_bounds_direct() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
 
       WmWindow* window = window_state->window();
       gfx::Rect bounds = window->GetBounds();
 
       // Don't adjust window bounds if the bounds are empty as this
       // happens when a new views::Widget is created.
       if (bounds.IsEmpty())
@@ skipping 14 matching lines @@
       int min_height = bounds.height() * wm::kMinimumPercentOnScreenArea;
       wm::AdjustBoundsToEnsureWindowVisibility(display_area, min_width,
                                                min_height, &bounds);
       window_state->AdjustSnappedBounds(&bounds);
       if (window->GetBounds() != bounds)
         window_state->SetBoundsConstrained(bounds);
       return true;
     }
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED: {
       if (window_state->is_dragged() ||
+          window_state->allow_set_bounds_direct() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
           GetDisplayWorkAreaBoundsInParent(window_state->window());
       gfx::Rect bounds = window_state->window()->GetTargetBounds();
       // When display bounds has changed, make sure the entire window is fully
       // visible.
       bounds.AdjustToFit(work_area_in_parent);
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->window()->GetTargetBounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED: {
       // Don't resize the maximized window when the desktop is covered
       // by fullscreen window. crbug.com/504299.
       bool in_fullscreen =
           window_state->window()
               ->GetRootWindowController()
               ->GetWorkspaceWindowState() == WORKSPACE_WINDOW_STATE_FULL_SCREEN;
       if (in_fullscreen && window_state->IsMaximized())
         return true;
 
       if (window_state->is_dragged() ||
+          window_state->allow_set_bounds_direct() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
           GetDisplayWorkAreaBoundsInParent(window_state->window());
       gfx::Rect bounds = window_state->window()->GetTargetBounds();
       if (!window_state->window()->GetTransientParent()) {
         wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
                                                         &bounds);
       }
@@ skipping 21 matching lines @@
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
+  DCHECK(!window_state->allow_set_bounds_direct());
   if (window_state->IsMaximized()) {
     window_state->SetBoundsDirect(
         GetMaximizedWindowBoundsInParent(window_state->window()));
     return true;
   }
   if (window_state->IsFullscreen()) {
     window_state->SetBoundsDirect(
         GetDisplayBoundsInParent(window_state->window()));
     return true;
   }
   return false;
 }
 
 // static
 void DefaultState::SetBounds(WindowState* window_state,
                              const SetBoundsEvent* event) {
-  if (window_state->is_dragged()) {
+  if (window_state->is_dragged() || window_state->allow_set_bounds_direct()) {
     // TODO(oshima|varkha): Is this still needed? crbug.com/485612.
     window_state->SetBoundsDirect(event->requested_bounds());
   } else if (window_state->IsSnapped()) {
     gfx::Rect work_area_in_parent =
         GetDisplayWorkAreaBoundsInParent(window_state->window());
     gfx::Rect child_bounds(event->requested_bounds());
     wm::AdjustBoundsSmallerThan(work_area_in_parent.size(), &child_bounds);
     window_state->AdjustSnappedBounds(&child_bounds);
     window_state->SetBoundsDirect(child_bounds);
-  } else if (!SetMaximizedOrFullscreenBounds(window_state) ||
-             window_state->allow_set_bounds_in_maximized()) {
+  } else if (!SetMaximizedOrFullscreenBounds(window_state)) {
     window_state->SetBoundsConstrained(event->requested_bounds());
   }
 }
 
 void DefaultState::EnterToNextState(WindowState* window_state,
                                     WindowStateType next_state_type) {
   // Do nothing if  we're already in the same state.
   if (state_type_ == next_state_type)
     return;
 
@@ skipping 204 matching lines @@
     gfx::Rect center_in_parent = GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->GetBounds().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