Do not create workspace for fullscreen.

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/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
@@ skipping 173 matching lines @@
     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 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) &&
-        ((new_state == ui::SHOW_STATE_FULLSCREEN &&
-          wm::IsWindowStateNormal(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);
+    ShowStateChanged(window, old_state);
 
     // 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))
-      SetMaximizedOrFullscreenBounds(window);
+    SetMaximizedOrFullscreenBounds(window);
   }
 
   if (key == aura::client::kAlwaysOnTopKey &&
       window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     internal::AlwaysOnTopController* controller =
         GetRootWindowController(window->GetRootWindow())->
             always_on_top_controller();
     controller->GetContainer(window)->AddChild(window);
   }
 }
 
 void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   if (root_window_ == window)
     AdjustWindowSizesForScreenChange(ADJUST_WINDOW_SCREEN_SIZE_CHANGED);
 }
 
 void WorkspaceLayoutManager::ShowStateChanged(
     Window* window,
-    ui::WindowShowState last_show_state,
-    ui::Layer* cloned_layer) {
+    ui::WindowShowState last_show_state) {
   if (wm::IsWindowMinimized(window)) {
-    DCHECK(!cloned_layer);
     // Save the previous show state so that we can correctly restore it.
     window->SetProperty(aura::client::kRestoreShowStateKey, last_show_state);
     views::corewm::SetWindowVisibilityAnimationType(
         window, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
     workspace_manager()->OnWorkspaceWindowShowStateChanged(
-        workspace_, window, last_show_state, NULL);
+        workspace_, window, last_show_state);
     window->Hide();
     if (wm::IsActiveWindow(window))
       wm::DeactivateWindow(window);
   } else {
     if ((window->TargetVisibility() ||
          last_show_state == ui::SHOW_STATE_MINIMIZED) &&
         !window->layer()->visible()) {
       // The layer may be hidden if the window was previously minimized. Make
       // sure it's visible.
       window->Show();
     }
     if (last_show_state == ui::SHOW_STATE_MINIMIZED &&
         !wm::IsWindowMaximized(window) &&
         !wm::IsWindowFullscreen(window)) {
       window->ClearProperty(internal::kWindowRestoresToRestoreBounds);
     }
     workspace_manager()->OnWorkspaceWindowShowStateChanged(
-        workspace_, window, last_show_state, cloned_layer);
+        workspace_, window, last_show_state);
   }
 }
 
 void WorkspaceLayoutManager::AdjustWindowSizesForScreenChange(
     AdjustWindowReason reason) {
   // Don't do any adjustments of the insets while we are in screen locked mode.
   // This would happen if the launcher was auto hidden before the login screen
   // was shown and then gets shown when the login screen gets presented.
   if (reason == ADJUST_WINDOW_DISPLAY_INSETS_CHANGED &&
       Shell::GetInstance()->session_state_delegate()->IsScreenLocked())
@@ skipping 71 matching lines @@
       }
       ClearRestoreBounds(window);
       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED:
       CrossFadeToBounds(window, ScreenAsh::GetMaximizedWindowBoundsInParent(
           window->parent()->parent()));
       break;
     case ui::SHOW_STATE_FULLSCREEN:
-      SetMaximizedOrFullscreenBounds(window);
+      CrossFadeToBounds(window, ScreenAsh::GetDisplayBoundsInParent(
+          window->parent()->parent()));
       break;
 
     default:
       break;
   }
 }
 
 bool WorkspaceLayoutManager::SetMaximizedOrFullscreenBounds(
     aura::Window* window) {
   if (!GetTrackedByWorkspace(window))
@@ skipping 16 matching lines @@
   }
   return false;
 }
 
 WorkspaceManager* WorkspaceLayoutManager::workspace_manager() {
   return workspace_->workspace_manager();
 }
 
 }  // namespace internal
 }  // namespace ash