Replace views::LocatedEvent with ui::LocatedEvent

ui/views/widget/root_view.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/root_view.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 180 matching lines @@
     layer()->SchedulePaint(rect);
   } else {
     gfx::Rect xrect = ConvertRectToParent(rect);
     gfx::Rect invalid_rect = GetLocalBounds().Intersect(xrect);
     if (!invalid_rect.IsEmpty())
       widget_->SchedulePaintInRect(invalid_rect);
   }
 }
 
 bool RootView::OnMousePressed(const MouseEvent& event) {
-  MouseEvent e(event, this);
-  UpdateCursor(e);
-  SetMouseLocationAndFlags(e);
+  UpdateCursor(event);
+  SetMouseLocationAndFlags(event);
 
   // If mouse_pressed_handler_ is non null, we are currently processing
   // a pressed -> drag -> released session. In that case we send the
   // event to mouse_pressed_handler_
   if (mouse_pressed_handler_) {
-    MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
+    MouseEvent mouse_pressed_event(event, this, mouse_pressed_handler_);
     drag_info_.Reset();
     mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
                                                 &drag_info_);
     return true;
   }
   DCHECK(!explicit_mouse_handler_);
 
   bool hit_disabled_view = false;
   // Walk up the tree until we find a view that wants the mouse event.
-  for (mouse_pressed_handler_ = GetEventHandlerForPoint(e.location());
+  for (mouse_pressed_handler_ = GetEventHandlerForPoint(event.location());
        mouse_pressed_handler_ && (mouse_pressed_handler_ != this);
        mouse_pressed_handler_ = mouse_pressed_handler_->parent()) {
     DVLOG(1) << "OnMousePressed testing "
         << mouse_pressed_handler_->GetClassName();
     if (!mouse_pressed_handler_->enabled()) {
       // Disabled views should eat events instead of propagating them upwards.
       hit_disabled_view = true;
       break;
     }
 
     // See if this view wants to handle the mouse press.
-    MouseEvent mouse_pressed_event(e, this, mouse_pressed_handler_);
+    MouseEvent mouse_pressed_event(event, this, mouse_pressed_handler_);
 
     // Remove the double-click flag if the handler is different than the
     // one which got the first click part of the double-click.
     if (mouse_pressed_handler_ != last_click_handler_)
-      mouse_pressed_event.set_flags(e.flags() & ~ui::EF_IS_DOUBLE_CLICK);
+      mouse_pressed_event.set_flags(event.flags() & ~ui::EF_IS_DOUBLE_CLICK);
 
     drag_info_.Reset();
     bool handled = mouse_pressed_handler_->ProcessMousePressed(
         mouse_pressed_event, &drag_info_);
 
     // The view could have removed itself from the tree when handling
     // OnMousePressed().  In this case, the removal notification will have
     // reset mouse_pressed_handler_ to NULL out from under us.  Detect this
     // case and stop.  (See comments in view.h.)
     //
@@ skipping 13 matching lines @@
     }
   }
 
   // Reset mouse_pressed_handler_ to indicate that no processing is occurring.
   mouse_pressed_handler_ = NULL;
 
   // In the event that a double-click is not handled after traversing the
   // entire hierarchy (even as a single-click when sent to a different view),
   // it must be marked as handled to avoid anything happening from default
   // processing if it the first click-part was handled by us.
-  if (last_click_handler_ && (e.flags() & ui::EF_IS_DOUBLE_CLICK))
+  if (last_click_handler_ && (event.flags() & ui::EF_IS_DOUBLE_CLICK))
     hit_disabled_view = true;
 
   last_click_handler_ = NULL;
   return hit_disabled_view;
 }
 
 bool RootView::OnMouseDragged(const MouseEvent& event) {
   if (mouse_pressed_handler_) {
-    MouseEvent e(event, this);
-    SetMouseLocationAndFlags(e);
+    SetMouseLocationAndFlags(event);
 
-    MouseEvent mouse_event(e, this, mouse_pressed_handler_);
+    MouseEvent mouse_event(event, this, mouse_pressed_handler_);
     return mouse_pressed_handler_->ProcessMouseDragged(mouse_event,
                                                        &drag_info_);
   }
   return false;
 }
 
 void RootView::OnMouseReleased(const MouseEvent& event) {
-  MouseEvent e(event, this);
-  UpdateCursor(e);
+  UpdateCursor(event);
 
   if (mouse_pressed_handler_) {
-    MouseEvent mouse_released(e, this, mouse_pressed_handler_);
+    MouseEvent mouse_released(event, this, mouse_pressed_handler_);
     // We allow the view to delete us from ProcessMouseReleased. As such,
     // configure state such that we're done first, then call View.
     View* mouse_pressed_handler = mouse_pressed_handler_;
     SetMouseHandler(NULL);
     mouse_pressed_handler->ProcessMouseReleased(mouse_released);
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseCaptureLost() {
@@ skipping 13 matching lines @@
     SetMouseHandler(NULL);
     if (mouse_pressed_handler)
       mouse_pressed_handler->OnMouseCaptureLost();
     else
       gesture_handler->OnMouseCaptureLost();
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseMoved(const MouseEvent& event) {
-  MouseEvent e(event, this);
-  View* v = GetEventHandlerForPoint(e.location());
+  View* v = GetEventHandlerForPoint(event.location());
   // Find the first enabled view, or the existing move handler, whichever comes
   // first.  The check for the existing handler is because if a view becomes
   // disabled while handling moves, it's wrong to suddenly send ET_MOUSE_EXITED
   // and ET_MOUSE_ENTERED events, because the mouse hasn't actually exited yet.
   while (v && !v->enabled() && (v != mouse_move_handler_))
     v = v->parent();
   if (v && v != this) {
     if (v != mouse_move_handler_) {
       if (mouse_move_handler_ != NULL &&
           (!mouse_move_handler_->notify_enter_exit_on_child() ||
            !mouse_move_handler_->Contains(v))) {
-        mouse_move_handler_->OnMouseExited(e);
-        NotifyEnterExitOfDescendant(e, EVENT_EXIT, mouse_move_handler_, v);
+        mouse_move_handler_->OnMouseExited(event);
+        NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
       }
       View* old_handler = mouse_move_handler_;
       mouse_move_handler_ = v;
-      MouseEvent entered_event(e, this, mouse_move_handler_);
+      MouseEvent entered_event(event, this, mouse_move_handler_);
       if (!mouse_move_handler_->notify_enter_exit_on_child() ||
           !mouse_move_handler_->Contains(old_handler)) {
         mouse_move_handler_->OnMouseEntered(entered_event);
         NotifyEnterExitOfDescendant(entered_event, EVENT_ENTER, v,
             old_handler);
       }
     }
-    MouseEvent moved_event(e, this, mouse_move_handler_);
+    MouseEvent moved_event(event, this, mouse_move_handler_);
     mouse_move_handler_->OnMouseMoved(moved_event);
     if (!(moved_event.flags() & ui::EF_IS_NON_CLIENT))
       widget_->SetCursor(mouse_move_handler_->GetCursor(moved_event));
   } else if (mouse_move_handler_ != NULL) {
-    mouse_move_handler_->OnMouseExited(e);
-    NotifyEnterExitOfDescendant(e, EVENT_EXIT, mouse_move_handler_, v);
+    mouse_move_handler_->OnMouseExited(event);
+    NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
     // On Aura the non-client area extends slightly outside the root view for
     // some windows.  Let the non-client cursor handling code set the cursor
     // as we do above.
-    if (!(e.flags() & ui::EF_IS_NON_CLIENT))
+    if (!(event.flags() & ui::EF_IS_NON_CLIENT))
       widget_->SetCursor(gfx::kNullCursor);
   }
 }
 
 void RootView::OnMouseExited(const MouseEvent& event) {
   if (mouse_move_handler_ != NULL) {
     mouse_move_handler_->OnMouseExited(event);
     NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, NULL);
     mouse_move_handler_ = NULL;
   }
 }
 
 bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
-  MouseWheelEvent e(event, this);
   bool consumed = false;
   for (View* v = GetFocusManager()->GetFocusedView();
        v && v != this && !consumed; v = v->parent())
-    consumed = v->OnMouseWheel(e);
+    consumed = v->OnMouseWheel(event);
   return consumed;
 }
 
 bool RootView::OnScrollEvent(const ScrollEvent& event) {
-  ScrollEvent e(event, this);
   bool consumed = false;
-  for (View* v = GetEventHandlerForPoint(e.location());
+  for (View* v = GetEventHandlerForPoint(event.location());
        v && v != this && !consumed; v = v->parent())
-    consumed = v->OnScrollEvent(e);
+    consumed = v->OnScrollEvent(event);
   return consumed;
 }
 
 ui::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
   // TODO: this looks all wrong. On a TOUCH_PRESSED we should figure out the
   // view and target that view with all touches with the same id until the
   // release (or keep it if captured).
 
-  TouchEvent e(event, this);
-
   // If touch_pressed_handler_ is non null, we are currently processing
   // a touch down on the screen situation. In that case we send the
   // event to touch_pressed_handler_
   ui::TouchStatus status = ui::TOUCH_STATUS_UNKNOWN;
 
   if (touch_pressed_handler_) {
-    TouchEvent touch_event(e, this, touch_pressed_handler_);
+    TouchEvent touch_event(event, this, touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
     if (status == ui::TOUCH_STATUS_END)
       touch_pressed_handler_ = NULL;
     return status;
   }
 
   // Walk up the tree until we find a view that wants the touch event.
-  for (touch_pressed_handler_ = GetEventHandlerForPoint(e.location());
+  for (touch_pressed_handler_ = GetEventHandlerForPoint(event.location());
        touch_pressed_handler_ && (touch_pressed_handler_ != this);
        touch_pressed_handler_ = touch_pressed_handler_->parent()) {
     if (!touch_pressed_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
       status = ui::TOUCH_STATUS_UNKNOWN;
       break;
     }
 
     // See if this view wants to handle the touch
-    TouchEvent touch_event(e, this, touch_pressed_handler_);
+    TouchEvent touch_event(event, this, touch_pressed_handler_);
     status = touch_pressed_handler_->ProcessTouchEvent(touch_event);
 
     // The view could have removed itself from the tree when handling
     // OnTouchEvent(). So handle as per OnMousePressed. NB: we
     // assume that the RootView itself cannot be so removed.
     if (!touch_pressed_handler_)
       break;
 
     // The touch event wasn't processed. Go up the view hierarchy and dispatch
     // the touch event.
     if (status == ui::TOUCH_STATUS_UNKNOWN)
       continue;
 
     // If the touch didn't initiate a touch-sequence, then reset the touch event
     // handler. Otherwise, leave it set so that subsequent touch events are
     // dispatched to the same handler.
     if (status != ui::TOUCH_STATUS_START)
       touch_pressed_handler_ = NULL;
 
     return status;
   }
 
   // Reset touch_pressed_handler_ to indicate that no processing is occurring.
   touch_pressed_handler_ = NULL;
 
   return status;
 }
 
 ui::GestureStatus RootView::OnGestureEvent(const GestureEvent& event) {
-  GestureEvent e(event, this);
   ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
 
   if (gesture_handler_) {
     // |gesture_handler_| (or |scroll_gesture_handler_|) can be deleted during
     // processing.
     View* handler = scroll_gesture_handler_ &&
         (event.IsScrollGestureEvent() || event.IsFlingScrollEvent())  ?
             scroll_gesture_handler_ : gesture_handler_;
     GestureEvent handler_event(event, this, handler);
 
@@ skipping 14 matching lines @@
 
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN &&
         !scroll_gesture_handler_) {
       // Some view started processing gesture events, however it does not
       // process scroll-gesture events. In such case, we allow the event to
       // bubble up, and install a different scroll-gesture handler different
       // from the default gesture handler.
       for (scroll_gesture_handler_ = gesture_handler_->parent();
           scroll_gesture_handler_ && scroll_gesture_handler_ != this;
           scroll_gesture_handler_ = scroll_gesture_handler_->parent()) {
-        GestureEvent gesture_event(e, this, scroll_gesture_handler_);
+        GestureEvent gesture_event(event, this, scroll_gesture_handler_);
         status = scroll_gesture_handler_->ProcessGestureEvent(gesture_event);
         if (status == ui::GESTURE_STATUS_CONSUMED)
           return status;
       }
       scroll_gesture_handler_ = NULL;
     }
 
     return ui::GESTURE_STATUS_UNKNOWN;
   }
 
   // Walk up the tree until we find a view that wants the gesture event.
-  for (gesture_handler_ = GetEventHandlerForPoint(e.location());
+  for (gesture_handler_ = GetEventHandlerForPoint(event.location());
       gesture_handler_ && (gesture_handler_ != this);
       gesture_handler_ = gesture_handler_->parent()) {
     if (!gesture_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
       return ui::GESTURE_STATUS_UNKNOWN;
     }
 
     // See if this view wants to handle the Gesture.
-    GestureEvent gesture_event(e, this, gesture_handler_);
+    GestureEvent gesture_event(event, this, gesture_handler_);
     status = gesture_handler_->ProcessGestureEvent(gesture_event);
 
     // The view could have removed itself from the tree when handling
     // OnGestureEvent(). So handle as per OnMousePressed. NB: we
     // assume that the RootView itself cannot be so removed.
     if (!gesture_handler_)
       return ui::GESTURE_STATUS_UNKNOWN;
 
     if (status == ui::GESTURE_STATUS_CONSUMED) {
       if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
@@ skipping 79 matching lines @@
 }
 
 void RootView::SetMouseLocationAndFlags(const MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
 }  // namespace internal
 }  // namespace views