Shell related switches -> aura shell switches.

ui/aura_shell/activation_controller.cc

 // Copyright (c) 2011 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 "ui/aura_shell/activation_controller.h"
 
 #include "base/auto_reset.h"
 #include "ui/aura/client/activation_delegate.h"
-#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura_shell/shell.h"
 #include "ui/aura_shell/shell_window_ids.h"
 #include "ui/aura_shell/window_util.h"
 
 namespace aura_shell {
 namespace internal {
 namespace {
@@ skipping 70 matching lines @@
   aura::Window* old_active = GetActiveWindow();
   if (old_active == window)
     return;
   // The stacking client may impose rules on what window configurations can be
   // activated or deactivated.
   if (!CanActivateWindow(window))
     return;
 
   if (!window->Contains(window->GetFocusManager()->GetFocusedWindow()))
     window->GetFocusManager()->SetFocusedWindow(window);
-  aura::RootWindow::GetInstance()->SetProperty(aura::kRootWindowActiveWindow,
-                                               window);
+  aura::RootWindow::GetInstance()->SetProperty(
+      aura::client::kRootWindowActiveWindow,
+      window);
   // Invoke OnLostActive after we've changed the active window. That way if the
   // delegate queries for active state it doesn't think the window is still
   // active.
   if (old_active && aura::client::GetActivationDelegate(old_active))
     aura::client::GetActivationDelegate(old_active)->OnLostActive();
   if (window) {
     window->parent()->StackChildAtTop(window);
     if (aura::client::GetActivationDelegate(window))
       aura::client::GetActivationDelegate(window)->OnActivated();
   }
 }
 
 void ActivationController::DeactivateWindow(aura::Window* window) {
   if (window)
     ActivateNextWindow(window);
 }
 
 aura::Window* ActivationController::GetActiveWindow() {
   return reinterpret_cast<aura::Window*>(
       aura::RootWindow::GetInstance()->GetProperty(
-          aura::kRootWindowActiveWindow));
+          aura::client::kRootWindowActiveWindow));
 }
 
 bool ActivationController::CanFocusWindow(aura::Window* window) const {
   return CanActivateWindow(GetActivatableWindow(window));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::WindowObserver implementation:
 
 void ActivationController::OnWindowVisibilityChanged(aura::Window* window,
                                                      bool visible) {
   if (!visible)
     ActivateNextWindow(window);
 }
 
 void ActivationController::OnWindowDestroyed(aura::Window* window) {
   if (IsActiveWindow(window)) {
     // Clear the property before activating something else, since
     // ActivateWindow() will attempt to notify the window stored in this value
     // otherwise.
-    aura::RootWindow::GetInstance()->SetProperty(aura::kRootWindowActiveWindow,
-                                                 NULL);
+    aura::RootWindow::GetInstance()->SetProperty(
+        aura::client::kRootWindowActiveWindow,
+        NULL);
     ActivateWindow(GetTopmostWindowToActivate(window));
   }
   window->RemoveObserver(this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::RootWindowObserver implementation:
 
 void ActivationController::OnWindowInitialized(aura::Window* window) {
   window->AddObserver(this);
@@ skipping 21 matching lines @@
        i != container->children().rend();
        ++i) {
     if (*i != ignore && CanActivateWindow(*i))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace aura_shell