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 246 matching lines @@
     pending_workspaces_.insert(workspace);
     return workspace->window();
   }
 
   if (!GetTrackedByWorkspace(window) || GetPersistsAcrossAllWorkspaces(window))
     return active_workspace_->window();
 
   return desktop_workspace()->window();
 }
 
+bool WorkspaceManager::CycleToWorkspace(Direction direction) {
+  aura::Window* active_window = active_workspace_->GetActiveWindow();
+
+  Workspaces::const_iterator workspace_i(FindWorkspace(active_workspace_));
+  int workspace_offset = 0;
+  if (direction == WORKSPACE_ABOVE) {
+    workspace_offset = 1;
+    if (workspace_i == workspaces_.end() - 1)
+      return false;
+  } else {
+    workspace_offset = -1;
+    if (workspace_i == workspaces_.begin())
+      return false;
+  }
+
+  Workspaces::const_iterator next_workspace_i(workspace_i + workspace_offset);
+  SetActiveWorkspace(*next_workspace_i, SWITCH_CYCLE_WORKSPACE,
+      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);

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

I don't understand this, why do you need to to do it?

[pkotwicz, 2012/11/29 01:01:46]

This is a hack. It has the effect of activating a window in the workspace cycled
to. This is similar to what is done in
WorkspaceLayoutManager::ShowStateChanged() when a window is minimized.
This is a hack because it does not work if there is no active window as is the
case when the desktop workspace is active and the desktop workspace has no
toplevel windows in it.

+  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;
 
   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()) {
+  // Adjust the z-order such that the active workspace is at the top of the
+  // stack. The following exceptions apply:
+  // - Do not adjust the desktop's z-order since it should stay at the bottom.
+  // - Do not adjust the z-order when cycling through windows such that cycling
+  //   is linear.
+  if (workspace != desktop_workspace() && reason != SWITCH_CYCLE_WORKSPACE) {
+    Workspaces::iterator workspace_i = FindWorkspace(workspace);
+    if (workspace_i != workspaces_.end())
+      workspaces_.erase(workspace_i);
     contents_view_->StackChildAbove(workspace->window(),
                                     workspaces_.back()->window());
     workspaces_.push_back(workspace);
   }
 
   Workspace* last_active = active_workspace_;
   active_workspace_ = workspace;
 
   // The display work-area may have changed while |workspace| was not the active
   // workspace. Give it a chance to adjust its state for the new work-area.
@@ skipping 51 matching lines @@
     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);
+    SelectWorkspaceBelow(reason);
 
   base::AutoReset<bool> setter(&in_move_, true);
 
   MoveChildrenToDesktop(workspace->window(), stack_beneath);
 
   {
     Workspaces::iterator workspace_i(FindWorkspace(workspace));
     if (workspace_i != workspaces_.end())
       workspaces_.erase(workspace_i);
   }
@@ skipping 24 matching lines @@
   // (moving may cascade and cause other windows to move).
   for (size_t i = 0; i < to_move.size(); ++i) {
     if (std::find(window->children().begin(), window->children().end(),
                   to_move[i]) != window->children().end()) {
       ReparentWindow(to_move[i], desktop_workspace()->window(),
                      stack_beneath);
     }
   }
 }
 
-void WorkspaceManager::SelectNextWorkspace(SwitchReason reason) {
-  DCHECK_NE(active_workspace_, desktop_workspace());
-
+void WorkspaceManager::SelectWorkspaceBelow(SwitchReason reason) {
   Workspaces::const_iterator workspace_i(FindWorkspace(active_workspace_));
-  Workspaces::const_iterator next_workspace_i(workspace_i + 1);
-  if (next_workspace_i != workspaces_.end())
-    SetActiveWorkspace(*next_workspace_i, reason, base::TimeDelta());
-  else
-    SetActiveWorkspace(*(workspace_i - 1), reason, base::TimeDelta());
+  if (workspace_i == workspaces_.begin()) {
+    SetActiveWorkspace(active_workspace_, reason, base::TimeDelta());
+  } else {
+    Workspaces::const_iterator workspace_below_i(workspace_i - 1);
+    SetActiveWorkspace(*workspace_below_i, reason, base::TimeDelta());
+  }
 }
 
 void WorkspaceManager::ScheduleDelete(Workspace* workspace) {
   to_delete_.insert(workspace);
   delete_timer_.Stop();
   delete_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
                       &WorkspaceManager::ProcessDeletion);
 }
 
 void WorkspaceManager::SetUnminimizingWorkspace(Workspace* workspace) {
@@ skipping 287 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