Convert Aura to use ui::Event.

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/aura/aura_switches.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event.h"
 #include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/display_manager.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
+#include "ui/base/event.h"
 #include "ui/base/gestures/gesture_recognizer.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/point3.h"
 #include "ui/gfx/screen.h"
@@ skipping 226 matching lines @@
   TRACE_EVENT_ASYNC_BEGIN0("ui", "RootWindow::Draw",
                            compositor_->last_started_frame() + 1);
 
   compositor_->Draw(false);
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
 }
 
-bool RootWindow::DispatchGestureEvent(GestureEvent* event) {
+bool RootWindow::DispatchGestureEvent(ui::GestureEventImpl* event) {
   DispatchHeldMouseMove();
 
   Window* target = client::GetCaptureWindow(this);
   if (!target) {
     target = ConsumerToWindow(
         gesture_recognizer_->GetTargetForGestureEvent(event));
     if (!target)
       return false;
   }
 
   if (target) {
-    GestureEvent translated_event(*event, this, target);
+    ui::GestureEventImpl translated_event(
+        *event, static_cast<Window*>(this), target);
     ui::GestureStatus status = ProcessGestureEvent(target, &translated_event);
     return status != ui::GESTURE_STATUS_UNKNOWN;
   }
 
   return false;
 }
 
 void RootWindow::OnWindowDestroying(Window* window) {
   OnWindowHidden(window, true);
 
@@ skipping 214 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, overridden from aura::client::CaptureDelegate:
 
 void RootWindow::UpdateCapture(Window* old_capture,
                                Window* new_capture) {
   if (old_capture && old_capture->GetRootWindow() == this &&
       old_capture->delegate()) {
     // Send a capture changed event with bogus location data.
-    MouseEvent event(
-        ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(), gfx::Point(), 0);
+    ui::MouseEvent event(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(),
+                         gfx::Point(), 0);
     ProcessMouseEvent(old_capture, &event);
 
     old_capture->delegate()->OnCaptureLost();
   }
 
   // Reset the mouse_moved_handler_ if the mouse_moved_handler_ belongs
   // to another root window when losing the capture.
   if (mouse_moved_handler_ && old_capture &&
       old_capture->Contains(mouse_moved_handler_) &&
       old_capture->GetRootWindow() != this) {
@@ skipping 23 matching lines @@
 
 gfx::Point RootWindow::QueryMouseLocationForTest() const {
   gfx::Point point;
   host_->QueryMouseLocation(&point);
   return point;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
-void RootWindow::HandleMouseMoved(const MouseEvent& event, Window* target) {
+void RootWindow::HandleMouseMoved(const ui::MouseEvent& event, Window* target) {
   if (target == mouse_moved_handler_)
     return;
 
   // Send an exited event.
   if (mouse_moved_handler_ && mouse_moved_handler_->delegate()) {
-    MouseEvent translated_event(event, this, mouse_moved_handler_,
-                                ui::ET_MOUSE_EXITED, event.flags());
+    ui::MouseEvent translated_event(event,
+                                    static_cast<Window*>(this),
+                                    mouse_moved_handler_,
+                                    ui::ET_MOUSE_EXITED,
+                                    event.flags());
     ProcessMouseEvent(mouse_moved_handler_, &translated_event);
   }
   mouse_moved_handler_ = target;
   // Send an entered event.
   if (mouse_moved_handler_ && mouse_moved_handler_->delegate()) {
-    MouseEvent translated_event(event, this, mouse_moved_handler_,
-                                ui::ET_MOUSE_ENTERED, event.flags());
+    ui::MouseEvent translated_event(event,
+                                    static_cast<Window*>(this),
+                                    mouse_moved_handler_,
+                                    ui::ET_MOUSE_ENTERED,
+                                    event.flags());
     ProcessMouseEvent(mouse_moved_handler_, &translated_event);
   }
 }
 
-bool RootWindow::ProcessMouseEvent(Window* target, MouseEvent* event) {
+bool RootWindow::ProcessMouseEvent(Window* target, ui::MouseEvent* event) {
   if (!target->IsVisible())
     return false;
 
   EventFilters filters;
   GetEventFiltersToNotify(target->parent(), &filters);
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     if ((*it)->PreHandleMouseEvent(target, event))
       return true;
   }
 
   if (!target->delegate())
     return false;
   return target->delegate()->OnMouseEvent(event);
 }
 
-bool RootWindow::ProcessKeyEvent(Window* target, KeyEvent* event) {
+bool RootWindow::ProcessKeyEvent(Window* target, ui::KeyEvent* event) {
   EventFilters filters;
 
   if (!target) {
     // When no window is focused, send the key event to |this| so event filters
     // for the window could check if the key is a global shortcut like Alt+Tab.
     target = this;
     GetEventFiltersToNotify(this, &filters);
   } else {
     if (!target->IsVisible())
       return false;
     GetEventFiltersToNotify(target->parent(), &filters);
   }
 
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     if ((*it)->PreHandleKeyEvent(target, event))
       return true;
   }
 
   if (!target->delegate())
     return false;
   return target->delegate()->OnKeyEvent(event);
 }
 
 ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
-                                              TouchEvent* event) {
+                                              ui::TouchEventImpl* event) {
   if (!target->IsVisible())
     return ui::TOUCH_STATUS_UNKNOWN;
 
   EventFilters filters;
   if (target == this)
     GetEventFiltersToNotify(target, &filters);
   else
     GetEventFiltersToNotify(target->parent(), &filters);
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     ui::TouchStatus status = (*it)->PreHandleTouchEvent(target, event);
     if (status != ui::TOUCH_STATUS_UNKNOWN)
       return status;
   }
 
   if (target->delegate())
     return target->delegate()->OnTouchEvent(event);
 
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
 ui::GestureStatus RootWindow::ProcessGestureEvent(Window* target,
-                                                  GestureEvent* event) {
+                                                  ui::GestureEventImpl* event) {
   if (!target->IsVisible())
     return ui::GESTURE_STATUS_UNKNOWN;
 
   EventFilters filters;
   if (target == this)
     GetEventFiltersToNotify(target, &filters);
   else
     GetEventFiltersToNotify(target->parent(), &filters);
   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
   for (EventFilters::const_reverse_iterator it = filters.rbegin(),
            rend = filters.rend();
        it != rend; ++it) {
     status = (*it)->PreHandleGestureEvent(target, event);
     if (status != ui::GESTURE_STATUS_UNKNOWN)
       return status;
   }
 
   if (target->delegate())
     status = target->delegate()->OnGestureEvent(event);
 
   return status;
 }
 
 bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
   if (!gestures)
     return false;
   bool handled = false;
   for (unsigned int i = 0; i < gestures->size(); i++) {
-    GestureEvent* gesture =
-        static_cast<GestureEvent*>(gestures->get().at(i));
+    ui::GestureEventImpl* gesture =
+        static_cast<ui::GestureEventImpl*>(gestures->get().at(i));
     if (DispatchGestureEvent(gesture) != ui::GESTURE_STATUS_UNKNOWN)
       handled = true;
   }
   return handled;
 }
 
 void RootWindow::OnWindowRemovedFromRootWindow(Window* detached) {
   DCHECK(aura::client::GetCaptureWindow(this) != this);
 
   OnWindowHidden(detached, false);
@@ skipping 45 matching lines @@
   gesture_recognizer_->FlushTouchQueue(invisible);
 }
 
 void RootWindow::OnWindowAddedToRootWindow(Window* attached) {
   if (attached->IsVisible() &&
       attached->ContainsPointInRoot(GetLastMouseLocationInRoot()))
     PostMouseMoveEventAfterWindowChange();
 }
 
 bool RootWindow::DispatchLongPressGestureEvent(ui::GestureEvent* event) {
-  return DispatchGestureEvent(static_cast<GestureEvent*>(event));
+  return DispatchGestureEvent(static_cast<ui::GestureEventImpl*>(event));
 }
 
 bool RootWindow::DispatchCancelTouchEvent(ui::TouchEvent* event) {
-  return OnHostTouchEvent(static_cast<TouchEvent*>(event));
+  return OnHostTouchEvent(static_cast<ui::TouchEventImpl*>(event));
 }
 
 ui::GestureEvent* RootWindow::CreateGestureEvent(
     const ui::GestureEventDetails& details,
     const gfx::Point& location,
     int flags,
     base::Time time,
     unsigned int touch_id_bitfield) {
-  return new GestureEvent(details.type(), location.x(), location.y(),
-                          flags, time, details,
-                          touch_id_bitfield);
+  return new ui::GestureEventImpl(details.type(), location.x(), location.y(),
+                                  flags, time, details, touch_id_bitfield);
 }
 
 ui::TouchEvent* RootWindow::CreateTouchEvent(ui::EventType type,
                                              const gfx::Point& location,
                                              int touch_id,
                                              base::TimeDelta time_stamp) {
-  return new TouchEvent(type, location, touch_id, time_stamp);
+  return new ui::TouchEventImpl(type, location, touch_id, time_stamp);
 }
 
 void RootWindow::OnLayerAnimationEnded(
     ui::LayerAnimationSequence* animation) {
   OnHostResized(host_->GetBounds().size());
 }
 
 void RootWindow::OnLayerAnimationScheduled(
     ui::LayerAnimationSequence* animation) {
 }
 
 void RootWindow::OnLayerAnimationAborted(
     ui::LayerAnimationSequence* animation) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, RootWindowHostDelegate implementation:
 
-bool RootWindow::OnHostKeyEvent(KeyEvent* event) {
+bool RootWindow::OnHostKeyEvent(ui::KeyEvent* event) {
   DispatchHeldMouseMove();
   if (event->key_code() == ui::VKEY_UNKNOWN)
     return false;
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   Window* focused_window = focus_manager_->GetFocusedWindow();
   if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
     GetFocusManager()->SetFocusedWindow(NULL, NULL);
     return false;
   }
   return ProcessKeyEvent(focused_window, event);
 }
 
-bool RootWindow::OnHostMouseEvent(MouseEvent* event) {
+bool RootWindow::OnHostMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_DRAGGED ||
       (event->flags() & ui::EF_IS_SYNTHESIZED)) {
     if (mouse_move_hold_count_) {
-      held_mouse_move_.reset(new MouseEvent(*event, NULL, NULL));
+      Window* null_window = static_cast<Window*>(NULL);
+      held_mouse_move_.reset(
+          new ui::MouseEvent(*event, null_window, null_window));
       return true;
     } else {
       // We may have a held event for a period between the time
       // mouse_move_hold_count_ fell to 0 and the DispatchHeldMouseMove
       // executes. Since we're going to dispatch the new event directly below,
       // we can reset the old one.
       held_mouse_move_.reset();
     }
   }
   DispatchHeldMouseMove();
   return DispatchMouseEventImpl(event);
 }
 
-bool RootWindow::OnHostScrollEvent(ScrollEvent* event) {
+bool RootWindow::OnHostScrollEvent(ui::ScrollEvent* event) {
   DispatchHeldMouseMove();
   float scale = ui::GetDeviceScaleFactor(layer());
   ui::Transform transform = layer()->transform();
   transform.ConcatScale(scale, scale);
   event->UpdateForRootTransform(transform);
 
   SetLastMouseLocation(this, event->location());
   synthesize_mouse_move_ = false;
 
   Window* target = mouse_pressed_handler_ ?
       mouse_pressed_handler_ : client::GetCaptureWindow(this);
   if (!target)
     target = GetEventHandlerForPoint(event->location());
 
   if (target && target->delegate()) {
     int flags = event->flags();
     gfx::Point location_in_window = event->location();
-    Window::ConvertPointToWindow(this, target, &location_in_window);
+    Window::ConvertPointToTarget(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
-    ScrollEvent translated_event(*event, this, target, event->type(), flags);
+    ui::ScrollEvent translated_event(
+        *event, static_cast<Window*>(this), target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
-bool RootWindow::OnHostTouchEvent(TouchEvent* event) {
+bool RootWindow::OnHostTouchEvent(ui::TouchEventImpl* event) {
   DispatchHeldMouseMove();
   switch (event->type()) {
     case ui::ET_TOUCH_PRESSED:
       touch_ids_down_ |= (1 << event->touch_id());
       Env::GetInstance()->set_touch_down(touch_ids_down_ != 0);
       break;
 
     // Don't handle ET_TOUCH_CANCELLED since we always get a ET_TOUCH_RELEASED.
     case ui::ET_TOUCH_RELEASED:
       touch_ids_down_ = (touch_ids_down_ | (1 << event->touch_id())) ^
@@ skipping 24 matching lines @@
     // If the initial touch is outside the root window, target the root.
     target = this;
   } else {
     // We only come here when the first contact was within the root window.
     if (!target) {
       target = GetEventHandlerForPoint(event->location());
       if (!target)
         return false;
     }
 
-    TouchEvent translated_event(*event, this, target);
+    ui::TouchEventImpl translated_event(
+        *event, static_cast<Window*>(this), target);
     status = ProcessTouchEvent(target, &translated_event);
     handled = status != ui::TOUCH_STATUS_UNKNOWN;
 
     if (status == ui::TOUCH_STATUS_QUEUED ||
         status == ui::TOUCH_STATUS_QUEUED_END)
       gesture_recognizer_->QueueTouchEventForGesture(target, *event);
   }
 
   // Get the list of GestureEvents from GestureRecognizer.
   scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
@@ skipping 33 matching lines @@
   return compositor()->device_scale_factor();
 }
 
 RootWindow* RootWindow::AsRootWindow() {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindow, private:
 
-bool RootWindow::DispatchMouseEventImpl(MouseEvent* event) {
+bool RootWindow::DispatchMouseEventImpl(ui::MouseEvent* event) {
   float scale = ui::GetDeviceScaleFactor(layer());
   ui::Transform transform = layer()->transform();
   transform.ConcatScale(scale, scale);
   event->UpdateForRootTransform(transform);
   Window* target = mouse_pressed_handler_ ?
       mouse_pressed_handler_ : client::GetCaptureWindow(this);
   if (!target)
     target = GetEventHandlerForPoint(event->location());
   return DispatchMouseEventToTarget(event, target);
 }
 
-bool RootWindow::DispatchMouseEventToTarget(MouseEvent* event,
+bool RootWindow::DispatchMouseEventToTarget(ui::MouseEvent* event,
                                             Window* target) {
   static const int kMouseButtonFlagMask =
       ui::EF_LEFT_MOUSE_BUTTON |
       ui::EF_MIDDLE_MOUSE_BUTTON |
       ui::EF_RIGHT_MOUSE_BUTTON;
   SetLastMouseLocation(this, event->location());
   synthesize_mouse_move_ = false;
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
       HandleMouseMoved(*event, target);
       break;
     case ui::ET_MOUSE_PRESSED:
       if (!mouse_pressed_handler_)
         mouse_pressed_handler_ = target;
       mouse_button_flags_ = event->flags() & kMouseButtonFlagMask;
       Env::GetInstance()->set_mouse_button_flags(mouse_button_flags_);
       break;
     case ui::ET_MOUSE_RELEASED:
       mouse_pressed_handler_ = NULL;
       mouse_button_flags_ = event->flags() & kMouseButtonFlagMask;
       Env::GetInstance()->set_mouse_button_flags(mouse_button_flags_);
       break;
     default:
       break;
   }
   if (target && target->delegate()) {
     int flags = event->flags();
     gfx::Point location_in_window = event->location();
-    Window::ConvertPointToWindow(this, target, &location_in_window);
+    Window::ConvertPointToTarget(this, target, &location_in_window);
     if (IsNonClientLocation(target, location_in_window))
       flags |= ui::EF_IS_NON_CLIENT;
-    MouseEvent translated_event(*event, this, target, event->type(), flags);
+    ui::MouseEvent translated_event(
+        *event, static_cast<Window*>(this), target, event->type(), flags);
     return ProcessMouseEvent(target, &translated_event);
   }
   return false;
 }
 
 void RootWindow::DispatchHeldMouseMove() {
   if (held_mouse_move_.get()) {
     // If a mouse move has been synthesized, the target location is suspect,
     // so drop the held event.
     if (!synthesize_mouse_move_)
@@ skipping 20 matching lines @@
   // Temporarily disabled for windows. See crbug.com/112222.
   gfx::Point3f point(GetLastMouseLocationInRoot());
   ui::Transform transform = layer()->transform();
   float scale = ui::GetDeviceScaleFactor(layer());
   transform.ConcatScale(scale, scale);
   transform.TransformPoint(point);
   gfx::Point orig_mouse_location = point.AsPoint();
 
   // TODO(derat|oshima): Don't use mouse_button_flags_ as it's
   // currently broken. See/ crbug.com/107931.
-  MouseEvent event(ui::ET_MOUSE_MOVED,
-                   orig_mouse_location,
-                   orig_mouse_location,
-                   ui::EF_IS_SYNTHESIZED);
+  ui::MouseEvent event(ui::ET_MOUSE_MOVED,
+                       orig_mouse_location,
+                       orig_mouse_location,
+                       ui::EF_IS_SYNTHESIZED);
   OnHostMouseEvent(&event);
 #endif
 }
 
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura