[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 {
-  return window_->GetProperty(aura::client::kCanMaximizeKey);
+  // Window must have the kCanMaximizeKey and have no maximum width or height.
+  if (!window()->GetProperty(aura::client::kCanMaximizeKey) ||
+      !window_->delegate()) {
+    return false;
+  }
+

[Mr4D (OOO till 08-26), 2014/09/11 20:24:17]

A window which can be maximized and has a maximum size beyond the x and y extent
of the screen is potentially be maximizable. Is it not? 

[oshima, 2014/09/11 20:32:14]

potentially yes, but that conflicts when the display size changes.
I think it's safe to assume that if an application has a limit on size,
it does not want to be maximized.

+  gfx::Size max_size = window_->delegate()->GetMaximumSize();
+  return !max_size.width() && !max_size.height();
 }
 
 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