Convert Aura to use ui::Event.

ash/wm/activation_controller.cc

 // Copyright (c) 2012 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 "ash/wm/activation_controller.h"
 
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/window_modality_controller.h"
 #include "ash/wm/window_util.h"
@@ skipping 67 matching lines @@
 bool VisibilityMatches(aura::Window* window, ActivateVisibilityType type) {
   bool visible = (type == CURRENT_VISIBILITY) ? window->IsVisible() :
       window->TargetVisibility();
   return visible || wm::IsWindowMinimized(window);
 }
 
 // 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 CanActivateWindowWithEvent(aura::Window* window,
-                                const aura::Event* event,
+                                const ui::Event* event,
                                 ActivateVisibilityType visibility_type) {
   return window &&
       VisibilityMatches(window, visibility_type) &&
       (!aura::client::GetActivationDelegate(window) ||
         aura::client::GetActivationDelegate(window)->ShouldActivate(event)) &&
       SupportsChildActivation(window->parent());
 }
 
 // When a modal window is activated, we bring its entire transient parent chain
 // to the front. This function must be called before the modal transient is
@@ skipping 24 matching lines @@
 }
 
 ActivationController::~ActivationController() {
   aura::Env::GetInstance()->RemoveObserver(this);
   focus_manager_->RemoveObserver(this);
 }
 
 // static
 aura::Window* ActivationController::GetActivatableWindow(
     aura::Window* window,
-    const aura::Event* event) {
+    const ui::Event* event) {
   aura::Window* parent = window->parent();
   aura::Window* child = window;
   while (parent) {
     if (CanActivateWindowWithEvent(child, event, CURRENT_VISIBILITY))
       return child;
     // If |child| isn't activatable, but has transient parent, trace
     // that path instead.
     if (child->transient_parent())
       return GetActivatableWindow(child->transient_parent(), event);
     parent = parent->parent();
@@ skipping 27 matching lines @@
 void ActivationController::DeactivateWindow(aura::Window* window) {
   if (window)
     ActivateNextWindow(window);
 }
 
 aura::Window* ActivationController::GetActiveWindow() {
   return active_window_;
 }
 
 bool ActivationController::OnWillFocusWindow(aura::Window* window,
-                                             const aura::Event* event) {
+                                             const ui::Event* event) {
   return CanActivateWindowWithEvent(
       GetActivatableWindow(window, event), event, CURRENT_VISIBILITY);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, aura::WindowObserver implementation:
 
 void ActivationController::OnWindowVisibilityChanged(aura::Window* window,
                                                      bool visible) {
   if (!visible) {
@@ skipping 31 matching lines @@
 // ActivationController, aura::RootWindowObserver implementation:
 
 void ActivationController::OnWindowFocused(aura::Window* window) {
   ActivateWindow(GetActivatableWindow(window, NULL));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ActivationController, private:
 
 void ActivationController::ActivateWindowWithEvent(aura::Window* window,
-                                                   const aura::Event* event) {
+                                                   const ui::Event* event) {
   aura::Window* window_modal_transient = wm::GetWindowModalTransient(window);
   if (window_modal_transient) {
     ActivateWindow(window_modal_transient);
     return;
   }
 
   // Prevent recursion when called from focus.
   if (updating_activation_)
     return;
 
@@ skipping 99 matching lines @@
     if (*i != ignore &&
         CanActivateWindowWithEvent(*i, NULL, CURRENT_VISIBILITY) &&
         !wm::IsWindowMinimized(*i))
       return *i;
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace ash