Implement workspace scrubbing

ash/wm/workspace/workspace_manager.h

 // 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.
 
 #ifndef ASH_WM_WORKSPACE_WORKSPACE_MANAGER_H_
 #define ASH_WM_WORKSPACE_WORKSPACE_MANAGER_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 60 matching lines @@
   void SetShelf(ShelfLayoutManager* shelf);
 
   // Activates the workspace containing |window|. Does nothing if |window| is
   // NULL or not contained in a workspace.
   void SetActiveWorkspaceByWindow(aura::Window* window);
 
   // Returns the parent for |window|. This is invoked from StackingController
   // when a new Window is being added.
   aura::Window* GetParentForNewWindow(aura::Window* window);
 
+  // Called by the workspace cycler to hide the currently active workspace.
+  // The currently active workspace is moved to |hidden_workspaces_|.
+  // Returns false if there are no workspaces which can be hidden. This will be
+  // the case if the desktop workspace is currently active.
+  bool CycleAwayFromCurrentlyActiveWorkspace();

[sadrul, 2012/11/23 20:02:07]

Where does it cycle to?

+
+  // Called by the workspace cycler to activate the workspace in
+  // |hidden_workspaces_| which was most recently added. Activating the
+  // workspace moves it to |workspaces_|.
+  // Returns false if |hidden_workspaces| is empty.
+  bool CycleToNextHiddenWorkspace();
+
   // Starts the animation that occurs on first login.
   void DoInitialAnimation();
 
+  // Returns the window of the currently active workspace.
+  aura::Window* GetActiveWorkspaceWindow() const;
+
   // ShellObserver overrides:
   virtual void OnAppTerminating() OVERRIDE;
 
  private:
   friend class WorkspaceLayoutManager;
   friend class WorkspaceManagerTest;
 
   class LayoutManagerImpl;
 
   typedef std::vector<Workspace*> Workspaces;
@@ skipping 36 matching lines @@
 
   Workspace* desktop_workspace() { return workspaces_[0]; }
   const Workspace* desktop_workspace() const { return workspaces_[0]; }
 
   // Creates a new workspace. The Workspace is not added to anything and is
   // owned by the caller.
   Workspace* CreateWorkspace(bool maximized);
 
   // Moves all the non-maximized child windows of |workspace| to the desktop
   // stacked beneath |stack_beneath| (if non-NULL). After moving child windows
-  // if |workspace| contains no children it is deleted, otherwise it it moved to
-  // |pending_workspaces_|.
-  void MoveWorkspaceToPendingOrDelete(Workspace* workspace,
-                                      aura::Window* stack_beneath,
-                                      SwitchReason reason);
+  // if |workspace| contains no children it is deleted. Otherwise, it is moved
+  // to |hidden_workspaces_|.
+  void MoveWorkspaceToHiddenOrDelete(Workspace* workspace,
+                                     aura::Window* stack_beneath,
+                                     SwitchReason reason);
 
   // Moves the children of |window| to the desktop. This excludes certain
   // windows. If |stack_beneath| is non-NULL the windows are stacked beneath it.
   void MoveChildrenToDesktop(aura::Window* window, aura::Window* stack_beneath);
 
   // Selects the next workspace.
   void SelectNextWorkspace(SwitchReason reason);
 
   // Schedules |workspace| for deletion when it no longer contains any layers.
   // See comments above |to_delete_| as to why we do this.
@@ skipping 45 matching lines @@
                                    aura::Window* window);
 
   aura::Window* contents_view_;
 
   Workspace* active_workspace_;
 
   // The set of active workspaces. There is always at least one in this stack,
   // which identifies the desktop.
   Workspaces workspaces_;
 
-  // The set of workspaces not currently active. Workspaces ended up here in
-  // two scenarios:
-  // . Prior to adding a window a new worskpace is created for it. The
-  //   Workspace is added to this set.
-  // . When the maximized window is minimized the workspace is added here.
+  // List of inactive workspaces which were deactivated as a result of a user
+  // action. Workspaces are moved here from |workspaces_| when the workspace's
+  // maximized window is minimized or hidden. The workspace is moved back to
+  // |workspaces_| when one of its windows is activated.
+  Workspaces hidden_workspaces_;
+
+  // Set of workspaces that have never been activated. Workspaces for new
+  // windows prior to those windows being activated are added to this set.
   // Once any window in the workspace is activated the workspace is moved to
   // |workspaces_|.
   std::set<Workspace*> pending_workspaces_;
 
   // Owned by the Shell. May be NULL.
   ShelfLayoutManager* shelf_;
 
-  // Whether or not we're in MoveWorkspaceToPendingOrDelete(). As
-  // MoveWorkspaceToPendingOrDelete() may trigger another call to
-  // MoveWorkspaceToPendingOrDelete() we use this to avoid doing anything if
-  // already in MoveWorkspaceToPendingOrDelete().
+  // Whether or not we're in MoveWorkspaceToHiddenOrDelete(). As
+  // MoveWorkspaceToHiddenOrDelete() may trigger another call to
+  // MoveWorkspaceToHiddenOrDelete() we use this to avoid doing anything if
+  // already in MoveWorkspaceToHiddenOrDelete().
   bool in_move_;
 
   // Ideally we would delete workspaces when not needed. Unfortunately doing so
   // would effectively cancel animations. Instead when a workspace is no longer
   // needed we add it here and start a timer. When the timer fires any windows
   // no longer contain layers are deleted.
   std::set<Workspace*> to_delete_;
   base::OneShotTimer<WorkspaceManager> delete_timer_;
 
   // See comments in SetUnminimizingWorkspace() for details.
@@ skipping 14 matching lines @@
   // DesktopBackgroundFadeController.
   bool creating_fade_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_WORKSPACE_WORKSPACE_MANAGER_H_