[Ash] Only snap windows that can maximize.

ash/wm/window_state.cc

 // Copyright 2013 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/window_state.h"
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell_window_ids.h"
@@ skipping 123 matching lines @@
 bool WindowState::IsActive() const {
   return IsActiveWindow(window_);
 }
 
 bool WindowState::IsDocked() const {
   return window_->parent() &&
          window_->parent()->id() == kShellWindowId_DockedContainer;
 }
 
 bool WindowState::CanMaximize() const {
+  if (window_->delegate()) {
+    gfx::Size max_size = window_->delegate()->GetMaximumSize();
+    if (max_size.width() || max_size.height())
+      return false;
+  }
+
   return window_->GetProperty(aura::client::kCanMaximizeKey);

[oshima, 2014/09/11 01:00:05]

This should be

window->GetProperty(aura::client::kCanMaximizeKey) &&
(delegate && delegate->GetMaximumSize().IsEmpty());

[jackhou1, 2014/09/11 01:52:42]

Ah I see.

BTW, GetMaximumSize will return 0x200 if only the height is set. IsEmpty is true
in this case, even though the size is constrained.

 }
 
 bool WindowState::CanMinimize() const {
   RootWindowController* controller = RootWindowController::ForWindow(window_);
   if (!controller)
     return false;
   aura::Window* lockscreen =
       controller->GetContainer(kShellWindowId_LockScreenContainersContainer);
   if (lockscreen->Contains(window_))
     return false;
 
   return true;
 }
 
 bool WindowState::CanResize() const {
   return window_->GetProperty(aura::client::kCanResizeKey);
 }
 
 bool WindowState::CanActivate() const {
   return ::wm::CanActivateWindow(window_);
 }
 
 bool WindowState::CanSnap() const {
   if (!CanResize() || window_->type() == ui::wm::WINDOW_TYPE_PANEL ||
       ::wm::GetTransientParent(window_))
     return false;
-  // If a window has a maximum size defined, snapping may make it too big.
-  // TODO(oshima): We probably should snap if possible.
-  return window_->delegate() ? window_->delegate()->GetMaximumSize().IsEmpty() :
-                              true;
+  // If a window cannot be maximized, assume it cannot snap either.
+  // TODO(oshima): We should probably snap if the maximum size is greater than
+  // the snapped size.
+  return CanMaximize();
 }
 
 bool WindowState::HasRestoreBounds() const {
   return window_->GetProperty(aura::client::kRestoreBoundsKey) != NULL;
 }
 
 void WindowState::Maximize() {
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 }
 
@@ skipping 265 matching lines @@
   }
   return settings;
 }
 
 const WindowState* GetWindowState(const aura::Window* window) {
   return GetWindowState(const_cast<aura::Window*>(window));
 }
 
 }  // namespace wm
 }  // namespace ash