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 35 matching lines @@
 class Workspace;
 
 // WorkspaceManager manages multiple workspaces in the desktop. Workspaces are
 // implicitly created as windows are maximized (or made fullscreen), and
 // destroyed when maximized windows are closed or restored. There is always one
 // workspace for the desktop.
 // Internally WorkspaceManager creates a Window for each Workspace. As windows
 // are maximized and restored they are reparented to the right Window.
 class ASH_EXPORT WorkspaceManager : public ash::ShellObserver {
  public:
+

[sky, 2012/11/28 15:15:34]

remove newline.

+  enum Direction {
+    WORKSPACE_ABOVE,

[sky, 2012/11/28 15:15:34]

Above and below are not clear in this content. How about next/previous and use
cycle here, eg:
CycleDirection {
  CYCLE_NEXT, CYCLE_PREVIOUS
}

+    WORKSPACE_BELOW
+  };
+
   explicit WorkspaceManager(aura::Window* viewport);
   virtual ~WorkspaceManager();
 
   // Returns true if |window| is considered maximized and should exist in its
   // own workspace.
   static bool IsMaximized(aura::Window* window);
   static bool IsMaximizedState(ui::WindowShowState state);
 
   // Returns true if |window| is minimized and will restore to a maximized
   // window.
   static bool WillRestoreMaximized(aura::Window* window);
 
   // Returns the current window state.
   WorkspaceWindowState GetWindowState() const;
 
   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 activate the next workspace in
+  // |direction|. Returns false if there are no more workspaces to cycle
+  // to in |direction|.
+  bool CycleToWorkspace(Direction direction);
+
   // Starts the animation that occurs on first login.
   void DoInitialAnimation();
 
+  // Returns the window of the currently active workspace.
+  aura::Window* GetActiveWorkspaceWindow() const;

[sky, 2012/11/28 15:15:34]

Should either return const or not be const.

+
   // ShellObserver overrides:
   virtual void OnAppTerminating() OVERRIDE;
 
  private:
   friend class WorkspaceLayoutManager;
   friend class WorkspaceManagerTest;
 
   class LayoutManagerImpl;
 
   typedef std::vector<Workspace*> Workspaces;
 
   // Reason for the workspace switch. Used to determine the characterstics of
   // the animation.
   enum SwitchReason {
     SWITCH_WINDOW_MADE_ACTIVE,
     SWITCH_WINDOW_REMOVED,
     SWITCH_VISIBILITY_CHANGED,
     SWITCH_MINIMIZED,
     SWITCH_MAXIMIZED_OR_RESTORED,
     SWITCH_TRACKED_BY_WORKSPACE_CHANGED,
 
     // Switch as the result of DoInitialAnimation(). This isn't a real switch,
     // rather we run the animations as if a switch occurred.
     SWITCH_INITIAL,
 
+    // Switch as the result of cycling through workspaces.
+    SWITCH_CYCLE_WORKSPACE,
+
     // Edge case. See comment in OnWorkspaceWindowShowStateChanged().  Don't
     // make other types randomly use this!
     SWITCH_OTHER,
   };
 
   // Updates the visibility and whether any windows overlap the shelf.
   void UpdateShelfVisibility();
 
   // Returns the workspace that contains |window|.
   Workspace* FindBy(aura::Window* window) const;
@@ skipping 21 matching lines @@
   // 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);
 
   // 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);
+  // Selects the workspace below the active workspace if any.
+  void SelectWorkspaceBelow(SwitchReason reason);

[sky, 2012/11/28 15:15:34]

Keep the old name, its clearer since below doesn't mean anything.

 
   // Schedules |workspace| for deletion when it no longer contains any layers.
   // See comments above |to_delete_| as to why we do this.
   void ScheduleDelete(Workspace* workspace);
 
   // Deletes any workspaces scheduled via ScheduleDelete() that don't contain
   // any layers.
   void ProcessDeletion();
 
   // Sets |unminimizing_workspace_| to |workspace|.
@@ skipping 88 matching lines @@
   // DesktopBackgroundFadeController.
   bool creating_fade_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkspaceManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_WORKSPACE_WORKSPACE_MANAGER_H_