Renames and moves some workspace related classes to the workspace

ash/wm/workspace/workspace_layout_manager.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/default_container_layout_manager.h"
+#include "ash/wm/workspace/workspace_layout_manager.h"
 
 #include "ash/wm/property_util.h"
 #include "ash/wm/show_state_controller.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace.h"
 #include "ash/wm/workspace/workspace_manager.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/screen_aura.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/native_widget_aura.h"
 
 namespace ash {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
-// DefaultContainerLayoutManager, public:
+// WorkspaceLayoutManager, public:
 
-DefaultContainerLayoutManager::DefaultContainerLayoutManager(
+WorkspaceLayoutManager::WorkspaceLayoutManager(
     WorkspaceManager* workspace_manager)
     : workspace_manager_(workspace_manager),
       show_state_controller_(new ShowStateController(workspace_manager)) {
 }
 
-DefaultContainerLayoutManager::~DefaultContainerLayoutManager() {}
+WorkspaceLayoutManager::~WorkspaceLayoutManager() {}
 
-void DefaultContainerLayoutManager::PrepareForMoveOrResize(
+void WorkspaceLayoutManager::PrepareForMoveOrResize(
     aura::Window* drag,
     aura::MouseEvent* event) {
   workspace_manager_->set_ignored_window(drag);
 }
 
-void DefaultContainerLayoutManager::CancelMoveOrResize(
+void WorkspaceLayoutManager::CancelMoveOrResize(
     aura::Window* drag,
     aura::MouseEvent* event) {
   workspace_manager_->set_ignored_window(NULL);
 }
 
-void DefaultContainerLayoutManager::ProcessMove(
+void WorkspaceLayoutManager::ProcessMove(
     aura::Window* drag,
     aura::MouseEvent* event) {
   // TODO(oshima): Just zooming out may (and will) move/swap window without
   // a users's intent. We probably should scroll viewport, but that may not
   // be enough. See crbug.com/101826 for more discussion.
   workspace_manager_->SetOverview(true);
 
   gfx::Point point_in_owner = event->location();
   aura::Window::ConvertPointToWindow(
       drag,
       workspace_manager_->contents_view(),
       &point_in_owner);
   // TODO(oshima): We should support simply moving to another
   // workspace when the destination workspace has enough room to accomodate.
   aura::Window* rotate_target =
       workspace_manager_->FindRotateWindowForLocation(point_in_owner);
   if (rotate_target)
     workspace_manager_->RotateWindows(drag, rotate_target);
 }
 
-void DefaultContainerLayoutManager::EndMove(
+void WorkspaceLayoutManager::EndMove(
     aura::Window* drag,
     aura::MouseEvent* evnet) {
   // TODO(oshima): finish moving window between workspaces.
   workspace_manager_->set_ignored_window(NULL);
   Workspace* workspace = workspace_manager_->FindBy(drag);
   workspace->Layout(NULL);
   workspace->Activate();
   workspace_manager_->SetOverview(false);
 }
 
-void DefaultContainerLayoutManager::EndResize(
+void WorkspaceLayoutManager::EndResize(
     aura::Window* drag,
     aura::MouseEvent* evnet) {
   workspace_manager_->set_ignored_window(NULL);
   Workspace* workspace = workspace_manager_->GetActiveWorkspace();
   if (workspace)
     workspace->Layout(NULL);
   workspace_manager_->SetOverview(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// DefaultContainerLayoutManager, aura::LayoutManager implementation:
+// WorkspaceLayoutManager, aura::LayoutManager implementation:
 
-void DefaultContainerLayoutManager::OnWindowResized() {
+void WorkspaceLayoutManager::OnWindowResized() {
   // Workspace is updated via RootWindowObserver::OnRootWindowResized.
 }
 
-void DefaultContainerLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
+void WorkspaceLayoutManager::OnWindowAddedToLayout(aura::Window* child) {
   if (child->type() != aura::client::WINDOW_TYPE_NORMAL ||
       child->transient_parent()) {
     return;
   }
 
   if (!child->GetProperty(aura::client::kShowStateKey))
     child->SetIntProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
 
   child->AddObserver(show_state_controller_.get());
 
   Workspace* workspace = workspace_manager_->GetActiveWorkspace();
   if (workspace) {
     aura::Window* active = ash::GetActiveWindow();
     // Active window may not be in the default container layer.
     if (!workspace->Contains(active))
       active = NULL;
     if (workspace->AddWindowAfter(child, active))
       return;
   }
   // Create new workspace if new |child| doesn't fit to current workspace.
   Workspace* new_workspace = workspace_manager_->CreateWorkspace();
   new_workspace->AddWindowAfter(child, NULL);
   new_workspace->Activate();
 }
 
-void DefaultContainerLayoutManager::OnWillRemoveWindowFromLayout(
+void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(
     aura::Window* child) {
   child->RemoveObserver(show_state_controller_.get());
   ClearRestoreBounds(child);
 
   Workspace* workspace = workspace_manager_->FindBy(child);
   if (!workspace)
     return;
   workspace->RemoveWindow(child);
   if (workspace->is_empty())
     delete workspace;
 }
 
-void DefaultContainerLayoutManager::OnChildWindowVisibilityChanged(
+void WorkspaceLayoutManager::OnChildWindowVisibilityChanged(
     aura::Window* child,
     bool visible) {
   NOTIMPLEMENTED();
 }
 
-void DefaultContainerLayoutManager::SetChildBounds(
+void WorkspaceLayoutManager::SetChildBounds(
     aura::Window* child,
     const gfx::Rect& requested_bounds) {
   gfx::Rect adjusted_bounds = requested_bounds;
 
   // First, calculate the adjusted bounds.
   if (child->type() != aura::client::WINDOW_TYPE_NORMAL ||
       workspace_manager_->layout_in_progress() ||
       child->transient_parent()) {
     // Use the requested bounds as is.
   } else if (child == workspace_manager_->ignored_window()) {
@@ skipping 28 matching lines @@
       adjusted_bounds = workspace->bounds();
     // Don't
     if (child->GetTargetBounds() == adjusted_bounds)
       return;
   }
   SetChildBoundsDirect(child, adjusted_bounds);
 }
 
 }  // namespace internal
 }  // namespace ash