Convert Aura to use ui::Event.

ui/views/widget/native_widget_aura.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/views/widget/native_widget_aura.h"
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/drag_drop_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/window_move_client.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
+#include "ui/base/event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/ime/input_method_bridge.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/drop_helper.h"
@@ skipping 346 matching lines @@
       parent_bounds.x() + (parent_bounds.width() - size.width()) / 2,
       parent_bounds.y() + (parent_bounds.height() - size.height()) / 2,
       size.width(),
       size.height());
   // Don't size the window bigger than the parent, otherwise the user may not be
   // able to close or move it.
   window_bounds = window_bounds.AdjustToFit(parent_bounds);
 
   // Convert the bounds back relative to the parent.
   gfx::Point origin = window_bounds.origin();
-  aura::Window::ConvertPointToWindow(window_->GetRootWindow(),
+  aura::Window::ConvertPointToTarget(window_->GetRootWindow(),
       window_->parent(), &origin);
   window_bounds.set_origin(origin);
   window_->SetBounds(window_bounds);
 }
 
 void NativeWidgetAura::GetWindowPlacement(
     gfx::Rect* bounds,
     ui::WindowShowState* show_state) const {
   // The interface specifies returning restored bounds, not current bounds.
   *bounds = GetRestoredBounds();
@@ skipping 326 matching lines @@
   // destruction unless WIDGET_OWNS_NATIVE_WIDGET is set (which is just the case
   // in tests).
   if (!destroying_)
     GetWidget()->GetInputMethod()->OnBlur();
   else
     DCHECK_EQ(ownership_, Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
 
   delegate_->OnNativeBlur(window_->GetFocusManager()->GetFocusedWindow());
 }
 
-bool NativeWidgetAura::OnKeyEvent(aura::KeyEvent* event) {
+bool NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   if (event->is_char()) {
     // If a ui::InputMethod object is attached to the root window, character
     // events are handled inside the object and are not passed to this function.
     // If such object is not attached, character events might be sent (e.g. on
     // Windows). In this case, we just skip these.
     return false;
   }
   // Renderer may send a key event back to us if the key event wasn't handled,
   // and the window may be invisible by that time.
   if (!window_->IsVisible())
@@ skipping 36 matching lines @@
       Layers::const_iterator root_layer_iter(
           std::find(window_->layer()->children().begin(),
                     window_->layer()->children().end(), layer));
       if (root_layer_iter > child_layer_iter)
         return false;
     }
   }
   return true;
 }
 
-bool NativeWidgetAura::OnMouseEvent(aura::MouseEvent* event) {
+bool NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(window_->IsVisible());
   if (event->type() == ui::ET_MOUSEWHEEL) {
     MouseWheelEvent wheel_event(event);
     return delegate_->OnMouseEvent(wheel_event);
   }
   if (event->type() == ui::ET_SCROLL) {
-    ScrollEvent scroll_event(static_cast<aura::ScrollEvent*>(event));
+    ScrollEvent scroll_event(static_cast<ui::ScrollEvent*>(event));
     if (delegate_->OnMouseEvent(scroll_event))
       return true;
 
     // Convert unprocessed scroll events into wheel events.
     MouseWheelEvent wheel_event(scroll_event);
     return delegate_->OnMouseEvent(wheel_event);
   }
   MouseEvent mouse_event(event);
   if (tooltip_manager_.get())
     tooltip_manager_->UpdateTooltip();
   return delegate_->OnMouseEvent(mouse_event);
 }
 
-ui::TouchStatus NativeWidgetAura::OnTouchEvent(aura::TouchEvent* event) {
+ui::TouchStatus NativeWidgetAura::OnTouchEvent(ui::TouchEventImpl* event) {
   DCHECK(window_->IsVisible());
   TouchEvent touch_event(event);
   return delegate_->OnTouchEvent(touch_event);
 }
 
-ui::GestureStatus NativeWidgetAura::OnGestureEvent(aura::GestureEvent* event) {
+ui::GestureStatus NativeWidgetAura::OnGestureEvent(
+    ui::GestureEventImpl* event) {
   DCHECK(window_->IsVisible());
   GestureEvent gesture_event(event);
   return delegate_->OnGestureEvent(gesture_event);
 }
 
 bool NativeWidgetAura::CanFocus() {
   return can_activate_;
 }
 
 void NativeWidgetAura::OnCaptureLost() {
@@ skipping 32 matching lines @@
 }
 
 void NativeWidgetAura::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
   delegate_->GetHitTestMask(mask);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, aura::ActivationDelegate implementation:
 
-bool NativeWidgetAura::ShouldActivate(const aura::Event* event) {
+bool NativeWidgetAura::ShouldActivate(const ui::Event* event) {
   return can_activate_ && delegate_->CanActivate();
 }
 
 void NativeWidgetAura::OnActivated() {
   if (GetWidget()->HasFocusManager())
     GetWidget()->GetFocusManager()->RestoreFocusedView();
   delegate_->OnNativeWidgetActivationChanged(true);
   if (IsVisible() && GetWidget()->non_client_view())
     GetWidget()->non_client_view()->SchedulePaint();
 }
 
 void NativeWidgetAura::OnLostActive() {
   if (GetWidget()->HasFocusManager())
     GetWidget()->GetFocusManager()->StoreFocusedView();
   delegate_->OnNativeWidgetActivationChanged(false);
   if (IsVisible() && GetWidget()->non_client_view())
     GetWidget()->non_client_view()->SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, aura::WindowDragDropDelegate implementation:
 
-void NativeWidgetAura::OnDragEntered(const aura::DropTargetEvent& event) {
+void NativeWidgetAura::OnDragEntered(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
       event.location(), event.source_operations());
 }
 
-int NativeWidgetAura::OnDragUpdated(const aura::DropTargetEvent& event) {
+int NativeWidgetAura::OnDragUpdated(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   last_drop_operation_ = drop_helper_->OnDragOver(event.data(),
       event.location(), event.source_operations());
   return last_drop_operation_;
 }
 
 void NativeWidgetAura::OnDragExited() {
   DCHECK(drop_helper_.get() != NULL);
   drop_helper_->OnDragExit();
 }
 
-int NativeWidgetAura::OnPerformDrop(const aura::DropTargetEvent& event) {
+int NativeWidgetAura::OnPerformDrop(const ui::DropTargetEvent& event) {
   DCHECK(drop_helper_.get() != NULL);
   return drop_helper_->OnDrop(event.data(), event.location(),
       last_drop_operation_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, protected:
 
 NativeWidgetAura::~NativeWidgetAura() {
   destroying_ = true;
@@ skipping 122 matching lines @@
   return aura::Env::GetInstance()->is_mouse_button_down();
 }
 
 // static
 bool NativeWidgetPrivate::IsTouchDown() {
   return aura::Env::GetInstance()->is_touch_down();
 }
 
 }  // namespace internal
 }  // namespace views