Renames Workspace*2 -> Workspace*.

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_manager2.h"
+#include "ash/wm/workspace/workspace_manager.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/base_layout_manager.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/auto_window_management.h"
 #include "ash/wm/workspace/desktop_background_fade_controller.h"
 #include "ash/wm/workspace/workspace_animations.h"
-#include "ash/wm/workspace/workspace_layout_manager2.h"
-#include "ash/wm/workspace/workspace2.h"
+#include "ash/wm/workspace/workspace_layout_manager.h"
+#include "ash/wm/workspace/workspace.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/widget/widget.h"
 
-DECLARE_WINDOW_PROPERTY_TYPE(ash::internal::Workspace2*);
+DECLARE_WINDOW_PROPERTY_TYPE(ash::internal::Workspace*);
 DECLARE_EXPORTED_WINDOW_PROPERTY_TYPE(ASH_EXPORT, ui::WindowShowState);
 
 using aura::Window;
 
 namespace ash {
 namespace internal {
 
-DEFINE_WINDOW_PROPERTY_KEY(Workspace2*, kWorkspaceKey, NULL);
+DEFINE_WINDOW_PROPERTY_KEY(Workspace*, kWorkspaceKey, NULL);
 
 namespace {
 
 // Duration for fading out the desktop background when maximizing.
 const int kCrossFadeSwitchTimeMS = 700;
 
 // Amount of time to pause before animating anything. Only used during initial
 // animation (when logging in).
 const int kInitialPauseTimeMS = 750;
 
 // Changes the parent of |window| and all its transient children to
 // |new_parent|. If |stack_beneach| is non-NULL all the windows are stacked
 // beneath it.
 void ReparentWindow(Window* window,
                     Window* new_parent,
                     Window* stack_beneath) {
   window->SetParent(new_parent);
   if (stack_beneath)
     new_parent->StackChildBelow(window, stack_beneath);
   for (size_t i = 0; i < window->transient_children().size(); ++i)
     ReparentWindow(window->transient_children()[i], new_parent, stack_beneath);
 }
 
 }  // namespace
 
 // Workspace -------------------------------------------------------------------
 
 // LayoutManager installed on the parent window of all the Workspace window (eg
-// |WorkspaceManager2::contents_view_|).
-class WorkspaceManager2::LayoutManagerImpl : public BaseLayoutManager {
+// |WorkspaceManager::contents_view_|).
+class WorkspaceManager::LayoutManagerImpl : public BaseLayoutManager {
  public:
-  explicit LayoutManagerImpl(WorkspaceManager2* workspace_manager)
+  explicit LayoutManagerImpl(WorkspaceManager* workspace_manager)
       : BaseLayoutManager(workspace_manager->contents_view_->GetRootWindow()),
         workspace_manager_(workspace_manager) {
   }
   virtual ~LayoutManagerImpl() {}
 
   // Overridden from BaseWorkspaceLayoutManager:
   virtual void OnWindowResized() OVERRIDE {
     for (size_t i = 0; i < window()->children().size(); ++i)
       window()->children()[i]->SetBounds(gfx::Rect(window()->bounds().size()));
   }
   virtual void OnWindowAddedToLayout(Window* child) OVERRIDE {
     // Only workspaces should be added as children.
     DCHECK((child->id() == kShellWindowId_WorkspaceContainer) ||
            workspace_manager_->creating_fade_);
     child->SetBounds(gfx::Rect(window()->bounds().size()));
   }
 
  private:
   aura::Window* window() { return workspace_manager_->contents_view_; }
 
-  WorkspaceManager2* workspace_manager_;
+  WorkspaceManager* workspace_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(LayoutManagerImpl);
 };
 
-// WorkspaceManager2 -----------------------------------------------------------
+// WorkspaceManager -----------------------------------------------------------
 
-WorkspaceManager2::WorkspaceManager2(Window* contents_view)
+WorkspaceManager::WorkspaceManager(Window* contents_view)
     : contents_view_(contents_view),
       active_workspace_(NULL),
       shelf_(NULL),
       in_move_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           clear_unminimizing_workspace_factory_(this)),
       unminimizing_workspace_(NULL),
       app_terminating_(false),
       creating_fade_(false) {
   // Clobber any existing event filter.
   contents_view->SetEventFilter(NULL);
   // |contents_view| takes ownership of LayoutManagerImpl.
   contents_view->SetLayoutManager(new LayoutManagerImpl(this));
   active_workspace_ = CreateWorkspace(false);
   workspaces_.push_back(active_workspace_);
   active_workspace_->window()->Show();
   Shell::GetInstance()->AddShellObserver(this);
 }
 
-WorkspaceManager2::~WorkspaceManager2() {
+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(&Workspace2::ReleaseWindow));
+                std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(pending_workspaces_.begin(), pending_workspaces_.end(),
-                std::mem_fun(&Workspace2::ReleaseWindow));
+                std::mem_fun(&Workspace::ReleaseWindow));
   std::for_each(to_delete_.begin(), to_delete_.end(),
-                std::mem_fun(&Workspace2::ReleaseWindow));
+                std::mem_fun(&Workspace::ReleaseWindow));
   STLDeleteElements(&workspaces_);
   STLDeleteElements(&pending_workspaces_);
   STLDeleteElements(&to_delete_);
 }
 
 // static
-bool WorkspaceManager2::IsMaximized(Window* window) {
+bool WorkspaceManager::IsMaximized(Window* window) {
   return IsMaximizedState(window->GetProperty(aura::client::kShowStateKey));
 }
 
 // static
-bool WorkspaceManager2::IsMaximizedState(ui::WindowShowState state) {
+bool WorkspaceManager::IsMaximizedState(ui::WindowShowState state) {
   return state == ui::SHOW_STATE_MAXIMIZED ||
       state == ui::SHOW_STATE_FULLSCREEN;
 }
 
 // static
-bool WorkspaceManager2::WillRestoreMaximized(Window* window) {
+bool WorkspaceManager::WillRestoreMaximized(Window* window) {
   return wm::IsWindowMinimized(window) &&
       IsMaximizedState(window->GetProperty(internal::kRestoreShowStateKey));
 }
 
-WorkspaceWindowState WorkspaceManager2::GetWindowState() const {
+WorkspaceWindowState WorkspaceManager::GetWindowState() const {
   if (!shelf_)
     return WORKSPACE_WINDOW_STATE_DEFAULT;
 
   const bool is_active_maximized = active_workspace_->is_maximized();
   const gfx::Rect shelf_bounds(shelf_->GetIdealBounds());
   const Window::Windows& windows(active_workspace_->window()->children());
   bool window_overlaps_launcher = false;
   bool has_maximized_window = false;
   for (Window::Windows::const_iterator i = windows.begin();
        i != windows.end(); ++i) {
@@ skipping 19 matching lines @@
       window_overlaps_launcher = true;
   }
   if (has_maximized_window)
     return WORKSPACE_WINDOW_STATE_MAXIMIZED;
 
   return window_overlaps_launcher ?
       WORKSPACE_WINDOW_STATE_WINDOW_OVERLAPS_SHELF :
       WORKSPACE_WINDOW_STATE_DEFAULT;
 }
 
-void WorkspaceManager2::SetShelf(ShelfLayoutManager* shelf) {
+void WorkspaceManager::SetShelf(ShelfLayoutManager* shelf) {
   shelf_ = shelf;
 }
 
-void WorkspaceManager2::SetActiveWorkspaceByWindow(Window* window) {
-  Workspace2* workspace = FindBy(window);
+void WorkspaceManager::SetActiveWorkspaceByWindow(Window* window) {
+  Workspace* workspace = FindBy(window);
   if (!workspace)
     return;
 
   if (workspace != active_workspace_) {
     // A window is being made active. In the following cases we reparent to
     // the active desktop:
     // . The window is not tracked by workspace code. This is used for tab
     //   dragging. Since tab dragging needs to happen in the active workspace we
     //   have to reparent the window (otherwise the window you dragged the tab
     //   out of would disappear since the workspace changed). Since this case is
@@ skipping 15 matching lines @@
                          base::TimeDelta());
     }
   }
   if (workspace->is_maximized() && IsMaximized(window)) {
     // Clicking on the maximized window in a maximized workspace. Force all
     // other windows to drop to the desktop.
     MoveChildrenToDesktop(workspace->window(), NULL);
   }
 }
 
-Window* WorkspaceManager2::GetParentForNewWindow(Window* window) {
+Window* WorkspaceManager::GetParentForNewWindow(Window* window) {
   // Try to put windows with transient parents in the same workspace as their
   // transient parent.
   if (window->transient_parent() && !IsMaximized(window)) {
-    Workspace2* workspace = FindBy(window->transient_parent());
+    Workspace* workspace = FindBy(window->transient_parent());
     if (workspace)
       return workspace->window();
     // Fall through to normal logic.
   }
 
   if (!GetTrackedByWorkspace(window))
     return active_workspace_->window();
 
   if (IsMaximized(window)) {
     // Wait for the window to be made active before showing the workspace.
-    Workspace2* workspace = CreateWorkspace(true);
+    Workspace* workspace = CreateWorkspace(true);
     pending_workspaces_.insert(workspace);
     return workspace->window();
   }
 
   if (!GetTrackedByWorkspace(window) || GetPersistsAcrossAllWorkspaces(window))
     return active_workspace_->window();
 
   return desktop_workspace()->window();
 }
 
-void WorkspaceManager2::DoInitialAnimation() {
+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);
 }
 
-void WorkspaceManager2::OnAppTerminating() {
+void WorkspaceManager::OnAppTerminating() {
   app_terminating_ = true;
 }
 
-void WorkspaceManager2::UpdateShelfVisibility() {
+void WorkspaceManager::UpdateShelfVisibility() {
   if (shelf_)
     shelf_->UpdateVisibilityState();
 }
 
-Workspace2* WorkspaceManager2::FindBy(Window* window) const {
+Workspace* WorkspaceManager::FindBy(Window* window) const {
   while (window) {
-    Workspace2* workspace = window->GetProperty(kWorkspaceKey);
+    Workspace* workspace = window->GetProperty(kWorkspaceKey);
     if (workspace)
       return workspace;
     window = window->parent();
   }
   return NULL;
 }
 
-void WorkspaceManager2::SetActiveWorkspace(Workspace2* workspace,
-                                           SwitchReason reason,
-                                           base::TimeDelta duration) {
+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()) {
     contents_view_->StackChildAbove(workspace->window(),
                                     workspaces_.back()->window());
     workspaces_.push_back(workspace);
   }
 
-  Workspace2* last_active = active_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.
   active_workspace_->workspace_layout_manager()->
       OnDisplayWorkAreaInsetsChanged();
 
   const bool is_unminimizing_maximized_window =
       unminimizing_workspace_ && unminimizing_workspace_ == active_workspace_ &&
       active_workspace_->is_maximized();
@@ skipping 21 matching lines @@
     aura::Window* background = root_controller->GetContainer(
         kShellWindowId_DesktopBackgroundContainer);
     if (last_active == desktop_workspace()) {
       ShowOrHideDesktopBackground(background, reason, duration, false);
     } else if (active_workspace_ == desktop_workspace() && !app_terminating_) {
       ShowOrHideDesktopBackground(background, reason, duration, true);
     }
   }
 }
 
-WorkspaceManager2::Workspaces::iterator
-WorkspaceManager2::FindWorkspace(Workspace2* workspace)  {
+WorkspaceManager::Workspaces::iterator
+WorkspaceManager::FindWorkspace(Workspace* workspace)  {
   return std::find(workspaces_.begin(), workspaces_.end(), workspace);
 }
 
-Workspace2* WorkspaceManager2::CreateWorkspace(bool maximized) {
-  return new Workspace2(this, contents_view_, maximized);
+Workspace* WorkspaceManager::CreateWorkspace(bool maximized) {
+  return new Workspace(this, contents_view_, maximized);
 }
 
-void WorkspaceManager2::MoveWorkspaceToPendingOrDelete(
-    Workspace2* workspace,
+void WorkspaceManager::MoveWorkspaceToPendingOrDelete(
+    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);
@@ skipping 11 matching lines @@
   if (workspace->window()->children().empty()) {
     if (workspace == unminimizing_workspace_)
       unminimizing_workspace_ = NULL;
     pending_workspaces_.erase(workspace);
     ScheduleDelete(workspace);
   } else {
     pending_workspaces_.insert(workspace);
   }
 }
 
-void WorkspaceManager2::MoveChildrenToDesktop(aura::Window* window,
-                                              aura::Window* stack_beneath) {
+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];
     if (!child->transient_parent() && !IsMaximized(child) &&
         !WillRestoreMaximized(child)) {
       to_move.push_back(child);
     }
   }
   // Move the windows, but make sure the window is still a child of |window|
   // (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 WorkspaceManager2::SelectNextWorkspace(SwitchReason reason) {
+void WorkspaceManager::SelectNextWorkspace(SwitchReason reason) {
   DCHECK_NE(active_workspace_, desktop_workspace());
 
   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());
 }
 
-void WorkspaceManager2::ScheduleDelete(Workspace2* workspace) {
+void WorkspaceManager::ScheduleDelete(Workspace* workspace) {
   to_delete_.insert(workspace);
   delete_timer_.Stop();
   delete_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
-                      &WorkspaceManager2::ProcessDeletion);
+                      &WorkspaceManager::ProcessDeletion);
 }
 
-void WorkspaceManager2::SetUnminimizingWorkspace(Workspace2* workspace) {
+void WorkspaceManager::SetUnminimizingWorkspace(Workspace* workspace) {
   // The normal sequence of unminimizing a window is: Show() the window, which
   // triggers changing the kShowStateKey to NORMAL and lastly the window is made
   // active. This means at the time the window is unminimized we don't know if
   // the workspace it is in is going to become active. To track this
   // |unminimizing_workspace_| is set at the time we unminimize and a task is
   // schedule to reset it. This way when we get the activate we know we're in
   // the process unminimizing and can do the right animation.
   unminimizing_workspace_ = workspace;
   if (unminimizing_workspace_) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&WorkspaceManager2::SetUnminimizingWorkspace,
+        base::Bind(&WorkspaceManager::SetUnminimizingWorkspace,
                    clear_unminimizing_workspace_factory_.GetWeakPtr(),
-                   static_cast<Workspace2*>(NULL)));
+                   static_cast<Workspace*>(NULL)));
   }
 }
 
-void WorkspaceManager2::FadeDesktop(aura::Window* window,
-                                    base::TimeDelta duration) {
+void WorkspaceManager::FadeDesktop(aura::Window* window,
+                                   base::TimeDelta duration) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           ash::switches::kAshWindowAnimationsDisabled) ||
       ui::LayerAnimator::disable_animations_for_test())
     return;
 
   AutoReset<bool> reseter(&creating_fade_, true);
   DesktopBackgroundFadeController::Direction direction;
   aura::Window* parent = NULL;
   aura::Window* stack_above = NULL;
   if (active_workspace_ == desktop_workspace()) {
     direction = DesktopBackgroundFadeController::FADE_IN;
     parent = desktop_workspace()->window();
     stack_above = window;
   } else {
     direction = DesktopBackgroundFadeController::FADE_OUT;
     parent = contents_view_;
     stack_above = desktop_workspace()->window();
     DCHECK_EQ(kCrossFadeSwitchTimeMS, (int)duration.InMilliseconds());
     duration = base::TimeDelta::FromMilliseconds(kCrossFadeSwitchTimeMS);
   }
   desktop_fade_controller_.reset(
       new DesktopBackgroundFadeController(
           parent, stack_above, duration, direction));
 }
 
-void WorkspaceManager2::ShowOrHideDesktopBackground(
+void WorkspaceManager::ShowOrHideDesktopBackground(
     aura::Window* window,
     SwitchReason reason,
     base::TimeDelta duration,
     bool show) const {
   WorkspaceAnimationDetails details;
   details.animate = true;
   details.direction = show ? WORKSPACE_ANIMATE_UP : WORKSPACE_ANIMATE_DOWN;
   details.animate_scale = reason != SWITCH_MAXIMIZED_OR_RESTORED;
   details.duration = duration;
   if (reason == SWITCH_INITIAL)
     details.pause_time_ms = kInitialPauseTimeMS;
   if (show)
     ash::internal::ShowWorkspace(window, details);
   else
     ash::internal::HideWorkspace(window, details);
 }
 
-void WorkspaceManager2::ShowWorkspace(
-    Workspace2* workspace,
-    Workspace2* last_active,
+void WorkspaceManager::ShowWorkspace(
+    Workspace* workspace,
+    Workspace* last_active,
     SwitchReason reason) const {
   WorkspaceAnimationDetails details;
   details.direction =
       (last_active == desktop_workspace() || reason == SWITCH_INITIAL) ?
       WORKSPACE_ANIMATE_DOWN : WORKSPACE_ANIMATE_UP;
 
   switch (reason) {
     case SWITCH_WINDOW_MADE_ACTIVE:
     case SWITCH_TRACKED_BY_WORKSPACE_CHANGED:
     case SWITCH_WINDOW_REMOVED:
     case SWITCH_VISIBILITY_CHANGED:
     case SWITCH_MINIMIZED:
       details.animate = details.animate_scale = true;
       details.animate_opacity = last_active == desktop_workspace();
       break;
 
     case SWITCH_INITIAL:
       details.animate = details.animate_opacity = details.animate_scale = true;
       details.pause_time_ms = kInitialPauseTimeMS;
       break;
 
     // Remaining cases require no animation.
     default:
       break;
   }
   ash::internal::ShowWorkspace(workspace->window(), details);
 }
 
-void WorkspaceManager2::HideWorkspace(
-    Workspace2* workspace,
+void WorkspaceManager::HideWorkspace(
+    Workspace* workspace,
     SwitchReason reason,
     bool is_unminimizing_maximized_window) const {
   WorkspaceAnimationDetails details;
   details.direction = active_workspace_ == desktop_workspace() ?
       WORKSPACE_ANIMATE_UP : WORKSPACE_ANIMATE_DOWN;
   switch (reason) {
     case SWITCH_WINDOW_MADE_ACTIVE:
     case SWITCH_TRACKED_BY_WORKSPACE_CHANGED:
       details.animate_opacity =
           ((active_workspace_ == desktop_workspace() ||
@@ skipping 12 matching lines @@
       }
       break;
 
     // Remaining cases require no animation.
     default:
       break;
   }
   ash::internal::HideWorkspace(workspace->window(), details);
 }
 
-void WorkspaceManager2::ProcessDeletion() {
-  std::set<Workspace2*> to_delete;
+void WorkspaceManager::ProcessDeletion() {
+  std::set<Workspace*> to_delete;
   to_delete.swap(to_delete_);
-  for (std::set<Workspace2*>::iterator i = to_delete.begin();
+  for (std::set<Workspace*>::iterator i = to_delete.begin();
        i != to_delete.end(); ++i) {
-    Workspace2* workspace = *i;
+    Workspace* workspace = *i;
     if (workspace->window()->layer()->children().empty()) {
       delete workspace->ReleaseWindow();
       delete workspace;
     } else {
       to_delete_.insert(workspace);
     }
   }
   if (!to_delete_.empty()) {
     delete_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
-                        &WorkspaceManager2::ProcessDeletion);
+                        &WorkspaceManager::ProcessDeletion);
   }
 }
 
-void WorkspaceManager2::OnWindowAddedToWorkspace(Workspace2* workspace,
-                                                 Window* child) {
+void WorkspaceManager::OnWindowAddedToWorkspace(Workspace* workspace,
+                                                Window* child) {
   child->SetProperty(kWorkspaceKey, workspace);
   // Do nothing (other than updating shelf visibility) as the right parent was
   // chosen by way of GetParentForNewWindow() or we explicitly moved the window
   // to the workspace.
   if (workspace == active_workspace_)
     UpdateShelfVisibility();
 
   RearrangeVisibleWindowOnShow(child);
 }
 
-void WorkspaceManager2::OnWillRemoveWindowFromWorkspace(Workspace2* workspace,
-                                                        Window* child) {
+void WorkspaceManager::OnWillRemoveWindowFromWorkspace(Workspace* workspace,
+                                                       Window* child) {
   if (child->TargetVisibility())
     RearrangeVisibleWindowOnHideOrRemove(child);
   child->ClearProperty(kWorkspaceKey);
 }
 
-void WorkspaceManager2::OnWindowRemovedFromWorkspace(Workspace2* workspace,
-                                                     Window* child) {
+void WorkspaceManager::OnWindowRemovedFromWorkspace(Workspace* workspace,
+                                                    Window* child) {
   if (workspace->ShouldMoveToPending())
     MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_WINDOW_REMOVED);
 }
 
-void WorkspaceManager2::OnWorkspaceChildWindowVisibilityChanged(
-    Workspace2* workspace,
+void WorkspaceManager::OnWorkspaceChildWindowVisibilityChanged(
+    Workspace* workspace,
     Window* child) {
   if (workspace->ShouldMoveToPending()) {
     MoveWorkspaceToPendingOrDelete(workspace, NULL, SWITCH_VISIBILITY_CHANGED);
   } else {
     if (child->TargetVisibility())
       RearrangeVisibleWindowOnShow(child);
     else
       RearrangeVisibleWindowOnHideOrRemove(child);
     if (workspace == active_workspace_)
       UpdateShelfVisibility();
   }
 }
 
-void WorkspaceManager2::OnWorkspaceWindowChildBoundsChanged(
-    Workspace2* workspace,
+void WorkspaceManager::OnWorkspaceWindowChildBoundsChanged(
+    Workspace* workspace,
     Window* child) {
   if (workspace == active_workspace_)
     UpdateShelfVisibility();
 }
 
-void WorkspaceManager2::OnWorkspaceWindowShowStateChanged(
-    Workspace2* workspace,
+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);
     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);
-    Workspace2* new_workspace = NULL;
+    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()) {
         {
           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,
                                        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);
     }
     if (is_active && new_workspace) {
       // |old_layer| may be NULL if as part of processing
-      // WorkspaceLayoutManager2::OnWindowPropertyChanged() the window is made
+      // WorkspaceLayoutManager::OnWindowPropertyChanged() the window is made
       // active.
       if (old_layer) {
         SetActiveWorkspace(new_workspace, SWITCH_MAXIMIZED_OR_RESTORED,
                            duration);
         CrossFadeWindowBetweenWorkspaces(new_workspace->window(), child,
                                          old_layer);
         if (workspace == desktop_workspace() ||
             new_workspace == desktop_workspace()) {
           FadeDesktop(child, duration);
         }
       } else {
         SetActiveWorkspace(new_workspace, SWITCH_OTHER, base::TimeDelta());
       }
     } else {
       if (last_show_state == ui::SHOW_STATE_MINIMIZED)
         SetUnminimizingWorkspace(new_workspace ? new_workspace : workspace);
       DCHECK(!old_layer);
     }
   }
   UpdateShelfVisibility();
 }
 
-void WorkspaceManager2::OnTrackedByWorkspaceChanged(Workspace2* workspace,
-                                                    aura::Window* window) {
-  Workspace2* new_workspace = NULL;
+void WorkspaceManager::OnTrackedByWorkspaceChanged(Workspace* workspace,
+                                                   aura::Window* window) {
+  Workspace* new_workspace = NULL;
   if (IsMaximized(window)) {
     new_workspace = CreateWorkspace(true);
     pending_workspaces_.insert(new_workspace);
   } else if (workspace->is_maximized()) {
     new_workspace = desktop_workspace();
   } else {
     return;
   }
   // If the window is active we need to make sure the destination Workspace
   // window is showing. Otherwise the window will be parented to a hidden window
   // and lose activation.
   const bool is_active = wm::IsActiveWindow(window);
   if (is_active)
     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