Refactored app window size constraints

The NativeAppWindow subclasses all depend on the minimum and maximum
size constraints state stored in AppWindow. This is problematic when
creating a window for the new bounds API. This patch moves the
constraints state into the NativeAppWindow.

BUG=315471
TEST=browser_tests (AppWindowAPITest.TestSizeConstraints)

Review URL: https://codereview.chromium.org/181383012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@254119 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 277 insertions, 172 deletions

diff --git a/apps/app_window.cc b/apps/app_window.cc
index 443f7b6..57047b2 100644
--- a/apps/app_window.cc
+++ b/apps/app_window.cc
@@ -7,6 +7,7 @@
 #include "apps/app_window_geometry_cache.h"
 #include "apps/app_window_registry.h"
 #include "apps/apps_client.h"
+#include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
@@ -65,14 +66,15 @@ bool IsFullscreen(int fullscreen_types) {
 void SetConstraintProperty(const std::string& name,
                            int value,
                            base::DictionaryValue* bounds_properties) {
-  if (value != AppWindow::SizeConstraints::kUnboundedSize)
+  if (value != SizeConstraints::kUnboundedSize)
     bounds_properties->SetInteger(name, value);
   else
     bounds_properties->Set(name, base::Value::CreateNullValue());
 }
 
 void SetBoundsProperties(const gfx::Rect& bounds,
-                         const AppWindow::SizeConstraints& constraints,
+                         const gfx::Size& min_size,
+                         const gfx::Size& max_size,
                          const std::string& bounds_name,
                          base::DictionaryValue* window_properties) {
   scoped_ptr<base::DictionaryValue> bounds_properties(
@@ -83,8 +85,6 @@ void SetBoundsProperties(const gfx::Rect& bounds,
   bounds_properties->SetInteger("width", bounds.width());
   bounds_properties->SetInteger("height", bounds.height());
 
-  gfx::Size min_size = constraints.GetMinimumSize();
-  gfx::Size max_size = constraints.GetMaximumSize();
   SetConstraintProperty("minWidth", min_size.width(), bounds_properties.get());
   SetConstraintProperty(
       "minHeight", min_size.height(), bounds_properties.get());
@@ -97,62 +97,6 @@ void SetBoundsProperties(const gfx::Rect& bounds,
 
 }  // namespace
 
-AppWindow::SizeConstraints::SizeConstraints()
-    : maximum_size_(kUnboundedSize, kUnboundedSize) {}
-
-AppWindow::SizeConstraints::SizeConstraints(const gfx::Size& min_size,
-                                            const gfx::Size& max_size)
-    : minimum_size_(min_size), maximum_size_(max_size) {}
-
-AppWindow::SizeConstraints::~SizeConstraints() {}
-
-gfx::Size AppWindow::SizeConstraints::ClampSize(gfx::Size size) const {
-  const gfx::Size max_size = GetMaximumSize();
-  if (max_size.width() != kUnboundedSize)
-    size.set_width(std::min(size.width(), GetMaximumSize().width()));
-  if (max_size.height() != kUnboundedSize)
-    size.set_height(std::min(size.height(), GetMaximumSize().height()));
-  size.SetToMax(GetMinimumSize());
-  return size;
-}
-
-bool AppWindow::SizeConstraints::HasMinimumSize() const {
-  return GetMinimumSize().width() != kUnboundedSize ||
-         GetMinimumSize().height() != kUnboundedSize;
-}
-
-bool AppWindow::SizeConstraints::HasMaximumSize() const {
-  const gfx::Size max_size = GetMaximumSize();
-  return max_size.width() != kUnboundedSize ||
-         max_size.height() != kUnboundedSize;
-}
-
-bool AppWindow::SizeConstraints::HasFixedSize() const {
-  return !GetMinimumSize().IsEmpty() && GetMinimumSize() == GetMaximumSize();
-}
-
-gfx::Size AppWindow::SizeConstraints::GetMinimumSize() const {
-  return minimum_size_;
-}
-
-gfx::Size AppWindow::SizeConstraints::GetMaximumSize() const {
-  return gfx::Size(
-      maximum_size_.width() == kUnboundedSize
-          ? kUnboundedSize
-          : std::max(maximum_size_.width(), minimum_size_.width()),
-      maximum_size_.height() == kUnboundedSize
-          ? kUnboundedSize
-          : std::max(maximum_size_.height(), minimum_size_.height()));
-}
-
-void AppWindow::SizeConstraints::set_minimum_size(const gfx::Size& min_size) {
-  minimum_size_ = min_size;
-}
-
-void AppWindow::SizeConstraints::set_maximum_size(const gfx::Size& max_size) {
-  maximum_size_ = max_size;
-}
-
 AppWindow::CreateParams::CreateParams()
     : window_type(AppWindow::WINDOW_TYPE_DEFAULT),
       frame(AppWindow::FRAME_CHROME),
@@ -213,8 +157,6 @@ void AppWindow::Init(const GURL& url,
   CreateParams new_params = LoadDefaultsAndConstrain(params);
   window_type_ = new_params.window_type;
   window_key_ = new_params.window_key;
-  size_constraints_ =
-      SizeConstraints(new_params.minimum_size, new_params.maximum_size);
 
   // Windows cannot be always-on-top in fullscreen mode for security reasons.
   cached_always_on_top_ = new_params.always_on_top;
@@ -578,12 +520,12 @@ void AppWindow::ForcedFullscreen() {
 }
 
 void AppWindow::SetMinimumSize(const gfx::Size& min_size) {
-  size_constraints_.set_minimum_size(min_size);
+  native_app_window_->SetMinimumSize(min_size);
   OnSizeConstraintsChanged();
 }
 
 void AppWindow::SetMaximumSize(const gfx::Size& max_size) {
-  size_constraints_.set_maximum_size(max_size);
+  native_app_window_->SetMaximumSize(max_size);
   OnSizeConstraintsChanged();
 }
 
@@ -646,14 +588,19 @@ void AppWindow::GetSerializedState(base::DictionaryValue* properties) const {
   properties->SetInteger("frameColor", native_app_window_->FrameColor());
 
   gfx::Rect content_bounds = GetClientBounds();
-  SetBoundsProperties(
-      content_bounds, size_constraints(), "innerBounds", properties);
+  SetBoundsProperties(content_bounds,
+                      native_app_window_->GetMinimumSize(),
+                      native_app_window_->GetMaximumSize(),
+                      "innerBounds",
+                      properties);
 
   // TODO(tmdiep): Frame constraints will be implemented in a future patch.
   gfx::Rect frame_bounds = native_app_window_->GetBounds();
-  SizeConstraints frame_constraints;
-  SetBoundsProperties(
-      frame_bounds, frame_constraints, "outerBounds", properties);
+  SetBoundsProperties(frame_bounds,
+                      gfx::Size(),
+                      gfx::Size(),
+                      "outerBounds",
+                      properties);
 }
 
 //------------------------------------------------------------------------------
@@ -716,9 +663,10 @@ void AppWindow::UpdateExtensionAppIcon() {
 }
 
 void AppWindow::OnSizeConstraintsChanged() {
-  native_app_window_->UpdateWindowMinMaxSize();
+  SizeConstraints size_constraints(native_app_window_->GetMinimumSize(),
+                                   native_app_window_->GetMaximumSize());
   gfx::Rect bounds = GetClientBounds();
-  gfx::Size constrained_size = size_constraints_.ClampSize(bounds.size());
+  gfx::Size constrained_size = size_constraints.ClampSize(bounds.size());
   if (bounds.size() != constrained_size) {
     bounds.set_size(constrained_size);
     native_app_window_->SetBounds(bounds);
diff --git a/apps/app_window.h b/apps/app_window.h
index 9551539..8403153 100644
--- a/apps/app_window.h
+++ b/apps/app_window.h
@@ -116,41 +116,6 @@ class AppWindow : public content::NotificationObserver,
     FULLSCREEN_TYPE_FORCED = 1 << 3,
   };
 
-  class SizeConstraints {
-   public:
-    // The value SizeConstraints uses to represent an unbounded width or height.
-    // This is an enum so that it can be declared inline here.
-    enum { kUnboundedSize = 0 };
-
-    SizeConstraints();
-    SizeConstraints(const gfx::Size& min_size, const gfx::Size& max_size);
-    ~SizeConstraints();
-
-    // Returns the bounds with its size clamped to the min/max size.
-    gfx::Size ClampSize(gfx::Size size) const;
-
-    // When gfx::Size is used as a min/max size, a zero represents an unbounded
-    // component. This method checks whether either component is specified.
-    // Note we can't use gfx::Size::IsEmpty as it returns true if either width
-    // or height is zero.
-    bool HasMinimumSize() const;
-    bool HasMaximumSize() const;
-
-    // This returns true if all components are specified, and min and max are
-    // equal.
-    bool HasFixedSize() const;
-
-    gfx::Size GetMaximumSize() const;
-    gfx::Size GetMinimumSize() const;
-
-    void set_minimum_size(const gfx::Size& min_size);
-    void set_maximum_size(const gfx::Size& max_size);
-
-   private:
-    gfx::Size minimum_size_;
-    gfx::Size maximum_size_;
-  };
-
   struct CreateParams {
     CreateParams();
     ~CreateParams();
@@ -342,9 +307,6 @@ class AppWindow : public content::NotificationObserver,
     return app_window_contents_.get();
   }
 
-  // Get the size constraints.
-  const SizeConstraints& size_constraints() const { return size_constraints_; }
-
   // Set whether the window should stay above other windows which are not
   // configured to be always-on-top.
   void SetAlwaysOnTop(bool always_on_top);
@@ -529,9 +491,6 @@ class AppWindow : public content::NotificationObserver,
   // Bit field of FullscreenType.
   int fullscreen_types_;
 
-  // Size constraints on the window.
-  SizeConstraints size_constraints_;
-
   // Show has been called, so the window should be shown once the first visually
   // non-empty paint occurs.
   bool show_on_first_paint_;
diff --git a/apps/apps.gypi b/apps/apps.gypi
index 6ea2c5d..e0031fb 100644
--- a/apps/apps.gypi
+++ b/apps/apps.gypi
@@ -56,6 +56,8 @@
         'saved_files_service.h',
         'saved_files_service_factory.cc',
         'saved_files_service_factory.h',
+        'size_constraints.cc',
+        'size_constraints.h',
         'switches.cc',
         'switches.h',
         'ui/native_app_window.h',
diff --git a/apps/size_constraints.cc b/apps/size_constraints.cc
new file mode 100644
index 0000000..05d4175
--- /dev/null
+++ b/apps/size_constraints.cc
@@ -0,0 +1,65 @@
+// 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 "apps/size_constraints.h"
+
+namespace apps {
+
+SizeConstraints::SizeConstraints()
+    : maximum_size_(kUnboundedSize, kUnboundedSize) {}
+
+SizeConstraints::SizeConstraints(const gfx::Size& min_size,
+                                 const gfx::Size& max_size)
+    : minimum_size_(min_size), maximum_size_(max_size) {}
+
+SizeConstraints::~SizeConstraints() {}
+
+gfx::Size SizeConstraints::ClampSize(gfx::Size size) const {
+  const gfx::Size max_size = GetMaximumSize();
+  if (max_size.width() != kUnboundedSize)
+    size.set_width(std::min(size.width(), GetMaximumSize().width()));
+  if (max_size.height() != kUnboundedSize)
+    size.set_height(std::min(size.height(), GetMaximumSize().height()));
+  size.SetToMax(GetMinimumSize());
+  return size;
+}
+
+bool SizeConstraints::HasMinimumSize() const {
+  return GetMinimumSize().width() != kUnboundedSize ||
+         GetMinimumSize().height() != kUnboundedSize;
+}
+
+bool SizeConstraints::HasMaximumSize() const {
+  const gfx::Size max_size = GetMaximumSize();
+  return max_size.width() != kUnboundedSize ||
+         max_size.height() != kUnboundedSize;
+}
+
+bool SizeConstraints::HasFixedSize() const {
+  return !GetMinimumSize().IsEmpty() && GetMinimumSize() == GetMaximumSize();
+}
+
+gfx::Size SizeConstraints::GetMinimumSize() const {
+  return minimum_size_;
+}
+
+gfx::Size SizeConstraints::GetMaximumSize() const {
+  return gfx::Size(
+      maximum_size_.width() == kUnboundedSize
+          ? kUnboundedSize
+          : std::max(maximum_size_.width(), minimum_size_.width()),
+      maximum_size_.height() == kUnboundedSize
+          ? kUnboundedSize
+          : std::max(maximum_size_.height(), minimum_size_.height()));
+}
+
+void SizeConstraints::set_minimum_size(const gfx::Size& min_size) {
+  minimum_size_ = min_size;
+}
+
+void SizeConstraints::set_maximum_size(const gfx::Size& max_size) {
+  maximum_size_ = max_size;
+}
+
+}  // namespace apps
diff --git a/apps/size_constraints.h b/apps/size_constraints.h
new file mode 100644
index 0000000..1af2692
--- /dev/null
+++ b/apps/size_constraints.h
@@ -0,0 +1,49 @@
+// 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.
+
+#ifndef APPS_SIZE_CONSTRAINTS_H_
+#define APPS_SIZE_CONSTRAINTS_H_
+
+#include "ui/gfx/geometry/size.h"
+
+namespace apps {
+
+class SizeConstraints {
+ public:
+  // The value SizeConstraints uses to represent an unbounded width or height.
+  // This is an enum so that it can be declared inline here.
+  enum { kUnboundedSize = 0 };
+
+  SizeConstraints();
+  SizeConstraints(const gfx::Size& min_size, const gfx::Size& max_size);
+  ~SizeConstraints();
+
+  // Returns the bounds with its size clamped to the min/max size.
+  gfx::Size ClampSize(gfx::Size size) const;
+
+  // When gfx::Size is used as a min/max size, a zero represents an unbounded
+  // component. This method checks whether either component is specified.
+  // Note we can't use gfx::Size::IsEmpty as it returns true if either width
+  // or height is zero.
+  bool HasMinimumSize() const;
+  bool HasMaximumSize() const;
+
+  // This returns true if all components are specified, and min and max are
+  // equal.
+  bool HasFixedSize() const;
+
+  gfx::Size GetMaximumSize() const;
+  gfx::Size GetMinimumSize() const;
+
+  void set_minimum_size(const gfx::Size& min_size);
+  void set_maximum_size(const gfx::Size& max_size);
+
+ private:
+  gfx::Size minimum_size_;
+  gfx::Size maximum_size_;
+};
+
+}  // namespace apps
+
+#endif  // APPS_SIZE_CONSTRAINTS_H_
diff --git a/apps/ui/native_app_window.h b/apps/ui/native_app_window.h
index 3596940..0093a3c 100644
--- a/apps/ui/native_app_window.h
+++ b/apps/ui/native_app_window.h
@@ -72,14 +72,22 @@ class NativeAppWindow : public ui::BaseWindow,
   virtual void ShowWithApp() = 0;
   virtual void HideWithApp() = 0;
 
-  // Updates the minimum and maximum size of the native window with the current
-  // size constraints.
-  virtual void UpdateWindowMinMaxSize() = 0;
-
   // Updates custom entries for the context menu of the app's taskbar/dock/shelf
   // icon.
   virtual void UpdateShelfMenu() = 0;
 
+  // Returns the minimum size constraints of the content.
+  virtual gfx::Size GetMinimumSize() const = 0;
+
+  // Updates the minimum size constraints of the content.
+  virtual void SetMinimumSize(const gfx::Size& size) = 0;
+
+  // Returns the maximum size constraints of the content.
+  virtual gfx::Size GetMaximumSize() const = 0;
+
+  // Updates the maximum size constraints of the content.
+  virtual void SetMaximumSize(const gfx::Size& size) = 0;
+
   virtual ~NativeAppWindow() {}
 };
 
diff --git a/apps/ui/views/native_app_window_views.cc b/apps/ui/views/native_app_window_views.cc
index c356b3d..070851e 100644
--- a/apps/ui/views/native_app_window_views.cc
+++ b/apps/ui/views/native_app_window_views.cc
@@ -37,6 +37,8 @@ void NativeAppWindowViews::Init(AppWindow* app_window,
   frameless_ = create_params.frame == AppWindow::FRAME_NONE;
   transparent_background_ = create_params.transparent_background;
   resizable_ = create_params.resizable;
+  size_constraints_.set_minimum_size(create_params.minimum_size);
+  size_constraints_.set_maximum_size(create_params.maximum_size);
   Observe(app_window_->web_contents());
 
   window_ = new views::Widget;
@@ -201,11 +203,11 @@ views::View* NativeAppWindowViews::GetInitiallyFocusedView() {
 }
 
 bool NativeAppWindowViews::CanResize() const {
-  return resizable_ && !app_window_->size_constraints().HasFixedSize();
+  return resizable_ && !size_constraints_.HasFixedSize();
 }
 
 bool NativeAppWindowViews::CanMaximize() const {
-  return resizable_ && !app_window_->size_constraints().HasMaximumSize() &&
+  return resizable_ && !size_constraints_.HasMaximumSize() &&
          !app_window_->window_type_is_panel();
 }
 
@@ -314,11 +316,11 @@ void NativeAppWindowViews::ViewHierarchyChanged(
 }
 
 gfx::Size NativeAppWindowViews::GetMinimumSize() {
-  return app_window_->size_constraints().GetMinimumSize();
+  return size_constraints_.GetMinimumSize();
 }
 
 gfx::Size NativeAppWindowViews::GetMaximumSize() {
-  return app_window_->size_constraints().GetMaximumSize();
+  return size_constraints_.GetMaximumSize();
 }
 
 void NativeAppWindowViews::OnFocus() {
@@ -404,8 +406,22 @@ void NativeAppWindowViews::HideWithApp() {}
 
 void NativeAppWindowViews::ShowWithApp() {}
 
-void NativeAppWindowViews::UpdateWindowMinMaxSize() {}
-
 void NativeAppWindowViews::UpdateShelfMenu() {}
 
+gfx::Size NativeAppWindowViews::GetMinimumSize() const {
+  return size_constraints_.GetMinimumSize();
+}
+
+void NativeAppWindowViews::SetMinimumSize(const gfx::Size& size) {
+  size_constraints_.set_minimum_size(size);
+}
+
+gfx::Size NativeAppWindowViews::GetMaximumSize() const {
+  return size_constraints_.GetMaximumSize();
+}
+
+void NativeAppWindowViews::SetMaximumSize(const gfx::Size& size) {
+  size_constraints_.set_maximum_size(size);
+}
+
 }  // namespace apps
diff --git a/apps/ui/views/native_app_window_views.h b/apps/ui/views/native_app_window_views.h
index c119b606..d8147f3 100644
--- a/apps/ui/views/native_app_window_views.h
+++ b/apps/ui/views/native_app_window_views.h
@@ -5,6 +5,7 @@
 #ifndef APPS_UI_VIEWS_NATIVE_APP_WINDOW_VIEWS_H_
 #define APPS_UI_VIEWS_NATIVE_APP_WINDOW_VIEWS_H_
 
+#include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/observer_list.h"
 #include "content/public/browser/web_contents_observer.h"
@@ -148,8 +149,11 @@ class NativeAppWindowViews : public NativeAppWindow,
   virtual gfx::Insets GetFrameInsets() const OVERRIDE;
   virtual void HideWithApp() OVERRIDE;
   virtual void ShowWithApp() OVERRIDE;
-  virtual void UpdateWindowMinMaxSize() OVERRIDE;
   virtual void UpdateShelfMenu() OVERRIDE;
+  virtual gfx::Size GetMinimumSize() const OVERRIDE;
+  virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetMaximumSize() const OVERRIDE;
+  virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
 
   // web_modal::WebContentsModalDialogHost implementation.
   virtual gfx::NativeView GetHostView() const OVERRIDE;
@@ -173,6 +177,7 @@ class NativeAppWindowViews : public NativeAppWindow,
   bool frameless_;
   bool transparent_background_;
   bool resizable_;
+  apps::SizeConstraints size_constraints_;
 
   views::UnhandledKeyboardEventHandler unhandled_keyboard_event_handler_;
 
diff --git a/chrome/browser/extensions/api/app_current_window_internal/app_current_window_internal_api.cc b/chrome/browser/extensions/api/app_current_window_internal/app_current_window_internal_api.cc
index 1e4f876..ebba22d 100644
--- a/chrome/browser/extensions/api/app_current_window_internal/app_current_window_internal_api.cc
+++ b/chrome/browser/extensions/api/app_current_window_internal/app_current_window_internal_api.cc
@@ -6,6 +6,7 @@
 
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
+#include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/command_line.h"
 #include "chrome/browser/profiles/profile.h"
@@ -52,7 +53,7 @@ const char kRequiresFramelessWindow[] =
 const char kAlwaysOnTopPermission[] =
     "The \"alwaysOnTopWindows\" permission is required.";
 
-const int kUnboundedSize = apps::AppWindow::SizeConstraints::kUnboundedSize;
+const int kUnboundedSize = apps::SizeConstraints::kUnboundedSize;
 
 }  // namespace
 
@@ -158,7 +159,7 @@ bool AppCurrentWindowInternalSetMinWidthFunction::RunWithWindow(
 
   scoped_ptr<SetMinWidth::Params> params(SetMinWidth::Params::Create(*args_));
   CHECK(params.get());
-  gfx::Size min_size = window->size_constraints().GetMinimumSize();
+  gfx::Size min_size = window->GetBaseWindow()->GetMinimumSize();
   min_size.set_width(params->min_width.get() ?
       *(params->min_width) : kUnboundedSize);
   window->SetMinimumSize(min_size);
@@ -174,7 +175,7 @@ bool AppCurrentWindowInternalSetMinHeightFunction::RunWithWindow(
 
   scoped_ptr<SetMinHeight::Params> params(SetMinHeight::Params::Create(*args_));
   CHECK(params.get());
-  gfx::Size min_size = window->size_constraints().GetMinimumSize();
+  gfx::Size min_size = window->GetBaseWindow()->GetMinimumSize();
   min_size.set_height(params->min_height.get() ?
       *(params->min_height) : kUnboundedSize);
   window->SetMinimumSize(min_size);
@@ -190,7 +191,7 @@ bool AppCurrentWindowInternalSetMaxWidthFunction::RunWithWindow(
 
   scoped_ptr<SetMaxWidth::Params> params(SetMaxWidth::Params::Create(*args_));
   CHECK(params.get());
-  gfx::Size max_size = window->size_constraints().GetMaximumSize();
+  gfx::Size max_size = window->GetBaseWindow()->GetMaximumSize();
   max_size.set_width(params->max_width.get() ?
       *(params->max_width) : kUnboundedSize);
   window->SetMaximumSize(max_size);
@@ -206,7 +207,7 @@ bool AppCurrentWindowInternalSetMaxHeightFunction::RunWithWindow(
 
   scoped_ptr<SetMaxHeight::Params> params(SetMaxHeight::Params::Create(*args_));
   CHECK(params.get());
-  gfx::Size max_size = window->size_constraints().GetMaximumSize();
+  gfx::Size max_size = window->GetBaseWindow()->GetMaximumSize();
   max_size.set_height(params->max_height.get() ?
       *(params->max_height) : kUnboundedSize);
   window->SetMaximumSize(max_size);
diff --git a/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.h b/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.h
index e19f1d4..2527836 100644
--- a/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.h
+++ b/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.h
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "apps/app_window.h"
+#include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/memory/scoped_ptr.h"
@@ -134,9 +135,11 @@ class NativeAppWindowCocoa : public apps::NativeAppWindow,
   // differentiate the reason a window was hidden.
   virtual void ShowWithApp() OVERRIDE;
   virtual void HideWithApp() OVERRIDE;
-  // Calls setContent[Min|Max]Size with the current size constraints.
-  virtual void UpdateWindowMinMaxSize() OVERRIDE;
   virtual void UpdateShelfMenu() OVERRIDE;
+  virtual gfx::Size GetMinimumSize() const OVERRIDE;
+  virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetMaximumSize() const OVERRIDE;
+  virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
 
   // WebContentsObserver implementation.
   virtual void RenderViewCreated(content::RenderViewHost* rvh) OVERRIDE;
@@ -203,6 +206,8 @@ class NativeAppWindowCocoa : public apps::NativeAppWindow,
   bool shows_resize_controls_;
   bool shows_fullscreen_controls_;
 
+  apps::SizeConstraints size_constraints_;
+
   base::scoped_nsobject<NativeAppWindowController> window_controller_;
   NSInteger attention_request_id_;  // identifier from requestUserAttention
 
diff --git a/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.mm b/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.mm
index 73da1fe..cbaaa43 100644
--- a/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.mm
+++ b/chrome/browser/ui/cocoa/apps/native_app_window_cocoa.mm
@@ -319,11 +319,12 @@ NativeAppWindowCocoa::NativeAppWindowCocoa(
     window_class = [ShellFramelessNSWindow class];
   }
 
-  AppWindow::SizeConstraints size_constraints = app_window_->size_constraints();
+  size_constraints_.set_minimum_size(params.minimum_size);
+  size_constraints_.set_maximum_size(params.maximum_size);
   shows_resize_controls_ =
-      params.resizable && !size_constraints.HasFixedSize();
+      params.resizable && !size_constraints_.HasFixedSize();
   shows_fullscreen_controls_ =
-      params.resizable && !size_constraints.HasMaximumSize();
+      params.resizable && !size_constraints_.HasMaximumSize();
   window.reset([[window_class alloc]
       initWithContentRect:cocoa_bounds
                 styleMask:GetWindowStyleMask()
@@ -362,7 +363,10 @@ NativeAppWindowCocoa::NativeAppWindowCocoa(
 
   [[window_controller_ window] setDelegate:window_controller_];
   [window_controller_ setAppWindow:this];
-  UpdateWindowMinMaxSize();
+
+  // Update the size constraints of the NSWindow.
+  SetMinimumSize(params.minimum_size);
+  SetMaximumSize(params.maximum_size);
 
   extension_keybinding_registry_.reset(new ExtensionKeybindingRegistryCocoa(
       Profile::FromBrowserContext(app_window_->browser_context()),
@@ -1033,20 +1037,34 @@ void NativeAppWindowCocoa::UpdateRestoredBounds() {
     restored_bounds_ = [window() frame];
 }
 
-void NativeAppWindowCocoa::UpdateWindowMinMaxSize() {
-  gfx::Size min_size = app_window_->size_constraints().GetMinimumSize();
+void NativeAppWindowCocoa::UpdateShelfMenu() {
+  // TODO(tmdiep): To be implemented for Mac.
+  NOTIMPLEMENTED();
+}
+
+gfx::Size NativeAppWindowCocoa::GetMinimumSize() const {
+  return size_constraints_.GetMinimumSize();
+}
+
+void NativeAppWindowCocoa::SetMinimumSize(const gfx::Size& size) {
+  size_constraints_.set_minimum_size(size);
+
+  gfx::Size min_size = size_constraints_.GetMinimumSize();
   [window() setContentMinSize:NSMakeSize(min_size.width(), min_size.height())];
+}
+
+gfx::Size NativeAppWindowCocoa::GetMaximumSize() const {
+  return size_constraints_.GetMaximumSize();
+}
 
-  gfx::Size max_size = app_window_->size_constraints().GetMaximumSize();
-  const int kUnboundedSize = AppWindow::SizeConstraints::kUnboundedSize;
+void NativeAppWindowCocoa::SetMaximumSize(const gfx::Size& size) {
+  size_constraints_.set_maximum_size(size);
+
+  gfx::Size max_size = size_constraints_.GetMaximumSize();
+  const int kUnboundedSize = apps::SizeConstraints::kUnboundedSize;
   CGFloat max_width = max_size.width() == kUnboundedSize ?
       CGFLOAT_MAX : max_size.width();
   CGFloat max_height = max_size.height() == kUnboundedSize ?
       CGFLOAT_MAX : max_size.height();
   [window() setContentMaxSize:NSMakeSize(max_width, max_height)];
 }
-
-void NativeAppWindowCocoa::UpdateShelfMenu() {
-  // TODO(tmdiep): To be implemented for Mac.
-  NOTIMPLEMENTED();
-}
diff --git a/chrome/browser/ui/gtk/apps/native_app_window_gtk.cc b/chrome/browser/ui/gtk/apps/native_app_window_gtk.cc
index c4e47a0..9244ca0 100644
--- a/chrome/browser/ui/gtk/apps/native_app_window_gtk.cc
+++ b/chrome/browser/ui/gtk/apps/native_app_window_gtk.cc
@@ -96,6 +96,8 @@ NativeAppWindowGtk::NativeAppWindowGtk(AppWindow* app_window,
   if (always_on_top_)
     gtk_window_set_keep_above(window_, TRUE);
 
+  size_constraints_.set_minimum_size(params.minimum_size);
+  size_constraints_.set_maximum_size(params.maximum_size);
   UpdateWindowMinMaxSize();
 
   // In some (older) versions of compiz, raising top-level windows when they
@@ -477,6 +479,33 @@ void NativeAppWindowGtk::OnConfigureDebounced() {
   }
 }
 
+void NativeAppWindowGtk::UpdateWindowMinMaxSize() {
+ GdkGeometry hints;
+ int hints_mask = 0;
+ if (size_constraints_.HasMinimumSize()) {
+   gfx::Size min_size = size_constraints_.GetMinimumSize();
+   hints.min_height = min_size.height();
+   hints.min_width = min_size.width();
+   hints_mask |= GDK_HINT_MIN_SIZE;
+ }
+ if (size_constraints_.HasMaximumSize()) {
+   gfx::Size max_size = size_constraints_.GetMaximumSize();
+   const int kUnboundedSize = apps::SizeConstraints::kUnboundedSize;
+   hints.max_height = max_size.height() == kUnboundedSize ?
+       G_MAXINT : max_size.height();
+   hints.max_width = max_size.width() == kUnboundedSize ?
+       G_MAXINT : max_size.width();
+   hints_mask |= GDK_HINT_MAX_SIZE;
+ }
+ if (hints_mask) {
+   gtk_window_set_geometry_hints(
+       window_,
+       GTK_WIDGET(window_),
+       &hints,
+       static_cast<GdkWindowHints>(hints_mask));
+ }
+}
+
 gboolean NativeAppWindowGtk::OnWindowState(GtkWidget* sender,
                                            GdkEventWindowState* event) {
   state_ = event->new_window_state;
@@ -705,34 +734,25 @@ gfx::Insets NativeAppWindowGtk::GetFrameInsets() const {
 void NativeAppWindowGtk::HideWithApp() {}
 void NativeAppWindowGtk::ShowWithApp() {}
 
-void NativeAppWindowGtk::UpdateWindowMinMaxSize() {
-  GdkGeometry hints;
-  int hints_mask = 0;
-  if (app_window_->size_constraints().HasMinimumSize()) {
-    gfx::Size min_size = app_window_->size_constraints().GetMinimumSize();
-    hints.min_height = min_size.height();
-    hints.min_width = min_size.width();
-    hints_mask |= GDK_HINT_MIN_SIZE;
-  }
-  if (app_window_->size_constraints().HasMaximumSize()) {
-    gfx::Size max_size = app_window_->size_constraints().GetMaximumSize();
-    const int kUnboundedSize = AppWindow::SizeConstraints::kUnboundedSize;
-    hints.max_height = max_size.height() == kUnboundedSize ?
-        G_MAXINT : max_size.height();
-    hints.max_width = max_size.width() == kUnboundedSize ?
-        G_MAXINT : max_size.width();
-    hints_mask |= GDK_HINT_MAX_SIZE;
-  }
-  if (hints_mask) {
-    gtk_window_set_geometry_hints(
-        window_,
-        GTK_WIDGET(window_),
-        &hints,
-        static_cast<GdkWindowHints>(hints_mask));
-  }
-}
-
 void NativeAppWindowGtk::UpdateShelfMenu() {
   // TODO(tmdiep): To be implemented for GTK.
   NOTIMPLEMENTED();
 }
+
+gfx::Size NativeAppWindowGtk::GetMinimumSize() const {
+ return size_constraints_.GetMinimumSize();
+}
+
+void NativeAppWindowGtk::SetMinimumSize(const gfx::Size& size) {
+ size_constraints_.set_minimum_size(size);
+ UpdateWindowMinMaxSize();
+}
+
+gfx::Size NativeAppWindowGtk::GetMaximumSize() const {
+ return size_constraints_.GetMaximumSize();
+}
+
+void NativeAppWindowGtk::SetMaximumSize(const gfx::Size& size) {
+ size_constraints_.set_maximum_size(size);
+ UpdateWindowMinMaxSize();
+}
diff --git a/chrome/browser/ui/gtk/apps/native_app_window_gtk.h b/chrome/browser/ui/gtk/apps/native_app_window_gtk.h
index 6f43ec5..0ba3edb 100644
--- a/chrome/browser/ui/gtk/apps/native_app_window_gtk.h
+++ b/chrome/browser/ui/gtk/apps/native_app_window_gtk.h
@@ -8,6 +8,7 @@
 #include <gtk/gtk.h>
 
 #include "apps/app_window.h"
+#include "apps/size_constraints.h"
 #include "apps/ui/native_app_window.h"
 #include "base/observer_list.h"
 #include "base/timer/timer.h"
@@ -84,9 +85,12 @@ class NativeAppWindowGtk : public apps::NativeAppWindow,
   virtual gfx::Insets GetFrameInsets() const OVERRIDE;
   virtual void HideWithApp() OVERRIDE;
   virtual void ShowWithApp() OVERRIDE;
-  // Calls gtk_window_set_geometry_hints with the current size constraints.
-  virtual void UpdateWindowMinMaxSize() OVERRIDE;
   virtual void UpdateShelfMenu() OVERRIDE;
+  // Calls gtk_window_set_geometry_hints with the current size constraints.
+  virtual gfx::Size GetMinimumSize() const OVERRIDE;
+  virtual void SetMinimumSize(const gfx::Size& size) OVERRIDE;
+  virtual gfx::Size GetMaximumSize() const OVERRIDE;
+  virtual void SetMaximumSize(const gfx::Size& size) OVERRIDE;
 
   // web_modal::WebContentsModalDialogHost implementation.
   virtual gfx::NativeView GetHostView() const OVERRIDE;
@@ -127,6 +131,8 @@ class NativeAppWindowGtk : public apps::NativeAppWindow,
 
   void OnConfigureDebounced();
 
+  void UpdateWindowMinMaxSize();
+
   apps::AppWindow* app_window_;  // weak - AppWindow owns NativeAppWindow.
 
   GtkWindow* window_;
@@ -168,6 +174,9 @@ class NativeAppWindowGtk : public apps::NativeAppWindow,
   // this flag enabled.
   bool always_on_top_;
 
+  // The size constraints of the window.
+  apps::SizeConstraints size_constraints_;
+
   // The current window cursor.  We set it to a resize cursor when over the
   // custom frame border.  We set it to NULL if we want the default cursor.
   GdkCursor* frame_cursor_;