Move DefaultActivationClient to wm/core

Several tests are using AuraTestHelper and were relying on it to set up the DefaultActivationClient, so I had to have them instantiate the DAC directly after calling SetUp() on the helper. I also had to make the DAC delete itself after the root window it's bound to is destroyed.

R=sky@chromium.org
http://crbug.com/308710

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=266616

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=266975

Review URL: https://codereview.chromium.org/250113002

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

8 files changed, 241 insertions, 5 deletions

diff --git a/ui/wm/core/compound_event_filter_unittest.cc b/ui/wm/core/compound_event_filter_unittest.cc
index aea992c..afd3bcb 100644
--- a/ui/wm/core/compound_event_filter_unittest.cc
+++ b/ui/wm/core/compound_event_filter_unittest.cc
@@ -14,6 +14,7 @@
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/public/activation_client.h"
 
 namespace {
@@ -112,6 +113,7 @@ TEST_F(CompoundEventFilterTest, CursorVisibilityChange) {
 #if defined(OS_CHROMEOS) || defined(OS_WIN)
 // Touch visually hides the cursor on ChromeOS and Windows.
 TEST_F(CompoundEventFilterTest, TouchHidesCursor) {
+  new wm::DefaultActivationClient(root_window());
   scoped_ptr<CompoundEventFilter> compound_filter(new CompoundEventFilter);
   aura::Env::GetInstance()->AddPreTargetHandler(compound_filter.get());
   aura::test::TestWindowDelegate delegate;
diff --git a/ui/wm/core/default_activation_client.cc b/ui/wm/core/default_activation_client.cc
new file mode 100644
index 0000000..222c9ac
--- /dev/null
+++ b/ui/wm/core/default_activation_client.cc
@@ -0,0 +1,157 @@
+// Copyright 2013 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/wm/core/default_activation_client.h"
+
+#include "ui/aura/window.h"
+#include "ui/wm/public/activation_change_observer.h"
+#include "ui/wm/public/activation_delegate.h"
+
+namespace wm {
+
+// Takes care of observing root window destruction & destroying the client.
+class DefaultActivationClient::Deleter : public aura::WindowObserver {
+ public:
+  Deleter(DefaultActivationClient* client, aura::Window* root_window)
+      : client_(client),
+        root_window_(root_window) {
+    root_window_->AddObserver(this);
+  }
+
+ private:
+  virtual ~Deleter() {}
+
+  // Overridden from WindowObserver:
+  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
+    DCHECK_EQ(window, root_window_);
+    root_window_->RemoveObserver(this);
+    delete client_;
+    delete this;
+  }
+
+  DefaultActivationClient* client_;
+  aura::Window* root_window_;
+
+  DISALLOW_COPY_AND_ASSIGN(Deleter);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// DefaultActivationClient, public:
+
+DefaultActivationClient::DefaultActivationClient(aura::Window* root_window)
+    : last_active_(NULL) {
+  aura::client::SetActivationClient(root_window, this);
+  new Deleter(this, root_window);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DefaultActivationClient, client::ActivationClient implementation:
+
+void DefaultActivationClient::AddObserver(
+    aura::client::ActivationChangeObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void DefaultActivationClient::RemoveObserver(
+    aura::client::ActivationChangeObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+void DefaultActivationClient::ActivateWindow(aura::Window* window) {
+  aura::Window* last_active = GetActiveWindow();
+  if (last_active == window)
+    return;
+
+  last_active_ = last_active;
+  RemoveActiveWindow(window);
+  active_windows_.push_back(window);
+  window->parent()->StackChildAtTop(window);
+  window->AddObserver(this);
+
+  FOR_EACH_OBSERVER(aura::client::ActivationChangeObserver,
+                    observers_,
+                    OnWindowActivated(window, last_active));
+
+  aura::client::ActivationChangeObserver* observer =
+      aura::client::GetActivationChangeObserver(last_active);
+  if (observer)
+    observer->OnWindowActivated(window, last_active);
+  observer = aura::client::GetActivationChangeObserver(window);
+  if (observer)
+    observer->OnWindowActivated(window, last_active);
+}
+
+void DefaultActivationClient::DeactivateWindow(aura::Window* window) {
+  aura::client::ActivationChangeObserver* observer =
+      aura::client::GetActivationChangeObserver(window);
+  if (observer)
+    observer->OnWindowActivated(NULL, window);
+  if (last_active_)
+    ActivateWindow(last_active_);
+}
+
+aura::Window* DefaultActivationClient::GetActiveWindow() {
+  if (active_windows_.empty())
+    return NULL;
+  return active_windows_.back();
+}
+
+aura::Window* DefaultActivationClient::GetActivatableWindow(
+    aura::Window* window) {
+  return NULL;
+}
+
+aura::Window* DefaultActivationClient::GetToplevelWindow(aura::Window* window) {
+  return NULL;
+}
+
+bool DefaultActivationClient::OnWillFocusWindow(aura::Window* window,
+                                                const ui::Event* event) {
+  return true;
+}
+
+bool DefaultActivationClient::CanActivateWindow(aura::Window* window) const {
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DefaultActivationClient, aura::WindowObserver implementation:
+
+void DefaultActivationClient::OnWindowDestroyed(aura::Window* window) {
+  if (window == last_active_)
+    last_active_ = NULL;
+
+  if (window == GetActiveWindow()) {
+    active_windows_.pop_back();
+    aura::Window* next_active = GetActiveWindow();
+    if (next_active && aura::client::GetActivationChangeObserver(next_active)) {
+      aura::client::GetActivationChangeObserver(next_active)->OnWindowActivated(
+          next_active, NULL);
+    }
+    return;
+  }
+
+  RemoveActiveWindow(window);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// DefaultActivationClient, private:
+
+DefaultActivationClient::~DefaultActivationClient() {
+  for (unsigned int i = 0; i < active_windows_.size(); ++i) {
+    active_windows_[i]->RemoveObserver(this);
+  }
+}
+
+void DefaultActivationClient::RemoveActiveWindow(aura::Window* window) {
+  for (unsigned int i = 0; i < active_windows_.size(); ++i) {
+    if (active_windows_[i] == window) {
+      active_windows_.erase(active_windows_.begin() + i);
+      window->RemoveObserver(this);
+      return;
+    }
+  }
+}
+
+}  // namespace wm
diff --git a/ui/wm/core/default_activation_client.h b/ui/wm/core/default_activation_client.h
new file mode 100644
index 0000000..3b6bffc
--- /dev/null
+++ b/ui/wm/core/default_activation_client.h
@@ -0,0 +1,73 @@
+// Copyright 2013 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.
+
+#ifndef UI_WM_CORE_DEFAULT_ACTIVATION_CLIENT_H_
+#define UI_WM_CORE_DEFAULT_ACTIVATION_CLIENT_H_
+
+#include <vector>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/observer_list.h"
+#include "ui/aura/window_observer.h"
+#include "ui/wm/public/activation_client.h"
+#include "ui/wm/wm_export.h"
+
+namespace aura {
+namespace client {
+class ActivationChangeObserver;
+}
+}
+
+namespace wm {
+
+// Simple ActivationClient implementation for use by tests and other targets
+// that just need basic behavior (e.g. activate windows whenever requested,
+// restack windows at the top when they're activated, etc.). This object deletes
+// itself when the root window it is associated with is destroyed.
+class WM_EXPORT DefaultActivationClient : public aura::client::ActivationClient,
+                                          public aura::WindowObserver {
+ public:
+  explicit DefaultActivationClient(aura::Window* root_window);
+
+  // Overridden from aura::client::ActivationClient:
+  virtual void AddObserver(
+      aura::client::ActivationChangeObserver* observer) OVERRIDE;
+  virtual void RemoveObserver(
+      aura::client::ActivationChangeObserver* observer) OVERRIDE;
+  virtual void ActivateWindow(aura::Window* window) OVERRIDE;
+  virtual void DeactivateWindow(aura::Window* window) OVERRIDE;
+  virtual aura::Window* GetActiveWindow() OVERRIDE;
+  virtual aura::Window* GetActivatableWindow(aura::Window* window) OVERRIDE;
+  virtual aura::Window* GetToplevelWindow(aura::Window* window) OVERRIDE;
+  virtual bool OnWillFocusWindow(aura::Window* window,
+                                 const ui::Event* event) OVERRIDE;
+  virtual bool CanActivateWindow(aura::Window* window) const OVERRIDE;
+
+  // Overridden from WindowObserver:
+  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
+
+ private:
+  class Deleter;
+
+  virtual ~DefaultActivationClient();
+  void RemoveActiveWindow(aura::Window* window);
+
+  // This class explicitly does NOT store the active window in a window property
+  // to make sure that ActivationChangeObserver is not treated as part of the
+  // aura API. Assumptions to that end will cause tests that use this client to
+  // fail.
+  std::vector<aura::Window*> active_windows_;
+
+  // The window which was active before the currently active one.
+  aura::Window* last_active_;
+
+  ObserverList<aura::client::ActivationChangeObserver> observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultActivationClient);
+};
+
+}  // namespace wm
+
+#endif  // UI_WM_CORE_DEFAULT_ACTIVATION_CLIENT_H_
diff --git a/ui/wm/core/input_method_event_filter_unittest.cc b/ui/wm/core/input_method_event_filter_unittest.cc
index 6fc1b39..c5daa67 100644
--- a/ui/wm/core/input_method_event_filter_unittest.cc
+++ b/ui/wm/core/input_method_event_filter_unittest.cc
@@ -12,6 +12,7 @@
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/wm/core/compound_event_filter.h"
+#include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/public/activation_client.h"
 
 #if !defined(OS_WIN) && !defined(USE_X11)
@@ -46,6 +47,8 @@ TEST_F(InputMethodEventFilterTest, TestInputMethodProperty) {
 // Tests if InputMethodEventFilter dispatches a ui::ET_TRANSLATED_KEY_* event to
 // the root window.
 TEST_F(InputMethodEventFilterTest, TestInputMethodKeyEventPropagation) {
+  new wm::DefaultActivationClient(root_window());
+
   CompoundEventFilter root_filter;
   root_window()->AddPreTargetHandler(&root_filter);
 
diff --git a/ui/wm/core/shadow_controller_unittest.cc b/ui/wm/core/shadow_controller_unittest.cc
index 60d571e..d82d015 100644
--- a/ui/wm/core/shadow_controller_unittest.cc
+++ b/ui/wm/core/shadow_controller_unittest.cc
@@ -13,6 +13,7 @@
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
+#include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/core/shadow.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
@@ -29,6 +30,7 @@ class ShadowControllerTest : public aura::test::AuraTestBase {
   virtual void SetUp() OVERRIDE {
     wm_state_.reset(new wm::WMState);
     AuraTestBase::SetUp();
+    new wm::DefaultActivationClient(root_window());
     aura::client::ActivationClient* activation_client =
         aura::client::GetActivationClient(root_window());
     shadow_controller_.reset(new ShadowController(activation_client));
diff --git a/ui/wm/test/wm_test_helper.cc b/ui/wm/test/wm_test_helper.cc
index 1982be5..8a3eba1 100644
--- a/ui/wm/test/wm_test_helper.cc
+++ b/ui/wm/test/wm_test_helper.cc
@@ -4,12 +4,12 @@
 
 #include "ui/wm/test/wm_test_helper.h"
 
-#include "ui/aura/client/default_activation_client.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/test/test_focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/wm/core/compound_event_filter.h"
+#include "ui/wm/core/default_activation_client.h"
 #include "ui/wm/core/input_method_event_filter.h"
 
 namespace wm {
@@ -31,8 +31,7 @@ WMTestHelper::WMTestHelper(const gfx::Size& default_window_size) {
   input_method_filter_->SetInputMethodPropertyInRootWindow(host_->window());
   root_window_event_filter_->AddHandler(input_method_filter_.get());
 
-  activation_client_.reset(
-      new aura::client::DefaultActivationClient(host_->window()));
+  new wm::DefaultActivationClient(host_->window());
 
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(host_->window()));
diff --git a/ui/wm/test/wm_test_helper.h b/ui/wm/test/wm_test_helper.h
index 1a3dd09..52707a4 100644
--- a/ui/wm/test/wm_test_helper.h
+++ b/ui/wm/test/wm_test_helper.h
@@ -14,7 +14,6 @@ namespace aura {
 class Window;
 class WindowTreeHost;
 namespace client {
-class DefaultActivationClient;
 class DefaultCaptureClient;
 class FocusClient;
 }
@@ -51,7 +50,6 @@ class WMTestHelper : public aura::client::WindowTreeClient {
   scoped_ptr<wm::CompoundEventFilter> root_window_event_filter_;
   scoped_ptr<aura::client::DefaultCaptureClient> capture_client_;
   scoped_ptr<wm::InputMethodEventFilter> input_method_filter_;
-  scoped_ptr<aura::client::DefaultActivationClient> activation_client_;
   scoped_ptr<aura::client::FocusClient> focus_client_;
 
   DISALLOW_COPY_AND_ASSIGN(WMTestHelper);
diff --git a/ui/wm/wm.gyp b/ui/wm/wm.gyp
index 17ceaa36..537f67a 100644
--- a/ui/wm/wm.gyp
+++ b/ui/wm/wm.gyp
@@ -34,6 +34,8 @@
         'core/compound_event_filter.h',
         'core/cursor_manager.cc',
         'core/cursor_manager.h',
+        'core/default_activation_client.cc',
+        'core/default_activation_client.h',
         'core/easy_resize_window_targeter.cc',
         'core/easy_resize_window_targeter.h',
         'core/focus_controller.cc',