Implement workspace scrubbing

ash/wm/workspace/workspace_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_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "ash/ash_switches.h"
@@ skipping 113 matching lines @@
   active_workspace_->window()->Show();
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 WorkspaceManager::~WorkspaceManager() {
   Shell::GetInstance()->RemoveShellObserver(this);
   // Release the windows, they'll be destroyed when |contents_view_| is
   // destroyed.
   std::for_each(workspaces_.begin(), workspaces_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
+  std::for_each(hidden_workspaces_.begin(), hidden_workspaces_.end(),
+                std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(pending_workspaces_.begin(), pending_workspaces_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(to_delete_.begin(), to_delete_.end(),
                 std::mem_fun(&Workspace::ReleaseWindow));
   STLDeleteElements(&workspaces_);
+  STLDeleteElements(&hidden_workspaces_);
   STLDeleteElements(&pending_workspaces_);
   STLDeleteElements(&to_delete_);
 }
 
 // static
 bool WorkspaceManager::IsMaximized(Window* window) {
   return IsMaximizedState(window->GetProperty(aura::client::kShowStateKey));
 }
 
 // static
@@ skipping 108 matching lines @@
     pending_workspaces_.insert(workspace);
     return workspace->window();
   }
 
   if (!GetTrackedByWorkspace(window) || GetPersistsAcrossAllWorkspaces(window))
     return active_workspace_->window();
 
   return desktop_workspace()->window();
 }
 
+bool WorkspaceManager::CycleToNextVisibleWorkspace() {
+  if (active_workspace_ == desktop_workspace())
+    return false;
+
+  aura::Window* active_window = active_workspace_->GetActiveWindow();
+  MoveWorkspaceToHiddenOrDelete(active_workspace_, NULL, SWITCH_OTHER);
+
+  // The activation controller will pick a window from the just activated
+  // workspace to activate as a result of DeactivateWindow().
+  if (active_window)
+    wm::DeactivateWindow(active_window);
+  return true;
+}
+
+bool WorkspaceManager::CycleToNextHiddenWorkspace() {
+  if (hidden_workspaces_.empty())
+    return false;
+
+  aura::Window* active_window = active_workspace_->GetActiveWindow();
+  SetActiveWorkspace(hidden_workspaces_.back(), SWITCH_OTHER,
+                     base::TimeDelta());
+
+  // The activation controller will pick a window from the just activated
+  // workspace to activate as a result of DeactivateWindow().
+  if (active_window)
+    wm::DeactivateWindow(active_window);
+  return true;
+}
+
 void WorkspaceManager::DoInitialAnimation() {
   if (active_workspace_->is_maximized()) {
     RootWindowController* root_controller = GetRootWindowController(
         contents_view_->GetRootWindow());
     if (root_controller) {
       aura::Window* background = root_controller->GetContainer(
           kShellWindowId_DesktopBackgroundContainer);
       background->Show();
       ShowOrHideDesktopBackground(background, SWITCH_INITIAL,
                                   base::TimeDelta(), false);
     }
   }
   ShowWorkspace(active_workspace_, active_workspace_, SWITCH_INITIAL);
 }
 
+aura::Window* WorkspaceManager::GetActiveWorkspaceWindow() const {
+  return active_workspace_->window();
+}
+
 void WorkspaceManager::OnAppTerminating() {
   app_terminating_ = true;
 }
 
 void WorkspaceManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
 Workspace* WorkspaceManager::FindBy(Window* window) const {
   while (window) {
     Workspace* workspace = window->GetProperty(kWorkspaceKey);
     if (workspace)
       return workspace;
     window = window->parent();
   }
   return NULL;
 }
 
 void WorkspaceManager::SetActiveWorkspace(Workspace* workspace,
                                           SwitchReason reason,
                                           base::TimeDelta duration) {
   DCHECK(workspace);
   if (active_workspace_ == workspace)
     return;
 
+  Workspaces::iterator it = std::find(
+      hidden_workspaces_.begin(), hidden_workspaces_.end(), workspace);
+  if (it != hidden_workspaces_.end())
+    hidden_workspaces_.erase(it);
   pending_workspaces_.erase(workspace);
 
   // Adjust the z-order. No need to adjust the z-order for the desktop since
   // it always stays at the bottom.
   if (workspace != desktop_workspace() &&
       FindWorkspace(workspace) == workspaces_.end()) {
     contents_view_->StackChildAbove(workspace->window(),
                                     workspaces_.back()->window());
     workspaces_.push_back(workspace);
   }
@@ skipping 46 matching lines @@
 
 WorkspaceManager::Workspaces::iterator
 WorkspaceManager::FindWorkspace(Workspace* workspace)  {
   return std::find(workspaces_.begin(), workspaces_.end(), workspace);
 }
 
 Workspace* WorkspaceManager::CreateWorkspace(bool maximized) {
   return new Workspace(this, contents_view_, maximized);
 }
 
-void WorkspaceManager::MoveWorkspaceToPendingOrDelete(
+void WorkspaceManager::MoveWorkspaceToHiddenOrDelete(
     Workspace* workspace,
     Window* stack_beneath,
     SwitchReason reason) {
   // We're all ready moving windows.
   if (in_move_)
     return;
 
   DCHECK_NE(desktop_workspace(), workspace);
 
   if (workspace == active_workspace_)
     SelectNextWorkspace(reason);
 
   base::AutoReset<bool> setter(&in_move_, true);
 
   MoveChildrenToDesktop(workspace->window(), stack_beneath);
 
+  bool workspace_previously_visible = false;
   {
     Workspaces::iterator workspace_i(FindWorkspace(workspace));
-    if (workspace_i != workspaces_.end())
+    if (workspace_i != workspaces_.end()) {
       workspaces_.erase(workspace_i);
+      workspace_previously_visible = true;
+    }
   }
 
   if (workspace->window()->children().empty()) {
     if (workspace == unminimizing_workspace_)
       unminimizing_workspace_ = NULL;
+    Workspaces::iterator hidden_i = std::find(
+        hidden_workspaces_.begin(), hidden_workspaces_.end(), workspace);
+    if (hidden_i != hidden_workspaces_.end())
+      hidden_workspaces_.erase(hidden_i);
     pending_workspaces_.erase(workspace);
     ScheduleDelete(workspace);
-  } else {
-    pending_workspaces_.insert(workspace);
+  } else if (workspace_previously_visible) {
+    hidden_workspaces_.push_back(workspace);
   }
 }
 
 void WorkspaceManager::MoveChildrenToDesktop(aura::Window* window,
                                              aura::Window* stack_beneath) {
   // Build the list of windows to move. Exclude maximized/fullscreen and windows
   // with transient parents.
   Window::Windows to_move;
   for (size_t i = 0; i < window->children().size(); ++i) {
     Window* child = window->children()[i];
@@ skipping 199 matching lines @@
 
 void WorkspaceManager::OnWillRemoveWindowFromWorkspace(Workspace* workspace,
                                                        Window* child) {
   if (child->TargetVisibility())
     RearrangeVisibleWindowOnHideOrRemove(child);
   child->ClearProperty(kWorkspaceKey);
 }
 
 void WorkspaceManager::OnWindowRemovedFromWorkspace(Workspace* workspace,
                                                     Window* child) {
-  if (workspace->ShouldMoveToPending())
-    MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_WINDOW_REMOVED);
+  if (workspace->ShouldMoveToHidden())
+    MoveWorkspaceToHiddenOrDelete(workspace, NULL, SWITCH_WINDOW_REMOVED);
 }
 
 void WorkspaceManager::OnWorkspaceChildWindowVisibilityChanged(
     Workspace* workspace,
     Window* child) {
-  if (workspace->ShouldMoveToPending()) {
-    MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_VISIBILITY_CHANGED);
+  if (workspace->ShouldMoveToHidden()) {
+    MoveWorkspaceToHiddenOrDelete(workspace, NULL, SWITCH_VISIBILITY_CHANGED);
   } else {
     if (child->TargetVisibility())
       RearrangeVisibleWindowOnShow(child);
     else
       RearrangeVisibleWindowOnHideOrRemove(child);
     if (workspace == active_workspace_)
       UpdateShelfVisibility();
   }
 }
 
 void WorkspaceManager::OnWorkspaceWindowChildBoundsChanged(
     Workspace* workspace,
     Window* child) {
   if (workspace == active_workspace_)
     UpdateShelfVisibility();
 }
 
 void WorkspaceManager::OnWorkspaceWindowShowStateChanged(
     Workspace* workspace,
     Window* child,
     ui::WindowShowState last_show_state,
     ui::Layer* old_layer) {
   // |child| better still be in |workspace| else things have gone wrong.
   DCHECK_EQ(workspace, child->GetProperty(kWorkspaceKey));
   if (wm::IsWindowMinimized(child)) {
-    if (workspace->ShouldMoveToPending())
-      MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_MINIMIZED);
+    if (workspace->ShouldMoveToHidden())
+      MoveWorkspaceToHiddenOrDelete(workspace, NULL, SWITCH_MINIMIZED);
     DCHECK(!old_layer);
   } else {
     // Set of cases to deal with:
     // . More than one maximized window: move newly maximized window into
     //   own workspace.
     // . One maximized window and not in a maximized workspace: move window
     //   into own workspace.
     // . No maximized window and not in desktop: move to desktop and further
     //   any existing windows are stacked beneath |child|.
     const bool is_active = wm::IsActiveWindow(child);
     Workspace* new_workspace = NULL;
     const int max_count = workspace->GetNumMaximizedWindows();
     base::TimeDelta duration = old_layer && !IsMaximized(child) ?
             GetCrossFadeDuration(old_layer->bounds(), child->bounds()) :
             base::TimeDelta::FromMilliseconds(kCrossFadeSwitchTimeMS);
     if (max_count == 0) {
       if (workspace != desktop_workspace()) {
         {
           base::AutoReset<bool> setter(&in_move_, true);
           ReparentWindow(child, desktop_workspace()->window(), NULL);
         }
         DCHECK(!is_active || old_layer);
         new_workspace = desktop_workspace();
         SetActiveWorkspace(new_workspace, SWITCH_MAXIMIZED_OR_RESTORED,
                            duration);
-        MoveWorkspaceToPendingOrDelete(workspace, child,
+        MoveWorkspaceToHiddenOrDelete(workspace, child,
                                        SWITCH_MAXIMIZED_OR_RESTORED);
         if (FindWorkspace(workspace) == workspaces_.end())
           workspace = NULL;
       }
     } else if ((max_count == 1 && workspace == desktop_workspace()) ||
                max_count > 1) {
       new_workspace = CreateWorkspace(true);
       pending_workspaces_.insert(new_workspace);
       ReparentWindow(child, new_workspace->window(), NULL);
     }
@@ skipping 41 matching lines @@
     new_workspace->window()->Show();
   ReparentWindow(window, new_workspace->window(), NULL);
   if (is_active) {
     SetActiveWorkspace(new_workspace, SWITCH_TRACKED_BY_WORKSPACE_CHANGED,
                        base::TimeDelta());
   }
 }
 
 }  // namespace internal
 }  // namespace ash