Renames two WorkspaceManager methods so that they are more clearly

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 "ash/screen_ash.h"
 #include "ash/shell.h"
@@ skipping 48 matching lines @@
       grid_size_(0),
       shelf_(NULL) {
   DCHECK(contents_view);
 }
 
 WorkspaceManager::~WorkspaceManager() {
   std::vector<Workspace*> copy_to_delete(workspaces_);
   STLDeleteElements(&copy_to_delete);
 }
 
-bool WorkspaceManager::IsManagedWindow(aura::Window* window) const {
+// static
+bool WorkspaceManager::ShouldManageWindow(aura::Window* window) {
   return window->type() == aura::client::WINDOW_TYPE_NORMAL &&
          !window->transient_parent() &&
          ash::GetTrackedByWorkspace(window) &&
          !ash::GetPersistsAcrossAllWorkspaces(window);
 }
 
-bool WorkspaceManager::IsManagingWindow(aura::Window* window) const {
+bool WorkspaceManager::Contains(aura::Window* window) const {
   return FindBy(window) != NULL;
 }
 
 bool WorkspaceManager::IsInMaximizedMode() const {
   return active_workspace_ &&
       active_workspace_->type() == Workspace::TYPE_MAXIMIZED;
 }
 
 void WorkspaceManager::AddWindow(aura::Window* window) {
-  DCHECK(IsManagedWindow(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();
@@ skipping 65 matching lines @@
       window_overlaps_launcher = true;
   }
   if (has_maximized_window)
     return WINDOW_STATE_MAXIMIZED;
 
   return window_overlaps_launcher ? WINDOW_STATE_WINDOW_OVERLAPS_SHELF :
       WINDOW_STATE_DEFAULT;
 }
 
 void WorkspaceManager::ShowStateChanged(aura::Window* window) {
-  if (!IsManagedWindow(window) || !FindBy(window))
+  if (!ShouldManageWindow(window) || !FindBy(window))
     return;
 
   Workspace::Type old_type = FindBy(window)->type();
   Workspace::Type new_type = Workspace::TypeForWindow(window);
   if (new_type != old_type)
     OnTypeOfWorkspacedNeededChanged(window);
   UpdateShelfVisibility();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 108 matching lines @@
   }
   return -1;
 }
 
 void WorkspaceManager::SetWindowBounds(aura::Window* window,
                                        const gfx::Rect& bounds) {
   window->SetBounds(bounds);
 }
 
 void WorkspaceManager::OnTypeOfWorkspacedNeededChanged(aura::Window* window) {
-  DCHECK(IsManagedWindow(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.
@@ skipping 29 matching lines @@
   return workspace;
 }
 
 void WorkspaceManager::CleanupWorkspace(Workspace* workspace) {
   if (workspace->type() != Workspace::TYPE_MANAGED && workspace->is_empty())
     delete workspace;
 }
 
 }  // namespace internal
 }  // namespace ash