Initial crack at new workspace behavior. Each workspace now has its

ash/wm/window_cycle_controller.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/window_cycle_controller.h"
 
 #include <algorithm>
 
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/activation_controller.h"
 #include "ash/wm/window_cycle_list.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace_controller.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/event.h"
 
 namespace ash {
 
 namespace {
 
 // List of containers whose children we will cycle through.
 const int kContainerIds[] = {
@@ skipping 53 matching lines @@
     ui::TouchEvent* event) {
   return ui::TOUCH_STATUS_UNKNOWN;  // Not handled.
 }
 
 ui::GestureStatus WindowCycleEventFilter::PreHandleGestureEvent(
     aura::Window* target,
     ui::GestureEvent* event) {
   return ui::GESTURE_STATUS_UNKNOWN;  // Not handled.
 }
 
+// Adds all the children of |window| to |windows|.
+void AddAllChildren(aura::Window* window,
+                    WindowCycleList::WindowList* windows) {
+  const WindowCycleList::WindowList& children(window->children());
+  windows->insert(windows->end(), children.begin(), children.end());
+}
+
+// Adds all the children of all of |window|s children to |windows|.
+void AddWorkspace2Children(aura::Window* window,
+                           WindowCycleList::WindowList* windows) {
+  for (size_t i = 0; i < window->children().size(); ++i)
+    AddAllChildren(window->children()[i], windows);
+}
+
+// Adds the windows that can be cycled through for the specified window id to
+// |windows|.
+void AddCycleWindows(aura::RootWindow* root,
+                     int container_id,
+                     WindowCycleList::WindowList* windows) {
+  aura::Window* container = Shell::GetContainer(root, container_id);
+  if (container_id == internal::kShellWindowId_DefaultContainer &&
+      internal::WorkspaceController::IsWorkspace2Enabled()) {
+    AddWorkspace2Children(container, windows);
+  } else {
+    AddAllChildren(container, windows);
+  }
+}
+
 }  // namespace
 
 //////////////////////////////////////////////////////////////////////////////
 // WindowCycleController, public:
 
 WindowCycleController::WindowCycleController(
     internal::ActivationController* activation_controller)
-  : activation_controller_(activation_controller) {
+    : activation_controller_(activation_controller) {
   activation_controller_->AddObserver(this);
 }
 
 WindowCycleController::~WindowCycleController() {
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
       aura::Window* container = Shell::GetContainer(*iter, kContainerIds[i]);
       if (container)
         container->RemoveObserver(this);
     }
+    aura::Window* default_container =
+        Shell::GetContainer(*iter, internal::kShellWindowId_DefaultContainer);
+    if (default_container) {
+      for (size_t i = 0; i < default_container->children().size(); ++i) {
+        aura::Window* workspace_window = default_container->children()[i];
+        DCHECK_EQ(internal::kShellWindowId_WorkspaceContainer,
+                  workspace_window->id());
+        workspace_window->RemoveObserver(this);
+      }
+    }
   }
 
   activation_controller_->RemoveObserver(this);
   StopCycling();
 }
 
 // static
 bool WindowCycleController::CanCycle() {
   // Don't allow window cycling if the screen is locked or a modal dialog is
   // open.
@@ skipping 28 matching lines @@
 void WindowCycleController::AltKeyReleased() {
   StopCycling();
 }
 
 // static
 std::vector<aura::Window*> WindowCycleController::BuildWindowList(
     const std::list<aura::Window*>* mru_windows) {
   WindowCycleList::WindowList windows;
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
 
+  aura::RootWindow* active_root = Shell::GetActiveRootWindow();
   for (Shell::RootWindowList::const_iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
-    if (*iter == Shell::GetActiveRootWindow())
+    if (*iter == active_root)
       continue;
-    for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
-      aura::Window* container = Shell::GetContainer(*iter, kContainerIds[i]);
-      WindowCycleList::WindowList children = container->children();
-      windows.insert(windows.end(), children.begin(), children.end());
-    }
+    for (size_t i = 0; i < arraysize(kContainerIds); ++i)
+      AddCycleWindows(*iter, kContainerIds[i], &windows);
   }
 
   // Add windows in the active root windows last so that the topmost window
   // in the active root window becomes the front of the list.
-  for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
-    aura::Window* container =
-        Shell::GetContainer(Shell::GetActiveRootWindow(), kContainerIds[i]);
-
-    WindowCycleList::WindowList children = container->children();
-    windows.insert(windows.end(), children.begin(), children.end());
-  }
+  for (size_t i = 0; i < arraysize(kContainerIds); ++i)
+    AddCycleWindows(active_root, kContainerIds[i], &windows);
 
   // Removes unfocusable windows.
   WindowCycleList::WindowList::iterator last =
       std::remove_if(
           windows.begin(),
           windows.end(),
           std::not1(std::ptr_fun(ash::wm::CanActivateWindow)));
   windows.erase(last, windows.end());
 
   // Put the windows in the mru_windows list at the head, if it's available.
@@ skipping 17 matching lines @@
 
   return windows;
 }
 
 void WindowCycleController::OnRootWindowAdded(aura::RootWindow* root_window) {
   for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
     aura::Window* container =
         Shell::GetContainer(root_window, kContainerIds[i]);
     container->AddObserver(this);
   }
+
+  aura::Window* default_container =
+      Shell::GetContainer(root_window,
+                          internal::kShellWindowId_DefaultContainer);
+  for (size_t i = 0; i < default_container->children().size(); ++i) {
+    aura::Window* workspace_window = default_container->children()[i];
+    DCHECK_EQ(internal::kShellWindowId_WorkspaceContainer,
+              workspace_window->id());
+    workspace_window->AddObserver(this);
+  }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WindowCycleController, private:
 
 void WindowCycleController::StartCycling() {
   windows_.reset(new WindowCycleList(BuildWindowList(&mru_windows_)));
 }
 
 void WindowCycleController::Step(Direction direction) {
@@ skipping 18 matching lines @@
 
 // static
 bool WindowCycleController::IsTrackedContainer(aura::Window* window) {
   if (!window)
     return false;
   for (size_t i = 0; i < arraysize(kContainerIds); ++i) {
     if (window->id() == kContainerIds[i]) {
       return true;
     }
   }
-  return false;
+  return window->id() == internal::kShellWindowId_WorkspaceContainer;
 }
 
 void WindowCycleController::InstallEventFilter() {
   event_filter_.reset(new WindowCycleEventFilter());
   Shell::GetInstance()->AddEnvEventFilter(event_filter_.get());
 }
 
 void WindowCycleController::OnWindowActivated(aura::Window* active,
                                               aura::Window* old_active) {
   if (active && !IsCycling() && IsTrackedContainer(active->parent())) {
     mru_windows_.remove(active);
     mru_windows_.push_front(active);
   }
 }
 
+void WindowCycleController::OnWindowAdded(aura::Window* window) {
+  if (window->id() == internal::kShellWindowId_WorkspaceContainer)
+    window->AddObserver(this);
+}
+
 void WindowCycleController::OnWillRemoveWindow(aura::Window* window) {
   mru_windows_.remove(window);
+  if (window->id() == internal::kShellWindowId_WorkspaceContainer)
+    window->RemoveObserver(this);
 }
 
 void WindowCycleController::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
 }
 
 }  // namespace ash