Removes worskpace 1 code. Will rename next.

ash/wm/workspace/workspace_manager.cc

Index: ash/wm/workspace/workspace_manager.cc
diff --git a/ash/wm/workspace/workspace_manager.cc b/ash/wm/workspace/workspace_manager.cc
deleted file mode 100644
index ca87dc738379047c8f628b58aeef7291d4b4adb7..0000000000000000000000000000000000000000
--- a/ash/wm/workspace/workspace_manager.cc
+++ /dev/null
@@ -1,368 +0,0 @@
-// 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 "ash/screen_ash.h"
-#include "ash/shell.h"
-#include "ash/wm/property_util.h"
-#include "ash/wm/shelf_layout_manager.h"
-#include "ash/wm/window_animations.h"
-#include "ash/wm/window_util.h"
-#include "ash/wm/workspace/managed_workspace.h"
-#include "ash/wm/workspace/maximized_workspace.h"
-#include "base/auto_reset.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "ui/aura/client/aura_constants.h"
-#include "ui/aura/env.h"
-#include "ui/aura/root_window.h"
-#include "ui/aura/window.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/gfx/screen.h"
-#include "ui/gfx/transform.h"
-
-namespace {
-
-// Returns a list of all the windows with layers in |result|.  Optionally
-// ignores the window |ignore_window|.
-void BuildWindowList(const std::vector<aura::Window*>& windows,
-                     aura::Window* ignore_window,
-                     std::vector<aura::Window*>* result) {
-  for (size_t i = 0; i < windows.size(); ++i) {
-    if (windows[i] == ignore_window)
-      continue;
-    if (windows[i]->layer())
-      result->push_back(windows[i]);
-    BuildWindowList(windows[i]->transient_children(), ignore_window, result);
-  }
-}
-
-}
-
-namespace ash {
-namespace internal {
-
-////////////////////////////////////////////////////////////////////////////////
-// WindowManager, public:
-
-WorkspaceManager::WorkspaceManager(aura::Window* contents_view)
-    : contents_view_(contents_view),
-      active_workspace_(NULL),
-      maximize_restore_window_(NULL),
-      grid_size_(0),
-      shelf_(NULL) {
-  DCHECK(contents_view);
-}
-
-WorkspaceManager::~WorkspaceManager() {
-  std::vector<Workspace*> copy_to_delete(workspaces_);
-  STLDeleteElements(&copy_to_delete);
-}
-
-// static
-bool WorkspaceManager::ShouldManageWindow(aura::Window* window) {
-  return window->type() == aura::client::WINDOW_TYPE_NORMAL &&
-         !window->transient_parent() &&
-         ash::GetTrackedByWorkspace(window) &&
-         (!ash::GetPersistsAcrossAllWorkspaces(window) ||
-          wm::IsWindowMaximized(window));
-}
-
-bool WorkspaceManager::Contains(aura::Window* window) const {
-  return FindBy(window) != NULL;
-}
-
-void WorkspaceManager::AddWindow(aura::Window* window) {
-  DCHECK(ShouldManageWindow(window));
-
-  Workspace* current_workspace = FindBy(window);
-  if (current_workspace) {
-    // Already know about this window. Make sure the workspace is active.
-    if (active_workspace_ != current_workspace) {
-      if (active_workspace_)
-        window->layer()->GetAnimator()->StopAnimating();
-      current_workspace->Activate();
-    }
-    window->Show();
-    UpdateShelfVisibility();
-    return;
-  }
-
-  Workspace* workspace = NULL;
-  Workspace::Type type_for_window = Workspace::TypeForWindow(window);
-  switch (type_for_window) {
-    case Workspace::TYPE_MANAGED:
-      // All normal windows go in the same workspace.
-      workspace = GetManagedWorkspace();
-      break;
-
-    case Workspace::TYPE_MAXIMIZED:
-      // All maximized windows go in their own workspace.
-      break;
-  }
-
-  if (!workspace)
-    workspace = CreateWorkspace(type_for_window);
-  workspace->AddWindowAfter(window, NULL);
-  workspace->Activate();
-  UpdateShelfVisibility();
-}
-
-void WorkspaceManager::RemoveWindow(aura::Window* window) {
-  Workspace* workspace = FindBy(window);
-  if (!workspace)
-    return;
-  workspace->RemoveWindow(window);
-  CleanupWorkspace(workspace);
-}
-
-void WorkspaceManager::UpdateShelfVisibility() {
-  if (shelf_)
-    shelf_->UpdateVisibilityState();
-}
-
-void WorkspaceManager::ShowStateChanged(aura::Window* window) {
-  Workspace* workspace = FindBy(window);
-  if (!workspace)
-    return;
-  if (!ShouldManageWindow(window)) {
-    RemoveWindow(window);
-  } else {
-    Workspace::Type old_type = workspace->type();
-    Workspace::Type new_type = Workspace::TypeForWindow(window);
-    if (new_type != old_type)
-      OnTypeOfWorkspacedNeededChanged(window);
-  }
-  UpdateShelfVisibility();
-}
-
-bool WorkspaceManager::IsInMaximizedMode() const {
-  return active_workspace_ &&
-      active_workspace_->type() == Workspace::TYPE_MAXIMIZED;
-}
-
-WorkspaceWindowState WorkspaceManager::GetWindowState() const {
-  if (!shelf_ || !active_workspace_)
-    return WORKSPACE_WINDOW_STATE_DEFAULT;
-
-  // TODO: this code needs to be made multi-display aware.
-  gfx::Rect shelf_bounds(shelf_->GetIdealBounds());
-  const aura::Window::Windows& windows(contents_view_->children());
-  bool window_overlaps_launcher = false;
-  bool has_maximized_window = false;
-  for (aura::Window::Windows::const_iterator i = windows.begin();
-       i != windows.end(); ++i) {
-    gfx::Rect b = (*i)->bounds();
-    if (GetIgnoredByShelf(*i))
-      continue;
-    ui::Layer* layer = (*i)->layer();
-    if (!layer->GetTargetVisibility() || layer->GetTargetOpacity() == 0.0f)
-      continue;
-    if (wm::IsWindowMaximized(*i)) {
-      // An untracked window may still be fullscreen so we keep iterating when
-      // we hit a maximized window.
-      has_maximized_window = true;
-    } else if (wm::IsWindowFullscreen(*i)) {
-      return WORKSPACE_WINDOW_STATE_FULL_SCREEN;
-    }
-    if (!window_overlaps_launcher && (*i)->bounds().Intersects(shelf_bounds))
-      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 WorkspaceManager::SetShelf(ShelfLayoutManager* shelf) {
-  shelf_ = shelf;
-}
-
-void WorkspaceManager::SetActiveWorkspaceByWindow(aura::Window* window) {
-  Workspace* workspace = FindBy(window);
-  if (workspace)
-    workspace->Activate();
-}
-
-aura::Window* WorkspaceManager::GetParentForNewWindow(aura::Window* window) {
-  return contents_view_;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// WorkspaceManager, private:
-
-void WorkspaceManager::AddWorkspace(Workspace* workspace) {
-  DCHECK(std::find(workspaces_.begin(), workspaces_.end(),
-                   workspace) == workspaces_.end());
-  if (active_workspace_) {
-    // New workspaces go right after current workspace.
-    Workspaces::iterator i = std::find(workspaces_.begin(), workspaces_.end(),
-                                       active_workspace_);
-    workspaces_.insert(++i, workspace);
-  } else {
-    workspaces_.push_back(workspace);
-  }
-}
-
-void WorkspaceManager::RemoveWorkspace(Workspace* workspace) {
-  Workspaces::iterator i = std::find(workspaces_.begin(),
-                                     workspaces_.end(),
-                                     workspace);
-  DCHECK(i != workspaces_.end());
-  i = workspaces_.erase(i);
-  if (active_workspace_ == workspace) {
-    // TODO: need mru order.
-    if (i != workspaces_.end())
-      SetActiveWorkspace(*i);
-    else if (!workspaces_.empty())
-      SetActiveWorkspace(workspaces_.back());
-    else
-      active_workspace_ = NULL;
-  }
-}
-
-void WorkspaceManager::SetVisibilityOfWorkspaceWindows(
-    ash::internal::Workspace* workspace,
-    AnimateChangeType change_type,
-    bool value) {
-  std::vector<aura::Window*> children;
-  BuildWindowList(workspace->windows(), maximize_restore_window_, &children);
-  SetWindowLayerVisibility(children, change_type, value);
-}
-
-void WorkspaceManager::SetWindowLayerVisibility(
-    const std::vector<aura::Window*>& windows,
-    AnimateChangeType change_type,
-    bool value) {
-  for (size_t i = 0; i < windows.size(); ++i) {
-    ui::Layer* layer = windows[i]->layer();
-    // Only show the layer for windows that want to be visible.
-    if (layer && (!value || windows[i]->TargetVisibility())) {
-      bool animation_disabled =
-          windows[i]->GetProperty(aura::client::kAnimationsDisabledKey);
-      WindowVisibilityAnimationType animation_type =
-          GetWindowVisibilityAnimationType(windows[i]);
-      windows[i]->SetProperty(aura::client::kAnimationsDisabledKey,
-                              change_type == DONT_ANIMATE);
-      bool update_layer = true;
-      if (change_type == ANIMATE) {
-        ash::SetWindowVisibilityAnimationType(
-            windows[i],
-            value ? ash::WINDOW_VISIBILITY_ANIMATION_TYPE_WORKSPACE_SHOW :
-                    ash::WINDOW_VISIBILITY_ANIMATION_TYPE_WORKSPACE_HIDE);
-        if (ash::internal::AnimateOnChildWindowVisibilityChanged(
-                windows[i], value))
-          update_layer = false;
-      }
-      if (update_layer)
-        layer->SetVisible(value);
-      // Reset the animation type so it isn't used in a future hide/show.
-      ash::SetWindowVisibilityAnimationType(
-          windows[i], animation_type);
-      windows[i]->SetProperty(aura::client::kAnimationsDisabledKey,
-                              animation_disabled);
-    }
-  }
-}
-
-Workspace* WorkspaceManager::GetActiveWorkspace() const {
-  return active_workspace_;
-}
-
-Workspace* WorkspaceManager::FindBy(aura::Window* window) const {
-  int index = GetWorkspaceIndexContaining(window);
-  return index < 0 ? NULL : workspaces_[index];
-}
-
-void WorkspaceManager::SetActiveWorkspace(Workspace* workspace) {
-  if (active_workspace_ == workspace)
-    return;
-  DCHECK(std::find(workspaces_.begin(), workspaces_.end(),
-                   workspace) != workspaces_.end());
-  if (active_workspace_)
-    SetVisibilityOfWorkspaceWindows(active_workspace_, ANIMATE, false);
-  Workspace* last_active = active_workspace_;
-  active_workspace_ = workspace;
-  if (active_workspace_) {
-    SetVisibilityOfWorkspaceWindows(active_workspace_,
-                                    last_active ? ANIMATE : DONT_ANIMATE, true);
-    UpdateShelfVisibility();
-  }
-}
-
-// Returns the index of the workspace that contains the |window|.
-int WorkspaceManager::GetWorkspaceIndexContaining(aura::Window* window) const {
-  for (Workspaces::const_iterator i = workspaces_.begin();
-       i != workspaces_.end();
-       ++i) {
-    if ((*i)->Contains(window))
-      return i - workspaces_.begin();
-  }
-  return -1;
-}
-
-void WorkspaceManager::SetWindowBounds(aura::Window* window,
-                                       const gfx::Rect& bounds) {
-  window->SetBounds(bounds);
-}
-
-void WorkspaceManager::OnTypeOfWorkspacedNeededChanged(aura::Window* window) {
-  DCHECK(ShouldManageWindow(window));
-  Workspace* current_workspace = FindBy(window);
-  DCHECK(current_workspace);
-  Workspace* new_workspace = NULL;
-  if (Workspace::TypeForWindow(window) == Workspace::TYPE_MAXIMIZED) {
-    // Unmaximized -> maximized; create a new workspace.
-    current_workspace->RemoveWindow(window);
-    new_workspace = CreateWorkspace(Workspace::TYPE_MAXIMIZED);
-    new_workspace->AddWindowAfter(window, NULL);
-  } else {
-    // Maximized -> unmaximized; move window to unmaximized workspace.
-    new_workspace = GetManagedWorkspace();
-    current_workspace->RemoveWindow(window);
-    if (!new_workspace)
-      new_workspace = CreateWorkspace(Workspace::TYPE_MANAGED);
-    new_workspace->AddWindowAfter(window, NULL);
-  }
-  maximize_restore_window_ = window;
-  SetActiveWorkspace(new_workspace);
-  maximize_restore_window_ = NULL;
-  // Delete at the end so that we don't attempt to switch to another
-  // workspace in RemoveWorkspace().
-  CleanupWorkspace(current_workspace);
-}
-
-Workspace* WorkspaceManager::GetManagedWorkspace() {
-  for (size_t i = 0; i < workspaces_.size(); ++i) {
-    if (workspaces_[i]->type() == Workspace::TYPE_MANAGED)
-      return workspaces_[i];
-  }
-  return NULL;
-}
-
-Workspace* WorkspaceManager::CreateWorkspace(Workspace::Type type) {
-  Workspace* workspace = NULL;
-  if (type == Workspace::TYPE_MAXIMIZED)
-    workspace = new MaximizedWorkspace(this);
-  else
-    workspace = new ManagedWorkspace(this);
-  AddWorkspace(workspace);
-  return workspace;
-}
-
-void WorkspaceManager::CleanupWorkspace(Workspace* workspace) {
-  if (workspace->type() != Workspace::TYPE_MANAGED && workspace->is_empty())
-    delete workspace;
-}
-
-}  // namespace internal
-}  // namespace ash