Ignoring minimum size requirements for maximized windows, full screen windows and too small screens

ui/aura/window.cc

 // Copyright (c) 2012 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 "ui/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 408 matching lines @@
 scoped_ptr<ui::EventTargeter>
 Window::SetEventTargeter(scoped_ptr<ui::EventTargeter> targeter) {
   scoped_ptr<ui::EventTargeter> old_targeter = targeter_.Pass();
   targeter_ = targeter.Pass();
   return old_targeter.Pass();
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
   if (parent_ && parent_->layout_manager())
     parent_->layout_manager()->SetChildBounds(this, new_bounds);
-  else
-    SetBoundsInternal(new_bounds);
+  else {
+    // Ensure we don't go smaller than our minimum bounds.
+    gfx::Rect final_bounds(new_bounds);
+    if (delegate_) {
+      const gfx::Size& min_size = delegate_->GetMinimumSize();
+      final_bounds.set_width(std::max(min_size.width(), final_bounds.width()));
+      final_bounds.set_height(std::max(min_size.height(),
+                                       final_bounds.height()));
+    }
+    SetBoundsInternal(final_bounds);
+  }
 }
 
 void Window::SetBoundsInScreen(const gfx::Rect& new_bounds_in_screen,
                                const gfx::Display& dst_display) {
   Window* root = GetRootWindow();
   if (root) {
     gfx::Point origin = new_bounds_in_screen.origin();
     aura::client::ScreenPositionClient* screen_position_client =
         aura::client::GetScreenPositionClient(root);
     screen_position_client->SetBounds(this, new_bounds_in_screen, dst_display);
@@ skipping 417 matching lines @@
   SkRegion clip_region;
   clip_region.setRect(local_bounds.x(), local_bounds.y(),
                       local_bounds.width(), local_bounds.height());
   SkRegion mask_region;
   return mask_region.setPath(mask, clip_region) &&
       mask_region.contains(local_point.x(), local_point.y());
 }
 
 void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
   gfx::Rect actual_new_bounds(new_bounds);
-
-  // Ensure we don't go smaller than our minimum bounds.
-  if (delegate_) {
-    const gfx::Size& min_size = delegate_->GetMinimumSize();
-    actual_new_bounds.set_width(
-        std::max(min_size.width(), actual_new_bounds.width()));
-    actual_new_bounds.set_height(
-        std::max(min_size.height(), actual_new_bounds.height()));
-  }
-
   gfx::Rect old_bounds = GetTargetBounds();
 
   // Always need to set the layer's bounds -- even if it is to the same thing.
   // This may cause important side effects such as stopping animation.
   if (!layer()) {
     const gfx::Vector2d origin_delta = new_bounds.OffsetFromOrigin() -
         bounds_.OffsetFromOrigin();
     bounds_ = new_bounds;
     OffsetLayerBounds(origin_delta);
   } else {
@@ skipping 540 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura