Do not create a workspace for a maximized window.

ash/wm/workspace/workspace_layout_manager.cc

 // Copyright (c) 2012 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/workspace/workspace_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/screen_ash.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
@@ skipping 56 matching lines @@
                                              aura::Window* window) {
   if (window->GetProperty(aura::client::kConstrainedWindowKey)) {
     BoundsMap::const_iterator i = bounds_map.find(window);
     if (i != bounds_map.end())
       window->SetBounds(i->second);
   }
   for (size_t i = 0; i < window->children().size(); ++i)
     ResetConstrainedWindowBoundsIfNecessary(bounds_map, window->children()[i]);
 }
 
+bool IsMaximizedState(ui::WindowShowState state) {
+  return state == ui::SHOW_STATE_MAXIMIZED ||
+      state == ui::SHOW_STATE_FULLSCREEN;
+}
+
 }  // namespace
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(Workspace* workspace)
     : root_window_(workspace->window()->GetRootWindow()),
       workspace_(workspace),
       work_area_(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
                      workspace->window()->parent())) {
   Shell::GetInstance()->AddShellObserver(this);
   root_window_->AddRootWindowObserver(this);
   root_window_->AddObserver(this);
@@ skipping 82 matching lines @@
 
 void WorkspaceLayoutManager::OnWindowPropertyChanged(Window* window,
                                                      const void* key,
                                                      intptr_t old) {
   if (key == aura::client::kShowStateKey) {
     ui::WindowShowState old_state = static_cast<ui::WindowShowState>(old);
     ui::WindowShowState new_state =
         window->GetProperty(aura::client::kShowStateKey);
     if (old_state != ui::SHOW_STATE_MINIMIZED &&
         GetRestoreBoundsInScreen(window) == NULL &&
-        WorkspaceManager::IsMaximizedState(new_state) &&
-        !WorkspaceManager::IsMaximizedState(old_state)) {
+        IsMaximizedState(new_state) &&
+        !IsMaximizedState(old_state)) {
       SetRestoreBoundsInParent(window, window->bounds());
     }
     // When restoring from a minimized state, we want to restore to the
     // previous (maybe L/R maximized) state. Since we do also want to keep the
     // restore rectangle, we set the restore rectangle to the rectangle we want
     // to restore to and restore it after we switched so that it is preserved.
     gfx::Rect restore;
     if (old_state == ui::SHOW_STATE_MINIMIZED &&
         (new_state == ui::SHOW_STATE_NORMAL ||
          new_state == ui::SHOW_STATE_DEFAULT) &&
         GetRestoreBoundsInScreen(window) &&
         !GetWindowAlwaysRestoresToRestoreBounds(window)) {
       restore = *GetRestoreBoundsInScreen(window);
       SetRestoreBoundsInScreen(window, window->GetBoundsInScreen());
     }
 
-    // If maximizing or restoring, clone the layer. WorkspaceManager will use it
-    // (and take ownership of it) when animating. Ideally we could use that of
-    // BaseLayoutManager, but that proves problematic. In particular when
-    // restoring we need to animate on top of the workspace animating in.
+    // If the new state requires |window| to be in a workspace, clone the layer.
+    // WorkspaceManager will use it (and take ownership of it) when animating.
+    // Ideally we could use that of BaseLayoutManager, but that proves
+    // problematic. In particular when restoring we need to animate on top of
+    // the workspace animating in.
     ui::Layer* cloned_layer = NULL;
     BoundsMap bounds_map;
     if (wm::IsActiveWindow(window) &&
-        ((WorkspaceManager::IsMaximizedState(new_state) &&
+        ((new_state == ui::SHOW_STATE_FULLSCREEN &&
           wm::IsWindowStateNormal(old_state)) ||
-         (!WorkspaceManager::IsMaximizedState(new_state) &&
-          WorkspaceManager::IsMaximizedState(old_state) &&
+         (new_state != ui::SHOW_STATE_FULLSCREEN &&
+          old_state == ui::SHOW_STATE_FULLSCREEN &&
           new_state != ui::SHOW_STATE_MINIMIZED))) {
       BuildWindowBoundsMap(window, &bounds_map);
       cloned_layer = views::corewm::RecreateWindowLayers(window, false);
       // Constrained windows don't get their bounds reset when we update the
       // window bounds. Leaving them empty is unexpected, so we reset them now.
       ResetConstrainedWindowBoundsIfNecessary(bounds_map, window);
     }
     UpdateBoundsFromShowState(window);
 
     if (cloned_layer) {
       // Even though we just set the bounds not all descendants may have valid
       // bounds. For example, constrained windows don't resize with the parent.
       // Ensure that all windows that had a bounds before we cloned the layer
       // have a bounds now.
       ResetBoundsIfNecessary(bounds_map, window);
     }
 
     ShowStateChanged(window, old_state, cloned_layer);
 
     // Set the restore rectangle to the previously set restore rectangle.
     if (!restore.IsEmpty())
       SetRestoreBoundsInScreen(window, restore);
   }
 
   if (key == internal::kWindowTrackedByWorkspaceKey &&
       GetTrackedByWorkspace(window)) {
     workspace_manager()->OnTrackedByWorkspaceChanged(workspace_, window);
+    if (wm::IsWindowMaximized(window)) {
+      SetChildBoundsDirect(
+          window, ScreenAsh::GetMaximizedWindowBoundsInParent(
+              window->parent()->parent()));
+    }
   }
 
   if (key == aura::client::kAlwaysOnTopKey &&
       window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     internal::AlwaysOnTopController* controller =
         window->GetRootWindow()->GetProperty(
             internal::kAlwaysOnTopControllerKey);
     controller->GetContainer(window)->AddChild(window);
   }
 }
@@ skipping 141 matching lines @@
   }
   return false;
 }
 
 WorkspaceManager* WorkspaceLayoutManager::workspace_manager() {
   return workspace_->workspace_manager();
 }
 
 }  // namespace internal
 }  // namespace ash