Minimum size for aura window

ui/aura/window.cc

 // Copyright (c) 2011 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/logging.h"
 #include "ui/aura/desktop.h"
@@ skipping 78 matching lines @@
     Desktop::GetInstance()->ActivateTopmostWindow();
   }
 }
 
 bool Window::IsVisible() const {
   return layer_->IsDrawn();
 }
 
 void Window::Maximize() {
   if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_MAXIMIZED))
-    SetBounds(gfx::Screen::GetMonitorWorkAreaNearestWindow(this));
+    SetBoundsInternal(gfx::Screen::GetMonitorWorkAreaNearestWindow(this));
 }
 
 void Window::Fullscreen() {
   if (UpdateShowStateAndRestoreBounds(ui::SHOW_STATE_FULLSCREEN))
-    SetBounds(gfx::Screen::GetMonitorAreaNearestWindow(this));
+    SetBoundsInternal(gfx::Screen::GetMonitorAreaNearestWindow(this));
 }
 
 void Window::Restore() {
   if (show_state_ != ui::SHOW_STATE_NORMAL) {
     show_state_ = ui::SHOW_STATE_NORMAL;
-    SetBounds(restore_bounds_);
+    SetBoundsInternal(restore_bounds_);
     restore_bounds_.SetRect(0, 0, 0, 0);
   }
 }
 
 void Window::Activate() {
   // If we support minimization need to ensure this restores the window first.
   aura::Desktop::GetInstance()->SetActiveWindow(this, this);
 }
 
 void Window::Deactivate() {
@@ skipping 10 matching lines @@
 
 const ToplevelWindowContainer* Window::AsToplevelWindowContainer() const {
   return NULL;
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   layout_manager_.reset(layout_manager);
 }
 
 void Window::SetBounds(const gfx::Rect& new_bounds) {
-  // TODO: funnel this through the Desktop.
-  gfx::Rect old_bounds = bounds();
-  bool was_move = old_bounds.size() == new_bounds.size();
-  layer_->SetBounds(new_bounds);
-
-  if (layout_manager_.get())
-    layout_manager_->OnWindowResized();
-  if (delegate_)
-    delegate_->OnBoundsChanged(old_bounds, new_bounds);
-  if (IsVisible()) {
-    if (was_move)
-      layer()->ScheduleDraw();
-    else
-      layer()->SchedulePaint(gfx::Rect());
+  if (show_state_ == ui::SHOW_STATE_MAXIMIZED ||
+      show_state_ == ui::SHOW_STATE_FULLSCREEN) {
+    restore_bounds_ = new_bounds;
+    return;
   }
+  SetBoundsInternal(new_bounds);
 }
 
 const gfx::Rect& Window::bounds() const {
   return layer_->bounds();
 }
 
 void Window::SchedulePaintInRect(const gfx::Rect& rect) {
   layer_->SchedulePaint(rect);
 }
 
@@ skipping 215 matching lines @@
   parts.push_back(ui::MultiAnimation::Part(200, ui::Tween::LINEAR));
   ui::MultiAnimation* multi_animation = new ui::MultiAnimation(parts);
   multi_animation->set_continuous(false);
   return multi_animation;
 }
 
 internal::RootWindow* Window::GetRoot() {
   return parent_ ? parent_->GetRoot() : NULL;
 }
 
+void Window::SetBoundsInternal(const gfx::Rect& new_bounds) {
+  const gfx::Rect old_bounds = bounds();
+  bool was_move = old_bounds.size() == new_bounds.size();
+  layer_->SetBounds(new_bounds);
+
+  if (layout_manager_.get())
+    layout_manager_->OnWindowResized();
+  if (delegate_)
+    delegate_->OnBoundsChanged(old_bounds, new_bounds);
+  if (IsVisible()) {
+    if (was_move)
+      layer()->ScheduleDraw();
+    else
+      layer()->SchedulePaint(gfx::Rect());
+  }
+}
+
 void Window::SetVisible(bool visible) {
   bool was_visible = IsVisible();
   layer_->SetVisible(visible);
   bool is_visible = IsVisible();
   if (was_visible != is_visible) {
     SchedulePaint();
     if (delegate_)
       delegate_->OnWindowVisibilityChanged(is_visible);
   }
 }
@@ skipping 48 matching lines @@
   }
 
   return delegate_ ? this : NULL;
 }
 
 void Window::OnPaintLayer(gfx::Canvas* canvas) {
   delegate_->OnPaint(canvas);
 }
 
 }  // namespace aura