Converts MruWindowTracker to work with common types

ash/wm/ash_focus_rules.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/ash_focus_rules.h"
 
+#include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
+#include "ash/common/wm/focus_rules.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/wm/mru_window_tracker.h"
 #include "ash/wm/window_state_aura.h"
 #include "ui/aura/window.h"
 
 namespace ash {
 namespace wm {
 namespace {
@@ skipping 12 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // AshFocusRules, public:
 
 AshFocusRules::AshFocusRules() {
 }
 
 AshFocusRules::~AshFocusRules() {
 }
 
 bool AshFocusRules::IsWindowConsideredActivatable(aura::Window* window) const {
-  // Only toplevel windows can be activated.
-  if (!IsToplevelWindow(window))
-    return false;
-
-  // The window must be visible.
-  if (!IsWindowConsideredVisibleForActivation(window))
-    return false;
-
-  return true;
+  return ash::IsWindowConsideredActivatable(WmWindowAura::Get(window));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AshFocusRules, ::wm::FocusRules:
 
+bool AshFocusRules::IsToplevelWindow(aura::Window* window) const {
+  return ash::IsToplevelWindow(WmWindowAura::Get(window));
+}
+
 bool AshFocusRules::SupportsChildActivation(aura::Window* window) const {
-  if (window->id() == kShellWindowId_DefaultContainer)
-    return true;
-
-  for (size_t i = 0; i < kNumActivatableShellWindowIds; i++) {
-    if (window->id() == kActivatableShellWindowIds[i])
-      return true;
-  }
-  return false;
+  return ash::IsActivatableShellWindowId(window->id());
 }
 
 bool AshFocusRules::IsWindowConsideredVisibleForActivation(
     aura::Window* window) const {
-  // If the |window| doesn't belong to the current active user and also doesn't
-  // show for the current active user, then it should not be activated.
-  if (!Shell::GetInstance()->delegate()->CanShowWindowForUser(window))
-    return false;
-
-  if (BaseFocusRules::IsWindowConsideredVisibleForActivation(window))
-    return true;
-
-  // Minimized windows are hidden in their minimized state, but they can always
-  // be activated.
-  if (wm::GetWindowState(window)->IsMinimized())
-    return true;
-
-  return window->TargetVisibility() &&
-         (window->parent()->id() == kShellWindowId_DefaultContainer ||
-          window->parent()->id() == kShellWindowId_LockScreenContainer);
+  return ash::IsWindowConsideredVisibleForActivation(WmWindowAura::Get(window));
 }
 
 bool AshFocusRules::CanActivateWindow(aura::Window* window) const {
   // Clearing activation is always permissible.
   if (!window)
     return true;
 
   if (!BaseFocusRules::CanActivateWindow(window))
     return false;
 
   if (Shell::GetInstance()->IsSystemModalWindowOpen()) {
     return BelongsToContainerWithEqualOrGreaterId(
         window, kShellWindowId_SystemModalContainer);
   }
 
   return true;
 }
 
 aura::Window* AshFocusRules::GetNextActivatableWindow(
     aura::Window* ignore) const {
   DCHECK(ignore);
 
   // Start from the container of the most-recently-used window. If the list of
   // MRU windows is empty, then start from the container of the window that just
   // lost focus |ignore|.
   ash::MruWindowTracker* mru = ash::Shell::GetInstance()->mru_window_tracker();
-  std::vector<aura::Window*> windows = mru->BuildMruWindowList();
-  aura::Window* starting_window = windows.empty() ? ignore : windows[0];
+  std::vector<WmWindow*> windows = mru->BuildMruWindowList();
+  aura::Window* starting_window =
+      windows.empty() ? ignore : WmWindowAura::GetAuraWindow(windows[0]);
 
   // Look for windows to focus in |starting_window|'s container. If none are
   // found, we look in all the containers in front of |starting_window|'s
   // container, then all behind.
   int starting_container_index = 0;
   aura::Window* root = starting_window->GetRootWindow();
   if (!root)
     root = Shell::GetTargetRootWindow();
   int container_count = static_cast<int>(kNumActivatableShellWindowIds);
   for (int i = 0; i < container_count; i++) {
@@ skipping 43 matching lines @@
     if (*i != ignore &&
         window_state->CanActivate() &&
         !window_state->IsMinimized())
       return *i;
   }
   return NULL;
 }
 
 }  // namespace wm
 }  // namespace ash