Do not create a workspace for a maximized window.

ash/wm/workspace/workspace_manager_unittest.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_manager.h"
 
 #include <map>
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
@@ skipping 131 matching lines @@
 
   bool GetWindowOverlapsShelf() {
     return shelf_layout_manager()->window_overlaps_shelf();
   }
 
   Workspace* FindBy(aura::Window* window) const {
     return manager_->FindBy(window);
   }
 
   std::string WorkspaceStateString(Workspace* workspace) {
-    return (workspace->is_maximized() ? "M" : "") +
+    return (workspace->is_fullscreen() ? "M" : "") +

[James Cook, 2013/06/06 15:38:00]

It's a little strange that fullscreen is "M". I would expect "F". :-)

[Jun Mukai, 2013/06/06 18:31:05]

Done.

         base::IntToString(static_cast<int>(
                               workspace->window()->children().size()));
   }
 
   int active_index() {
     return static_cast<int>(
         manager_->FindWorkspace(manager_->active_workspace_) -
         manager_->workspaces_.begin());
   }
 
@@ skipping 90 matching lines @@
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
 
   EXPECT_EQ("0,0 250x251", w1->bounds().ToString());
 
   // Maximize the window.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
-  // Should be 2 workspaces, the second maximized with w1.
-  ASSERT_EQ("0 M1 active=1", StateString());
-  EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
+  // Should be 1 workspace.
+  ASSERT_EQ("1 active=0", StateString());
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ(ScreenAsh::GetMaximizedWindowBoundsInParent(w1.get()).width(),
             w1->bounds().width());
   EXPECT_EQ(ScreenAsh::GetMaximizedWindowBoundsInParent(w1.get()).height(),
             w1->bounds().height());
 
   // Restore the window.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 
-  // Should be 1 workspace for the desktop.
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ("0,0 250x251", w1->bounds().ToString());
 }
 
 // Assertions around closing the last window in a workspace.
 TEST_F(WorkspaceManagerTest, CloseLastWindowInWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w1.get());
 
-  // Should be 1 workspace and 1 pending, !maximized and maximized. The second
-  // workspace is pending since the window wasn't active.
-  ASSERT_EQ("1 P=M1 active=0", StateString());
-  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
+  // Maximized window will be in the same workspace.
+  ASSERT_EQ("2 active=0", StateString());
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[1]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[0]);
 
   // Close w2.
   w2.reset();
 
   // Should have one workspace.
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_TRUE(w1->IsVisible());
 }
 
 // Assertions around adding a maximized window when empty.
 TEST_F(WorkspaceManagerTest, AddMaximizedWindowWhenEmpty) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
   wm::ActivateWindow(w1.get());
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
   gfx::Rect work_area(
       ScreenAsh::GetMaximizedWindowBoundsInParent(w1.get()));
   EXPECT_EQ(work_area.width(), w1->bounds().width());
   EXPECT_EQ(work_area.height(), w1->bounds().height());
 
-  // Should be 2 workspaces (since we always keep the desktop).
-  ASSERT_EQ("0 M1 active=1", StateString());
-  EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
+  ASSERT_EQ("1 active=0", StateString());
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
 }
 
 // Assertions around two windows and toggling one to be maximized.
 TEST_F(WorkspaceManagerTest, MaximizeWithNormalWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
 
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
 
-  // Should now be two workspaces.
-  ASSERT_EQ("1 M1 active=1", StateString());
+  // Both w1 and w2 should be in the same workspace.
+  ASSERT_EQ("2 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
-  EXPECT_EQ(w2.get(), workspaces()[1]->window()->children()[0]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
 
   gfx::Rect work_area(ScreenAsh::GetMaximizedWindowBoundsInParent(w1.get()));
   EXPECT_EQ(work_area.width(), w2->bounds().width());
   EXPECT_EQ(work_area.height(), w2->bounds().height());
 
-  // Restore w2, which should then go back to one workspace.
+  // Restore w2
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("2 active=0", StateString());
   EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
   EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
   EXPECT_EQ(50, w2->bounds().width());
   EXPECT_EQ(51, w2->bounds().height());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 }
 
 // Assertions around two maximized windows.
 TEST_F(WorkspaceManagerTest, TwoMaximized) {
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->Show();
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("1 M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
-  ASSERT_EQ("0 M1 M1 active=2", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // The last stacked window (|w2|) should be last since it was maximized last.
-  EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
-  EXPECT_EQ(w2.get(), workspaces()[2]->window()->children()[0]);
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
 }
 
 // Get the index of the layer inside its parent. This index can be used to
 // determine the z-order / draw-order of objects in the render tree.
 size_t IndexOfLayerInParent(ui::Layer* layer) {
   ui::Layer* parent = layer->parent();
   for (size_t i = 0; i < parent->children().size(); i++) {
     if (layer == parent->children()[i])
       return i;
   }
   // This should never be reached.
   NOTREACHED();
   return 0;
 }
 
 // Make sure that the layer z-order is correct for the time of the animation
 // when in a workspace with a normal and a maximized window the normal window
 // gets maximized. See crbug.com/232399.
 TEST_F(WorkspaceManagerTest, MaximizeSecondInWorkspace) {
   // Create a maximized window.
   scoped_ptr<Window> w1(CreateTestWindow());
   ASSERT_EQ(1U, w1->layer()->parent()->children().size());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   wm::ActivateWindow(w1.get());
   // There are two workspaces: A normal and a maximized one.
-  ASSERT_EQ("0 M1 active=1", StateString());
+  ASSERT_EQ("1 active=0", StateString());
 
   // Create a second window and make it part of the maximized workspace.
   scoped_ptr<Window> w2(CreateAppTestWindow(w1->parent()));
   w2->SetBounds(gfx::Rect(0, 0, 50, 51));
   w2->Show();
   wm::ActivateWindow(w2.get());
   // There are still two workspaces and two windows in the (maximized)
   // workspace.
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   ASSERT_EQ(w1->layer()->parent()->children()[0], w1->layer());
   ASSERT_EQ(w1->layer()->parent()->children()[1], w2->layer());
 
   // Now we need to enable all animations since the incorrect layer ordering we
   // want to test against happens only while the animation is going on.
   scoped_ptr<ui::ScopedAnimationDurationScaleMode> animation_duration(
       new ui::ScopedAnimationDurationScaleMode(
           ui::ScopedAnimationDurationScaleMode::FAST_DURATION));
 
-  ui::Layer* old_w2_layer = w2->layer();
-
   // Maximize the second window and make sure that the workspace changes.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
 
   // Check the correct window hierarchy - (|w2|) should be last since it was
   // maximized last.
-  ASSERT_EQ("0 M1 M1 active=2", StateString());
-  EXPECT_EQ(3U, workspaces().size());
-  EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
-  EXPECT_EQ(w2.get(), workspaces()[2]->window()->children()[0]);
-
-  // Check the workspace layer visibility.
-  EXPECT_EQ(1, workspaces()[1]->window()->layer()->opacity());
-  EXPECT_EQ(1, workspaces()[2]->window()->layer()->opacity());
-
-  // Check that |w2| got a new layer and that the old layer is still visible,
-  // while the new one is not. Further and foremost the old layer should be a
-  // member of the workspace's window and it should be the second last of the
-  // list to be properly stacked while the animation is going on.
-  EXPECT_NE(w2->layer(), old_w2_layer);
-  EXPECT_EQ(0, w2->layer()->opacity());
-  EXPECT_EQ(1, old_w2_layer->opacity());
-
-  // For the animation to look right we need the following ordering:
-  // workspace_1_layer_index < old_layer_index < workspace_2_layer_index.
-  ASSERT_EQ(workspaces()[1]->window()->parent()->layer(),
-            old_w2_layer->parent());
-  const size_t workspace_1_layer_index = IndexOfLayerInParent(
-      workspaces()[1]->window()->layer());
-  const size_t workspace_2_layer_index = IndexOfLayerInParent(
-      workspaces()[2]->window()->layer());
-  const size_t old_layer_index = IndexOfLayerInParent(old_w2_layer);
-  EXPECT_LT(workspace_1_layer_index, old_layer_index);
-  EXPECT_LT(old_layer_index, workspace_2_layer_index);
+  ASSERT_EQ("2 active=0", StateString());
+  EXPECT_EQ(1U, workspaces().size());
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
 }
 
 // Makes sure requests to change the bounds of a normal window go through.
 TEST_F(WorkspaceManagerTest, ChangeBoundsOfNormalWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
 
   // Setting the bounds should go through since the window is in the normal
   // workspace.
   w1->SetBounds(gfx::Rect(0, 0, 200, 500));
@@ skipping 58 matching lines @@
   w2->SetBounds(gfx::Rect(0, 0, 250, 251));
   w1->AddTransientChild(w2.get());
 
   w1->Show();
 
   scoped_ptr<Window> w3(CreateTestWindow());
   w3->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w3->Show();
   wm::ActivateWindow(w3.get());
 
-  EXPECT_FALSE(w1->layer()->IsDrawn());
+  EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
   EXPECT_TRUE(w3->layer()->IsDrawn());
 
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
-  EXPECT_FALSE(w3->layer()->IsDrawn());
+  EXPECT_TRUE(w3->layer()->IsDrawn());
 }
 
 // Persists-across-all-workspace flag should not cause a transient child
 // to be activated at desktop workspace.
 TEST_F(WorkspaceManagerTest, PersistsTransientChildStayInSameWorkspace) {
   scoped_ptr<Window> w1(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w1.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
   wm::ActivateWindow(w1.get());
-  ASSERT_EQ("0 M1 active=1", StateString());
+  ASSERT_EQ("1 active=0", StateString());
 
   scoped_ptr<Window> w2(CreateTestWindowUnparented());
   w1->AddTransientChild(w2.get());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   SetDefaultParentByPrimaryRootWindow(w2.get());
   w2->Show();
   wm::ActivateWindow(w2.get());
 
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 }
 
 // Assertions around minimizing a single window.
 TEST_F(WorkspaceManagerTest, MinimizeSingleWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
 
   w1->Show();
   ASSERT_EQ("1 active=0", StateString());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_FALSE(w1->layer()->IsDrawn());
 
   // Show the window.
   w1->Show();
   EXPECT_TRUE(wm::IsWindowNormal(w1.get()));
   ASSERT_EQ("1 active=0", StateString());
   EXPECT_TRUE(w1->layer()->IsDrawn());
 }
 
 // Assertions around minimizing a maximized window.
 TEST_F(WorkspaceManagerTest, MinimizeMaximizedWindow) {
   // Two windows, w1 normal, w2 maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->Show();
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // Minimize w2.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  ASSERT_EQ("1 P=M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
 
   // Show the window, which should trigger unminimizing.
   w2->Show();
-  ASSERT_EQ("1 P=M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   EXPECT_TRUE(wm::IsWindowMaximized(w2.get()));
-  EXPECT_FALSE(w1->layer()->IsDrawn());
+  EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_TRUE(w2->layer()->IsDrawn());
 
   // Minimize the window, which should hide the window and activate another.
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
   EXPECT_FALSE(w2->layer()->IsDrawn());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
   // Make the window normal.
@@ skipping 91 matching lines @@
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
 
   // Create another window, maximized.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w2->Show();
   wm::ActivateWindow(w2.get());
-  EXPECT_EQ(1, active_index());
+  EXPECT_EQ(0, active_index());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
 
   // Switch to w1.
   wm::ActivateWindow(w1.get());
   EXPECT_EQ(0, active_index());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
   EXPECT_EQ(ScreenAsh::GetMaximizedWindowBoundsInParent(
                 w2->parent()).ToString(),
             w2->bounds().ToString());
 
   // Switch to w2.
   wm::ActivateWindow(w2.get());
-  EXPECT_EQ(1, active_index());
+  EXPECT_EQ(0, active_index());
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
   EXPECT_EQ(ScreenAsh::GetMaximizedWindowBoundsInParent(w2.get()).ToString(),
             w2->bounds().ToString());
 
   // Turn off auto-hide, switch back to w2 (maximized) and verify overlap.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   wm::ActivateWindow(w2.get());
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   // Move w1 to overlap shelf, it shouldn't change window overlaps shelf since
   // the window isn't in the visible workspace.
   w1->SetBounds(touches_shelf_bounds);
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
-  // Activate w1. Since w1 is visible the overlap state should be true.
+  // Activate w1. Although w1 is visible, the overlap state is still false since
+  // w2 is maximized.
   wm::ActivateWindow(w1.get());
+  EXPECT_FALSE(GetWindowOverlapsShelf());
+
+  // Restore w2.
+  w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_TRUE(GetWindowOverlapsShelf());
 }
 
 // Verifies persist across all workspaces.
 TEST_F(WorkspaceManagerTest, PersistAcrossAllWorkspaces) {
   // Create a maximized window.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   wm::ActivateWindow(w1.get());
-  ASSERT_EQ("0 M1 active=1", StateString());
+  ASSERT_EQ("1 active=0", StateString());
 
   // Create a window that persists across all workspaces. It should be placed in
   // the current maximized workspace.
   scoped_ptr<Window> w2(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // Activate w2, which should move it to the 2nd workspace.
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // Restoring w2 should drop the persists window back to the desktop, and drop
   // it to the bottom of the stack.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("2 active=0", StateString());
-  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[0]);
-  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[1]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
 
   // Repeat, but this time minimize. The minimized window should end up in
   // pending.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  ASSERT_EQ("1 P=M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   w2.reset(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
-  ASSERT_EQ("1 P=M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("1 P=M1 active=0", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  ASSERT_EQ("1 P=M1 active=0", StateString());
-  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[0]);
+  ASSERT_EQ("2 active=0", StateString());
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
 }
 
 // Verifies that when a window persists across all workpaces is activated that
 // it moves to the current workspace.
 TEST_F(WorkspaceManagerTest, ActivatePersistAcrossAllWorkspacesWhenNotActive) {
   // Create a window that persists across all workspaces.
   scoped_ptr<Window> w2(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
   ASSERT_EQ("1 active=0", StateString());
 
   // Create a maximized window.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   wm::ActivateWindow(w1.get());
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // Activate the persists across all workspace window. It should move to the
   // current workspace.
   wm::ActivateWindow(w2.get());
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   // The window that persists across all workspaces should be moved to the top
   // of the stacking order.
-  EXPECT_EQ(w1.get(), workspaces()[1]->window()->children()[0]);
-  EXPECT_EQ(w2.get(), workspaces()[1]->window()->children()[1]);
+  EXPECT_EQ(w1.get(), workspaces()[0]->window()->children()[0]);
+  EXPECT_EQ(w2.get(), workspaces()[0]->window()->children()[1]);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
 }
 
 // Verifies Show()ing a minimized window that persists across all workspaces
 // unminimizes the window.
 TEST_F(WorkspaceManagerTest, ShowMinimizedPersistWindow) {
   // Create a window that persists across all workspaces.
   scoped_ptr<Window> w1(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w1.get(),
@@ skipping 122 matching lines @@
 
   SetPersistsAcrossAllWorkspaces(
       w1.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w1->Show();
 
   ASSERT_EQ("1 active=0", StateString());
 
   // Maximize should trigger containing the window.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  ASSERT_EQ("0 P=M1 active=0", StateString());
+  ASSERT_EQ("1 active=0", StateString());
 
   // And resetting to normal should remove it.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("1 active=0", StateString());
 }
 
 // Verifies going from maximized to minimized sets the right state for painting
 // the background of the launcher.
 TEST_F(WorkspaceManagerTest, MinimizeResetsVisibility) {
   scoped_ptr<Window> w1(CreateTestWindow());
@@ skipping 10 matching lines @@
 TEST_F(WorkspaceManagerTest, MoveTransientOnMaximize) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->AddTransientChild(w2.get());
   w2->Show();
   wm::ActivateWindow(w1.get());
   ASSERT_EQ("2 active=0", StateString());
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
 
   // Create another transient child of |w1|. We do this unparented, set up the
   // transient parent then set parent. This is how NativeWidgetAura does things
   // too.
   scoped_ptr<Window> w3(CreateTestWindowUnparented());
   w1->AddTransientChild(w3.get());
   SetDefaultParentByPrimaryRootWindow(w3.get());
   w3->Show();
-  ASSERT_EQ("0 M3 active=1", StateString());
+  ASSERT_EQ("3 active=0", StateString());
 
   // Minimize the window. All the transients are hidden as a result, so it ends
   // up in pending.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  ASSERT_EQ("0 P=M3 active=0", StateString());
+  ASSERT_EQ("3 active=0", StateString());
 
   // Restore and everything should go back to the first workspace.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   ASSERT_EQ("3 active=0", StateString());
 }
 
 // Verifies window visibility during various workspace changes.
 TEST_F(WorkspaceManagerTest, VisibilityTests) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_EQ(1.0f, w1->layer()->GetCombinedOpacity());
 
   // Create another window, activate it and maximized it.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->Show();
   wm::ActivateWindow(w2.get());
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_EQ(1.0f, w2->layer()->GetCombinedOpacity());
-  EXPECT_FALSE(w1->IsVisible());
+  EXPECT_TRUE(w1->IsVisible());
 
   // Switch to w1. |w1| should be visible and |w2| hidden.
   wm::ActivateWindow(w1.get());
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_EQ(1.0f, w1->layer()->GetCombinedOpacity());
-  EXPECT_FALSE(w2->IsVisible());
+  EXPECT_TRUE(w2->IsVisible());
 
   // Switch back to |w2|.
   wm::ActivateWindow(w2.get());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_EQ(1.0f, w2->layer()->GetCombinedOpacity());
-  EXPECT_FALSE(w1->IsVisible());
+  EXPECT_TRUE(w1->IsVisible());
 
   // Restore |w2|, both windows should be visible.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_EQ(1.0f, w1->layer()->GetCombinedOpacity());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_EQ(1.0f, w2->layer()->GetCombinedOpacity());
 
   // Maximize |w2| again, then close it.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
@@ skipping 207 matching lines @@
   // Because |w2| isn't tracked we should be able to set the bounds of it.
   gfx::Rect bounds(w2->bounds());
   bounds.Offset(4, 5);
   w2->SetBounds(bounds);
   EXPECT_EQ(bounds.ToString(), w2->bounds().ToString());
 
   // Transition it to tracked by worskpace. It should end up in its own
   // workspace.
   SetTrackedByWorkspace(w2.get(), true);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
-  EXPECT_FALSE(w1->IsVisible());
+  EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
-  EXPECT_NE(w1->parent(), w2->parent());
+  EXPECT_EQ(w1->parent(), w2->parent());
 }
 
 // Verifies a window marked as persisting across all workspaces ends up in its
 // own workspace when maximized.
 TEST_F(WorkspaceManagerTest, DeactivateDropsToDesktop) {
   // Create a window maximized.
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->Show();
   wm::ActivateWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create another window that persists across all workspaces. It should end
   // up with the same parent as |w1|.
   scoped_ptr<Window> w2(CreateTestWindow());
   SetPersistsAcrossAllWorkspaces(
       w2.get(),
       WINDOW_PERSISTS_ACROSS_ALL_WORKSPACES_VALUE_YES);
   w2->Show();
   wm::ActivateWindow(w2.get());
   EXPECT_EQ(w1->parent(), w2->parent());
-  ASSERT_EQ("0 M2 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 
   // Activate |w1|, should result in dropping |w2| to the desktop.
   wm::ActivateWindow(w1.get());
-  ASSERT_EQ("1 M1 active=1", StateString());
+  ASSERT_EQ("2 active=0", StateString());
 }
 
 // Test the basic auto placement of one and or two windows in a "simulated
 // session" of sequential window operations.
 TEST_F(WorkspaceManagerTest, BasicAutoPlacing) {
   // Test 1: In case there is no manageable window, no window should shift.
 
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
@@ skipping 420 matching lines @@
   SetDefaultParentByPrimaryRootWindow(w1.get());
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   w1->Show();
   wm::ActivateWindow(w1.get());
   DragMaximizedNonTrackedWindowObserver observer;
   w1->parent()->parent()->AddObserver(&observer);
   const gfx::Rect max_bounds(w1->bounds());
 
   // There should be two workspace, one for the desktop and one for the
   // maximized window with the maximized active.
-  EXPECT_EQ("0 M1 active=1", StateString());
+  EXPECT_EQ("1 active=0", StateString());
 
   generator.PressLeftButton();
   generator.MoveMouseTo(100, 100);
   // The bounds shouldn't change (drag should result in nothing happening
   // now.
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
-  EXPECT_EQ("0 M1 active=1", StateString());
+  EXPECT_EQ("1 active=0", StateString());
 
   generator.ReleaseLeftButton();
   EXPECT_EQ(0, observer.change_count());
 
   // Set tracked to false and repeat, now the window should move.
   SetTrackedByWorkspace(w1.get(), false);
   generator.MoveMouseTo(5, 5);
   generator.PressLeftButton();
   generator.MoveMouseBy(100, 100);
   EXPECT_EQ(gfx::Rect(max_bounds.x() + 100, max_bounds.y() + 100,
                       max_bounds.width(), max_bounds.height()).ToString(),
             w1->bounds().ToString());
-  EXPECT_EQ("0 M1 active=1", StateString());
+  EXPECT_EQ("1 active=0", StateString());
 
   generator.ReleaseLeftButton();
   SetTrackedByWorkspace(w1.get(), true);
   // Marking the window tracked again should snap back to origin.
-  EXPECT_EQ("0 M1 active=1", StateString());
+  EXPECT_EQ("1 active=0", StateString());
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
   EXPECT_EQ(0, observer.change_count());
 
   w1->parent()->parent()->RemoveObserver(&observer);
 }
 
 // Verifies that a new maximized window becomes visible after its activation
 // is requested, even though it does not become activated because a system
 // modal window is active.
 TEST_F(WorkspaceManagerTest, SwitchFromModal) {
   scoped_ptr<Window> modal_window(CreateTestWindowUnparented());
   modal_window->SetBounds(gfx::Rect(10, 11, 21, 22));
   modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
   SetDefaultParentByPrimaryRootWindow(modal_window.get());
   modal_window->Show();
   wm::ActivateWindow(modal_window.get());
 
   scoped_ptr<Window> maximized_window(CreateTestWindow());
   maximized_window->SetProperty(
       aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   maximized_window->Show();
   wm::ActivateWindow(maximized_window.get());
   EXPECT_TRUE(maximized_window->IsVisible());
 }
 
 }  // namespace internal
 }  // namespace ash