Move ActivationClient/Delegate to client namespace.

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"
@@ skipping 19 matching lines @@
          window->id() == kShellWindowId_LockScreenContainer ||
          window->id() == kShellWindowId_LockModalContainer;
 }
 
 // Returns true if |window| can be activated or deactivated.
 // A window manager typically defines some notion of "top level window" that
 // supports activation/deactivation.
 bool CanActivateWindow(aura::Window* window) {
   return window &&
       window->IsVisible() &&
-      (!aura::ActivationDelegate::GetActivationDelegate(window) ||
-        aura::ActivationDelegate::GetActivationDelegate(window)->
-            ShouldActivate(NULL)) &&
+      (!aura::client::GetActivationDelegate(window) ||
+        aura::client::GetActivationDelegate(window)->ShouldActivate(NULL)) &&
       SupportsChildActivation(window->parent());
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, public:
 
 ActivationController::ActivationController()
     : updating_activation_(false),
       default_container_for_test_(NULL) {
-  aura::ActivationClient::SetActivationClient(this);
+  aura::client::SetActivationClient(this);
   aura::RootWindow::GetInstance()->AddRootWindowObserver(this);
 }
 
 ActivationController::~ActivationController() {
   aura::RootWindow::GetInstance()->RemoveRootWindowObserver(this);
 }
 
 // static
 aura::Window* ActivationController::GetActivatableWindow(aura::Window* window) {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
     if (SupportsChildActivation(parent))
       return child;
     // If |child| isn't activatable, but has transient parent, trace
     // that path instead.
     if (child->transient_parent())
       return GetActivatableWindow(child->transient_parent());
     parent = parent->parent();
     child = child->parent();
   }
   return NULL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// StackingController, aura::ActivationClient implementation:
+// ActivationController, aura::client::ActivationClient implementation:
 
 void ActivationController::ActivateWindow(aura::Window* window) {
   // Prevent recursion when called from focus.
   if (updating_activation_)
     return;
 
   AutoReset<bool> in_activate_window(&updating_activation_, true);
   if (!window)
     return;
   // Nothing may actually have changed.
   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);
   // 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::ActivationDelegate::GetActivationDelegate(old_active))
-    aura::ActivationDelegate::GetActivationDelegate(old_active)->OnLostActive();
+  if (old_active && aura::client::GetActivationDelegate(old_active))
+    aura::client::GetActivationDelegate(old_active)->OnLostActive();
   if (window) {
     window->parent()->StackChildAtTop(window);
-    if (aura::ActivationDelegate::GetActivationDelegate(window))
-      aura::ActivationDelegate::GetActivationDelegate(window)->OnActivated();
+    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*>(
@@ skipping 55 matching lines @@
        i != container->children().rend();
        ++i) {
     if (*i != ignore && CanActivateWindow(*i))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace aura_shell