Selecting an app window from the overview mode maximizes the window only if it's maximizable

athena/wm/window_manager_impl.cc

 // 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 "athena/wm/window_manager_impl.h"
 
 #include <algorithm>
 
 #include "athena/screen/public/screen_manager.h"
 #include "athena/util/container_priorities.h"
 #include "athena/wm/bezel_controller.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/title_drag_controller.h"
 #include "athena/wm/window_list_provider_impl.h"
 #include "athena/wm/window_overview_mode.h"
 #include "base/bind.h"
 #include "base/logging.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/wm/core/shadow_controller.h"
 #include "ui/wm/core/transient_window_manager.h"
 #include "ui/wm/core/window_util.h"
 #include "ui/wm/core/wm_state.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/window_types.h"
 
 namespace athena {
 namespace {
 class WindowManagerImpl* instance = nullptr;
 
 void SetWindowState(aura::Window* window,
                     const gfx::Rect& bounds,
                     const gfx::Transform& transform) {
   window->SetBounds(bounds);
   window->SetTransform(transform);
 }
 
+// Tests whether the given window can be maximized
+bool CanWindowMaximize(const aura::Window* const window) {
+  const aura::WindowDelegate* delegate = window->delegate();
+  const bool no_max_size =
+      !delegate || delegate->GetMaximumSize().IsEmpty();
+  return no_max_size &&
+         window->GetProperty(aura::client::kCanMaximizeKey) &&
+         window->GetProperty(aura::client::kCanResizeKey);
+}
+
 }  // namespace
 
 class AthenaContainerLayoutManager : public aura::LayoutManager {
  public:
   AthenaContainerLayoutManager();
   ~AthenaContainerLayoutManager() override;
 
  private:
   // aura::LayoutManager:
   void OnWindowResized() override;
@@ skipping 31 matching lines @@
   for (aura::Window::Windows::const_iterator iter = list.begin();
        iter != list.end();
        ++iter) {
     aura::Window* window = *iter;
     if (is_splitview) {
       if (window == instance->split_view_controller_->left_window())
         window->SetBounds(gfx::Rect(split_size));
       else if (window == instance->split_view_controller_->right_window())
         window->SetBounds(
             gfx::Rect(gfx::Point(split_size.width(), 0), split_size));
-      else
+      else if (CanWindowMaximize(window))
+          window->SetBounds(gfx::Rect(work_area));
+    } else if (CanWindowMaximize(window))
         window->SetBounds(gfx::Rect(work_area));
-    } else {
-      window->SetBounds(gfx::Rect(work_area));
-    }
   }
 }
 
 void AthenaContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   // TODO(oshima): Split view modes needs to take the transient window into
   // account.
   if (wm::GetTransientParent(child)) {
     wm::TransientWindowManager::Get(child)
         ->set_parent_controls_visibility(true);
   }
 }
 
 void AthenaContainerLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnWindowRemovedFromLayout(
     aura::Window* child) {
 }
 
 void AthenaContainerLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
+  if (visible && CanWindowMaximize(child)) {
+    // Make sure we're resizing a window that actually exists in the window list
+    // to avoid resizing the divider in the split mode.
+    if(instance->window_list_provider_->IsWindowInList(child)) {
+       child->SetBounds(
+          gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area());
+    }
+  }
 }
 
 void AthenaContainerLayoutManager::SetChildBounds(
     aura::Window* child,
     const gfx::Rect& requested_bounds) {
   if (!requested_bounds.IsEmpty())
     SetChildBoundsDirect(child, requested_bounds);
 }
 
 WindowManagerImpl::WindowManagerImpl() {
@@ skipping 152 matching lines @@
   wm::ActivateWindow(window);
 
   if (split_view_controller_->IsSplitViewModeActive()) {
     split_view_controller_->DeactivateSplitMode();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_, OnSplitViewModeExit());
   }
   // If |window| does not have the size of the work-area, then make sure it is
   // resized.
   const gfx::Size work_area =
       gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
-  if (window->GetTargetBounds().size() != work_area) {
+
+  // Resize to the screen bounds only if the window is maximize-able, and
+  // is not already maximized
+  if (window->GetTargetBounds().size() != work_area &&
+      CanWindowMaximize(window)) {
     const gfx::Rect& window_bounds = window->bounds();
     const gfx::Rect desired_bounds(work_area);
     gfx::Transform transform;
     transform.Translate(desired_bounds.x() - window_bounds.x(),
                         desired_bounds.y() - window_bounds.y());
     transform.Scale(desired_bounds.width() / window_bounds.width(),
                     desired_bounds.height() / window_bounds.height());
     ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
@@ skipping 160 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::Get() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena