Move ActivationClient/Delegate to client namespace.

BUG=none
TEST=existing automation
TBR=sky
Review URL: http://codereview.chromium.org/8956004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@114657 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 55 insertions, 55 deletions

diff --git a/ui/aura/client/activation_client.cc b/ui/aura/client/activation_client.cc
index 8106ca2..bbb9bcc 100644
--- a/ui/aura/client/activation_client.cc
+++ b/ui/aura/client/activation_client.cc
@@ -8,16 +8,16 @@
 #include "ui/aura/root_window.h"
 
 namespace aura {
+namespace client {
 
-// static
-void ActivationClient::SetActivationClient(ActivationClient* client) {
+void SetActivationClient(ActivationClient* client) {
   RootWindow::GetInstance()->SetProperty(kRootWindowActivationClient, client);
 }
 
-// static
-ActivationClient* ActivationClient::GetActivationClient() {
+ActivationClient* GetActivationClient() {
   return reinterpret_cast<ActivationClient*>(
       RootWindow::GetInstance()->GetProperty(kRootWindowActivationClient));
 }
 
+}  // namespace client
 }  // namespace aura
diff --git a/ui/aura/client/activation_client.h b/ui/aura/client/activation_client.h
index 547f9ab..c75a1e5 100644
--- a/ui/aura/client/activation_client.h
+++ b/ui/aura/client/activation_client.h
@@ -9,16 +9,12 @@
 #include "ui/aura/aura_export.h"
 
 namespace aura {
-
 class Window;
+namespace client {
 
 // An interface implemented by an object that manages window activation.
 class AURA_EXPORT ActivationClient {
  public:
-  // Sets/Gets the activation client on the RootWindow.
-  static void SetActivationClient(ActivationClient* client);
-  static ActivationClient* GetActivationClient();
-
   // Activates |window|. If |window| is NULL, nothing happens.
   virtual void ActivateWindow(Window* window) = 0;
 
@@ -37,6 +33,11 @@ class AURA_EXPORT ActivationClient {
   virtual ~ActivationClient() {}
 };
 
+// Sets/Gets the activation client on the RootWindow.
+AURA_EXPORT void SetActivationClient(ActivationClient* client);
+AURA_EXPORT ActivationClient* GetActivationClient();
+
+}  // namespace clients
 }  // namespace aura
 
 #endif  // UI_AURA_CLIENT_ACTIVATION_CLIENT_H_
diff --git a/ui/aura/client/activation_delegate.cc b/ui/aura/client/activation_delegate.cc
index 18688f0..734a4da 100644
--- a/ui/aura/client/activation_delegate.cc
+++ b/ui/aura/client/activation_delegate.cc
@@ -8,17 +8,16 @@
 #include "ui/aura/window.h"
 
 namespace aura {
+namespace client {
 
-// static
-void ActivationDelegate::SetActivationDelegate(Window* window,
-                                               ActivationDelegate* delegate) {
+void SetActivationDelegate(Window* window, ActivationDelegate* delegate) {
   window->SetProperty(kActivationDelegateKey, delegate);
 }
 
-// static
-ActivationDelegate* ActivationDelegate::GetActivationDelegate(Window* window) {
+ActivationDelegate* GetActivationDelegate(Window* window) {
   return reinterpret_cast<ActivationDelegate*>(
       window->GetProperty(kActivationDelegateKey));
 }
 
+}  // namespace client
 }  // namespace aura
diff --git a/ui/aura/client/activation_delegate.h b/ui/aura/client/activation_delegate.h
index dd2933e..b711cbd 100644
--- a/ui/aura/client/activation_delegate.h
+++ b/ui/aura/client/activation_delegate.h
@@ -9,19 +9,14 @@
 #include "ui/aura/aura_export.h"
 
 namespace aura {
-
 class Event;
 class Window;
+namespace client {
 
 // An interface implemented by an object that configures and responds to changes
 // to a window's activation state.
 class AURA_EXPORT ActivationDelegate {
  public:
-  // Sets/Gets the ActivationDelegate on the Window. No ownership changes.
-  static void SetActivationDelegate(Window* window,
-                                    ActivationDelegate* delegate);
-  static ActivationDelegate* GetActivationDelegate(Window* window);
-
   // Returns true if the window should be activated. |event| is either the mouse
   // event supplied if the activation is the result of a mouse, or the touch
   // event if the activation is the result of a touch, or NULL if activation is
@@ -38,6 +33,12 @@ class AURA_EXPORT ActivationDelegate {
   virtual ~ActivationDelegate() {}
 };
 
+// Sets/Gets the ActivationDelegate on the Window. No ownership changes.
+AURA_EXPORT void SetActivationDelegate(Window* window,
+                                       ActivationDelegate* delegate);
+AURA_EXPORT ActivationDelegate* GetActivationDelegate(Window* window);
+
+}  // namespace client
 }  // namespace aura
 
 #endif  // UI_AURA_CLIENT_ACTIVATION_DELEGATE_H_
diff --git a/ui/aura/client/aura_constants.h b/ui/aura/client/aura_constants.h
index 07e85e4..a964c13 100644
--- a/ui/aura/client/aura_constants.h
+++ b/ui/aura/client/aura_constants.h
@@ -31,7 +31,7 @@ AURA_EXPORT extern const char kModalKey[];
 AURA_EXPORT extern const char kRestoreBoundsKey[];
 
 // A property key to store a client that handles window activation. The type of
-// the value is |aura::ActivationClient*|.
+// the value is |aura::client::ActivationClient*|.
 AURA_EXPORT extern const char kRootWindowActivationClient[];
 
 // A property key to store what the client defines as the active window on the
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index 7b9218c..10535a7 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -477,9 +477,8 @@ void RootWindow::SetFocusedWindow(Window* focused_window) {
   // The NULL-check of |focused)window| is essential here before asking the
   // activation client, since it is valid to clear the focus by calling
   // SetFocusedWindow() to NULL.
-  if (focused_window && ActivationClient::GetActivationClient() &&
-      !ActivationClient::GetActivationClient()->CanFocusWindow(
-          focused_window)) {
+  if (focused_window && client::GetActivationClient() &&
+      !client::GetActivationClient()->CanFocusWindow(focused_window)) {
     return;
   }
 
diff --git a/ui/aura/test/test_activation_client.cc b/ui/aura/test/test_activation_client.cc
index 6f32ea7..a6aef6a 100644
--- a/ui/aura/test/test_activation_client.cc
+++ b/ui/aura/test/test_activation_client.cc
@@ -13,14 +13,14 @@ namespace test {
 // TestActivationClient, public:
 
 TestActivationClient::TestActivationClient() : active_window_(NULL) {
-  ActivationClient::SetActivationClient(this);
+  client::SetActivationClient(this);
 }
 
 TestActivationClient::~TestActivationClient() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// TestActivationClient, ActivationClient implementation:
+// TestActivationClient, client::ActivationClient implementation:
 
 void TestActivationClient::ActivateWindow(Window* window) {
   if (active_window_)
diff --git a/ui/aura/test/test_activation_client.h b/ui/aura/test/test_activation_client.h
index 22d56e5..a0454ca 100644
--- a/ui/aura/test/test_activation_client.h
+++ b/ui/aura/test/test_activation_client.h
@@ -14,12 +14,13 @@
 namespace aura {
 namespace test {
 
-class TestActivationClient : public ActivationClient, public WindowObserver {
+class TestActivationClient : public client::ActivationClient,
+                             public WindowObserver {
  public:
   TestActivationClient();
   virtual ~TestActivationClient();
 
-  // Overridden from ActivationClient:
+  // Overridden from client::ActivationClient:
   virtual void ActivateWindow(Window* window) OVERRIDE;
   virtual void DeactivateWindow(Window* window) OVERRIDE;
   virtual Window* GetActiveWindow() OVERRIDE;
diff --git a/ui/aura_shell/activation_controller.cc b/ui/aura_shell/activation_controller.cc
index 8bc474a3b..68d702e 100644
--- a/ui/aura_shell/activation_controller.cc
+++ b/ui/aura_shell/activation_controller.cc
@@ -37,9 +37,8 @@ bool SupportsChildActivation(aura::Window* window) {
 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());
 }
 
@@ -51,7 +50,7 @@ bool CanActivateWindow(aura::Window* window) {
 ActivationController::ActivationController()
     : updating_activation_(false),
       default_container_for_test_(NULL) {
-  aura::ActivationClient::SetActivationClient(this);
+  aura::client::SetActivationClient(this);
   aura::RootWindow::GetInstance()->AddRootWindowObserver(this);
 }
 
@@ -77,7 +76,7 @@ aura::Window* ActivationController::GetActivatableWindow(aura::Window* window) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// StackingController, aura::ActivationClient implementation:
+// ActivationController, aura::client::ActivationClient implementation:
 
 void ActivationController::ActivateWindow(aura::Window* window) {
   // Prevent recursion when called from focus.
@@ -103,12 +102,12 @@ void ActivationController::ActivateWindow(aura::Window* 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();
   }
 }
 
diff --git a/ui/aura_shell/activation_controller.h b/ui/aura_shell/activation_controller.h
index 0a4e129..a849d9b 100644
--- a/ui/aura_shell/activation_controller.h
+++ b/ui/aura_shell/activation_controller.h
@@ -18,9 +18,10 @@ namespace aura_shell {
 namespace internal {
 
 // Exported for unit tests.
-class AURA_SHELL_EXPORT ActivationController : public aura::ActivationClient,
-                                               public aura::WindowObserver,
-                                               public aura::RootWindowObserver {
+class AURA_SHELL_EXPORT ActivationController
+    : public aura::client::ActivationClient,
+      public aura::WindowObserver,
+      public aura::RootWindowObserver {
  public:
   ActivationController();
   virtual ~ActivationController();
@@ -29,7 +30,7 @@ class AURA_SHELL_EXPORT ActivationController : public aura::ActivationClient,
   // activation.
   static aura::Window* GetActivatableWindow(aura::Window* window);
 
-  // Overridden from aura::ActivationClient:
+  // Overridden from aura::client::ActivationClient:
   virtual void ActivateWindow(aura::Window* window) OVERRIDE;
   virtual void DeactivateWindow(aura::Window* window) OVERRIDE;
   virtual aura::Window* GetActiveWindow() OVERRIDE;
diff --git a/ui/aura_shell/test/test_activation_delegate.cc b/ui/aura_shell/test/test_activation_delegate.cc
index ac63bdb..e9a9bda 100644
--- a/ui/aura_shell/test/test_activation_delegate.cc
+++ b/ui/aura_shell/test/test_activation_delegate.cc
@@ -34,7 +34,7 @@ TestActivationDelegate::TestActivationDelegate(bool activate)
 
 void TestActivationDelegate::SetWindow(aura::Window* window) {
   window_ = window;
-  aura::ActivationDelegate::SetActivationDelegate(window, this);
+  aura::client::SetActivationDelegate(window, this);
 }
 
 bool TestActivationDelegate::ShouldActivate(aura::Event* event) {
diff --git a/ui/aura_shell/test/test_activation_delegate.h b/ui/aura_shell/test/test_activation_delegate.h
index d3f1c85..fab656e 100644
--- a/ui/aura_shell/test/test_activation_delegate.h
+++ b/ui/aura_shell/test/test_activation_delegate.h
@@ -19,7 +19,7 @@ namespace test {
 
 // A test ActivationDelegate that can be used to track activation changes for
 // an aura::Window.
-class TestActivationDelegate : public aura::ActivationDelegate {
+class TestActivationDelegate : public aura::client::ActivationDelegate {
  public:
   TestActivationDelegate();
   explicit TestActivationDelegate(bool activate);
@@ -37,7 +37,7 @@ class TestActivationDelegate : public aura::ActivationDelegate {
     window_was_active_ = false;
   }
 
-  // Overridden from ActivationDelegate:
+  // Overridden from client::ActivationDelegate:
   virtual bool ShouldActivate(aura::Event* event) OVERRIDE;
   virtual void OnActivated() OVERRIDE;
   virtual void OnLostActive() OVERRIDE;
diff --git a/ui/aura_shell/window_util.cc b/ui/aura_shell/window_util.cc
index 133962d..d9b40b9 100644
--- a/ui/aura_shell/window_util.cc
+++ b/ui/aura_shell/window_util.cc
@@ -21,11 +21,11 @@ bool IsWindowMaximized(aura::Window* window) {
 }
 
 void ActivateWindow(aura::Window* window) {
-  aura::ActivationClient::GetActivationClient()->ActivateWindow(window);
+  aura::client::GetActivationClient()->ActivateWindow(window);
 }
 
 void DeactivateWindow(aura::Window* window) {
-  aura::ActivationClient::GetActivationClient()->DeactivateWindow(window);
+  aura::client::GetActivationClient()->DeactivateWindow(window);
 }
 
 bool IsActiveWindow(aura::Window* window) {
@@ -33,7 +33,7 @@ bool IsActiveWindow(aura::Window* window) {
 }
 
 aura::Window* GetActiveWindow() {
-  return aura::ActivationClient::GetActivationClient()->GetActiveWindow();
+  return aura::client::GetActivationClient()->GetActiveWindow();
 }
 
 aura::Window* GetActivatableWindow(aura::Window* window) {
diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc
index 89e75ca..619018b 100644
--- a/ui/views/widget/native_widget_aura.cc
+++ b/ui/views/widget/native_widget_aura.cc
@@ -93,7 +93,7 @@ class NativeWidgetAura::ActiveWindowObserver : public aura::WindowObserver {
     if (key != aura::kRootWindowActiveWindow)
       return;
     aura::Window* active =
-        aura::ActivationClient::GetActivationClient()->GetActiveWindow();
+        aura::client::GetActivationClient()->GetActiveWindow();
     if (!active || (active != host_->window_ &&
                     active->transient_parent() != host_->window_)) {
       host_->delegate_->EnableInactiveRendering();
@@ -187,7 +187,7 @@ void NativeWidgetAura::InitNativeWidget(const Widget::InitParams& params) {
     aura::client::SetDragDropDelegate(window_, this);
   }
 
-  aura::ActivationDelegate::SetActivationDelegate(window_, this);
+  aura::client::SetActivationDelegate(window_, this);
 
   if (window_type == Widget::InitParams::TYPE_MENU ||
       window_type == Widget::InitParams::TYPE_TOOLTIP)
@@ -442,16 +442,15 @@ bool NativeWidgetAura::IsVisible() const {
 }
 
 void NativeWidgetAura::Activate() {
-  aura::ActivationClient::GetActivationClient()->ActivateWindow(window_);
+  aura::client::GetActivationClient()->ActivateWindow(window_);
 }
 
 void NativeWidgetAura::Deactivate() {
-  aura::ActivationClient::GetActivationClient()->DeactivateWindow(window_);
+  aura::client::GetActivationClient()->DeactivateWindow(window_);
 }
 
 bool NativeWidgetAura::IsActive() const {
-  return aura::ActivationClient::GetActivationClient()->GetActiveWindow() ==
-      window_;
+  return aura::client::GetActivationClient()->GetActiveWindow() == window_;
 }
 
 void NativeWidgetAura::SetAlwaysOnTop(bool on_top) {
diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h
index 89676a3..121b89b 100644
--- a/ui/views/widget/native_widget_aura.h
+++ b/ui/views/widget/native_widget_aura.h
@@ -29,7 +29,7 @@ class TooltipManagerAura;
 
 class VIEWS_EXPORT NativeWidgetAura : public internal::NativeWidgetPrivate,
                                       public aura::WindowDelegate,
-                                      public aura::ActivationDelegate,
+                                      public aura::client::ActivationDelegate,
                                       public aura::client::DragDropDelegate {
  public:
   explicit NativeWidgetAura(internal::NativeWidgetDelegate* delegate);
@@ -140,7 +140,7 @@ class VIEWS_EXPORT NativeWidgetAura : public internal::NativeWidgetPrivate,
   virtual void OnWindowDestroyed() OVERRIDE;
   virtual void OnWindowVisibilityChanged(bool visible) OVERRIDE;
 
-  // Overridden from aura::ActivationDelegate:
+  // Overridden from aura::client::ActivationDelegate:
   virtual bool ShouldActivate(aura::Event* event) OVERRIDE;
   virtual void OnActivated() OVERRIDE;
   virtual void OnLostActive() OVERRIDE;