More ash_unittests run without crashing/pass with new focus controller.

. Listen for ActivationChanged events to minimized windows on BaseLayoutManager and show the activated window (BLM is also responsible for hiding minimized windows)
. Stop the annoying cursor movement for RWHWin while the tests are running. There's never a reason for us to do this on win32.
. Listen for FocusChanging events in the DeleteOnBlur delegate in RootWindowControllerTest. Currently calls StopPropagation since the handler is deleted. Will not be necessary after sadrul's latest.
. Shell keeps track of active root window now as an activation event handler (in the old world, the ActivationController manually updated this).
. TestActivationDelegate is also an activation event handler.
. FocusController responds to hides on visibility changED vs changING since that's necessary to restore activation properly after hiding a system modal window.

http://crbug.com/162100
R=sadrul@chromium.org
Review URL: https://codereview.chromium.org/11446050

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

8 files changed, 70 insertions, 3 deletions

diff --git a/ash/root_window_controller_unittest.cc b/ash/root_window_controller_unittest.cc
index 2635d12..ca9d340 100644
--- a/ash/root_window_controller_unittest.cc
+++ b/ash/root_window_controller_unittest.cc
@@ -67,8 +67,11 @@ class DeleteOnBlurDelegate : public aura::test::TestWindowDelegate {
   virtual void OnEvent(ui::Event* event) OVERRIDE {
     if (event->type() ==
         views::corewm::FocusChangeEvent::focus_changing_event_type()) {
-      if (event->target() == window_)
+      if (event->target() == window_) {
         OnBlur();
+        // TODO(sadrul): should not be necessary.
+        event->StopPropagation();
+      }
     }
   }
 
diff --git a/ash/shell.cc b/ash/shell.cc
index 5d8b830..4e6580a 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -85,6 +85,7 @@
 #include "ui/ui_controls/ui_controls.h"
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/views/corewm/corewm_switches.h"
+#include "ui/views/corewm/focus_change_event.h"
 #include "ui/views/corewm/focus_controller.h"
 #include "ui/views/corewm/input_method_event_filter.h"
 #include "ui/views/corewm/shadow_controller.h"
@@ -246,6 +247,7 @@ Shell::Shell(ShellDelegate* delegate)
   base::MessagePumpAuraX11::Current()->AddDispatcherForRootWindow(
       output_configurator());
 #endif  // defined(OS_CHROMEOS)
+  AddPreTargetHandler(this);
 }
 
 Shell::~Shell() {
@@ -887,6 +889,9 @@ bool Shell::CanWindowReceiveEvents(aura::Window* window) {
   return false;
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Shell, ui::EventTarget overrides:
+
 bool Shell::CanAcceptEvent(const ui::Event& event) {
   return true;
 }
@@ -895,4 +900,12 @@ ui::EventTarget* Shell::GetParentTarget() {
   return NULL;
 }
 
+void Shell::OnEvent(ui::Event* event) {
+  if (event->type() ==
+      views::corewm::FocusChangeEvent::activation_changed_event_type()) {
+    active_root_window_ =
+        static_cast<aura::Window*>(event->target())->GetRootWindow();
+  }
+}
+
 }  // namespace ash
diff --git a/ash/shell.h b/ash/shell.h
index ec50145..5ba1df6 100644
--- a/ash/shell.h
+++ b/ash/shell.h
@@ -451,6 +451,7 @@ class ASH_EXPORT Shell : internal::SystemModalContainerEventFilterDelegate,
   // Overridden from ui::EventTarget:
   virtual bool CanAcceptEvent(const ui::Event& event) OVERRIDE;
   virtual EventTarget* GetParentTarget() OVERRIDE;
+  virtual void OnEvent(ui::Event* event) OVERRIDE;
 
   static Shell* instance_;
 
diff --git a/ash/test/test_activation_delegate.cc b/ash/test/test_activation_delegate.cc
index 88b5f13..a85a982 100644
--- a/ash/test/test_activation_delegate.cc
+++ b/ash/test/test_activation_delegate.cc
@@ -8,6 +8,7 @@
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event.h"
+#include "ui/views/corewm/focus_change_event.h"
 
 namespace ash {
 namespace test {
@@ -36,6 +37,7 @@ TestActivationDelegate::TestActivationDelegate(bool activate)
 void TestActivationDelegate::SetWindow(aura::Window* window) {
   window_ = window;
   aura::client::SetActivationDelegate(window, this);
+  window_->AddPreTargetHandler(this);
 }
 
 bool TestActivationDelegate::ShouldActivate() const {
@@ -52,5 +54,18 @@ void TestActivationDelegate::OnLostActive() {
     window_was_active_ = wm::IsActiveWindow(window_);
 }
 
+void TestActivationDelegate::OnEvent(ui::Event* event) {
+  if (event->target() == window_) {
+    if (event->type() ==
+        views::corewm::FocusChangeEvent::activation_changed_event_type()) {
+      OnActivated();
+    } else if (event->type() ==
+        views::corewm::FocusChangeEvent::activation_changing_event_type()) {
+      OnLostActive();
+    }
+  }
+  EventHandler::OnEvent(event);
+}
+
 }  // namespace test
 }  // namespace ash
diff --git a/ash/test/test_activation_delegate.h b/ash/test/test_activation_delegate.h
index 185e65d..1e3bec6 100644
--- a/ash/test/test_activation_delegate.h
+++ b/ash/test/test_activation_delegate.h
@@ -8,6 +8,7 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "ui/aura/client/activation_delegate.h"
+#include "ui/base/events/event_handler.h"
 
 namespace aura {
 class Window;
@@ -18,7 +19,8 @@ namespace test {
 
 // A test ActivationDelegate that can be used to track activation changes for
 // an aura::Window.
-class TestActivationDelegate : public aura::client::ActivationDelegate {
+class TestActivationDelegate : public aura::client::ActivationDelegate,
+                               public ui::EventHandler {
  public:
   TestActivationDelegate();
   explicit TestActivationDelegate(bool activate);
@@ -42,6 +44,9 @@ class TestActivationDelegate : public aura::client::ActivationDelegate {
   virtual void OnLostActive() OVERRIDE;
 
  private:
+  // Overridden from ui::EventHandler:
+  virtual void OnEvent(ui::Event* event) OVERRIDE;
+
   aura::Window* window_;
   bool window_was_active_;
   bool activate_;
diff --git a/ash/wm/activation_controller_unittest.cc b/ash/wm/activation_controller_unittest.cc
index 30224f2..21c9231 100644
--- a/ash/wm/activation_controller_unittest.cc
+++ b/ash/wm/activation_controller_unittest.cc
@@ -15,6 +15,7 @@
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/compositor/layer.h"
+#include "ui/views/corewm/corewm_switches.h"
 
 #if defined(OS_WIN)
 // Windows headers define macros for these function names which screw with us.
@@ -257,6 +258,10 @@ TEST_F(ActivationControllerTest, Deactivate) {
 // Verifies that when WindowDelegate::OnLostActive is invoked the window is not
 // active.
 TEST_F(ActivationControllerTest, NotActiveInLostActive) {
+  // TODO(beng): remove this test once the new focus controller is on.
+  if (views::corewm::UseFocusController())
+    return;
+
   TestActivationDelegate ad1;
   aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
@@ -412,6 +417,9 @@ TEST_F(ActivationControllerTest, CanActivateWindowIteselfTest)
 // Verifies code in ActivationController::OnWindowVisibilityChanged() that keeps
 // hiding windows layers stacked above the newly active window while they
 // animate away.
+// TODO(beng): This test now duplicates a test in:
+//                ui/views/corewm/focus_controller_unittest.cc
+//             ...and can be removed once the new focus controller is enabled.
 TEST_F(ActivationControllerTest, AnimateHideMaintainsStacking) {
   aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate(
diff --git a/ash/wm/base_layout_manager.cc b/ash/wm/base_layout_manager.cc
index 770a609..87c2567 100644
--- a/ash/wm/base_layout_manager.cc
+++ b/ash/wm/base_layout_manager.cc
@@ -17,6 +17,7 @@
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
+#include "ui/views/corewm/focus_change_event.h"
 #include "ui/views/corewm/window_util.h"
 
 namespace ash {
@@ -30,10 +31,12 @@ BaseLayoutManager::BaseLayoutManager(aura::RootWindow* root_window)
   Shell::GetInstance()->AddShellObserver(this);
   root_window_->AddRootWindowObserver(this);
   root_window_->AddObserver(this);
+  root_window_->AddPreTargetHandler(this);
 }
 
 BaseLayoutManager::~BaseLayoutManager() {
   if (root_window_) {
+    root_window_->RemovePreTargetHandler(this);
     root_window_->RemoveObserver(this);
     root_window_->RemoveRootWindowObserver(this);
   }
@@ -147,6 +150,20 @@ void BaseLayoutManager::OnWindowDestroying(aura::Window* window) {
 }
 
 //////////////////////////////////////////////////////////////////////////////
+// BaseLayoutManager, ui::EventHandler implementation:
+
+void BaseLayoutManager::OnEvent(ui::Event* event) {
+  if (event->type() ==
+      views::corewm::FocusChangeEvent::activation_changed_event_type()) {
+    aura::Window* activated = static_cast<aura::Window*>(event->target());
+    if (wm::IsWindowMinimized(activated)) {
+      activated->Show();
+      DCHECK(!wm::IsWindowMinimized(activated));
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, private:
 
 void BaseLayoutManager::ShowStateChanged(aura::Window* window,
diff --git a/ash/wm/base_layout_manager.h b/ash/wm/base_layout_manager.h
index 466349c..312e8ae 100644
--- a/ash/wm/base_layout_manager.h
+++ b/ash/wm/base_layout_manager.h
@@ -13,6 +13,7 @@
 #include "base/compiler_specific.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window_observer.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/aura/window_observer.h"
 
@@ -32,7 +33,8 @@ namespace internal {
 class ASH_EXPORT BaseLayoutManager : public aura::LayoutManager,
                                      public aura::RootWindowObserver,
                                      public ash::ShellObserver,
-                                     public aura::WindowObserver {
+                                     public aura::WindowObserver,
+                                     public ui::EventHandler {
  public:
   typedef std::set<aura::Window*> WindowSet;
 
@@ -70,6 +72,9 @@ class ASH_EXPORT BaseLayoutManager : public aura::LayoutManager,
                                        intptr_t old) OVERRIDE;
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 
+  // ui::EventHandler overrides:
+  virtual void OnEvent(ui::Event* event) OVERRIDE;
+
  protected:
   // Invoked from OnWindowPropertyChanged() if |kShowStateKey| changes.
   virtual void ShowStateChanged(aura::Window* window,