views: Dispatch mouse events using EventDispatch interface too.

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 10 matching lines @@
 namespace views {
 namespace internal {
 
 namespace {
 
 enum EventType {
   EVENT_ENTER,
   EVENT_EXIT
 };
 
-// |view| is the view receiving |event|. This function sends the event to all
-// the Views up the hierarchy that has |notify_enter_exit_on_child_| flag turned
-// on, but does not contain |sibling|.
-void NotifyEnterExitOfDescendant(const ui::MouseEvent& event,
-                                 EventType type,
-                                 View* view,
-                                 View* sibling) {
-  for (View* p = view->parent(); p; p = p->parent()) {
-    if (!p->notify_enter_exit_on_child())
-      continue;
-    if (sibling && p->Contains(sibling))
-        break;
-    if (type == EVENT_ENTER)
-      p->OnMouseEntered(event);
-    else
-      p->OnMouseExited(event);
+class MouseEnterExitEvent : public ui::MouseEvent {
+ public:
+  MouseEnterExitEvent(const ui::MouseEvent& event, ui::EventType type)
+      : ui::MouseEvent(event,
+                       static_cast<View*>(NULL),
+                       static_cast<View*>(NULL)) {
+    DCHECK(type == ui::ET_MOUSE_ENTERED ||
+           type == ui::ET_MOUSE_EXITED);
+    SetType(type);
   }
-}
+
+  virtual ~MouseEnterExitEvent() {}
+};
 
 }  // namespace
 
 // static
 const char RootView::kViewClassName[] = "views/RootView";
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, public:
 
 // Creation and lifetime -------------------------------------------------------
@@ skipping 85 matching lines @@
   // under the cursor.
   ui::MouseWheelEvent wheel(*event);
   if (OnMouseWheel(wheel)) {
     event->SetHandled();
   } else {
     View* focused_view =
         GetFocusManager() ? GetFocusManager()->GetFocusedView() : NULL;
     View* v = GetEventHandlerForPoint(wheel.location());
     if (v != focused_view) {
       for (; v && v != this; v = v->parent()) {
-        if (v->OnMouseWheel(wheel)) {
+        DispatchEventToTarget(v, &wheel);
+        if (wheel.handled()) {
           event->SetHandled();
           break;
         }
       }
     }
   }
 }
 
 void RootView::DispatchTouchEvent(ui::TouchEvent* event) {
   // TODO: this looks all wrong. On a TOUCH_PRESSED we should figure out the
@@ skipping 236 matching lines @@
   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_) {
     ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(this),
                                        mouse_pressed_handler_);
     drag_info_.Reset();
-    mouse_pressed_handler_->ProcessMousePressed(mouse_pressed_event,
-                                                &drag_info_);
+    DispatchEventToTarget(mouse_pressed_handler_, &mouse_pressed_event);
     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(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.
     ui::MouseEvent mouse_pressed_event(event, static_cast<View*>(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(event.flags() & ~ui::EF_IS_DOUBLE_CLICK);
 
     drag_info_.Reset();
-    bool handled = mouse_pressed_handler_->ProcessMousePressed(
-        mouse_pressed_event, &drag_info_);
+    DispatchEventToTarget(mouse_pressed_handler_, &mouse_pressed_event);
 
     // 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.)
     //
     // NOTE: Don't return true here, because we don't want the frame to
     // forward future events to us when there's no handler.
     if (!mouse_pressed_handler_)
       break;
 
     // If the view handled the event, leave mouse_pressed_handler_ set and
     // return true, which will cause subsequent drag/release events to get
     // forwarded to that view.
-    if (handled) {
+    if (mouse_pressed_event.handled()) {
       last_click_handler_ = mouse_pressed_handler_;
       DVLOG(1) << "OnMousePressed handled by "
           << mouse_pressed_handler_->GetClassName();
       return true;
     }
   }
 
   // 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_ && (event.flags() & ui::EF_IS_DOUBLE_CLICK))
     hit_disabled_view = true;
 
   last_click_handler_ = NULL;
   return hit_disabled_view;
 }
 
 bool RootView::OnMouseDragged(const ui::MouseEvent& event) {
   if (mouse_pressed_handler_) {
     SetMouseLocationAndFlags(event);
 
     ui::MouseEvent mouse_event(event, static_cast<View*>(this),
                                mouse_pressed_handler_);
-    return mouse_pressed_handler_->ProcessMouseDragged(mouse_event,
-                                                       &drag_info_);
+    DispatchEventToTarget(mouse_pressed_handler_, &mouse_event);
+    return mouse_event.handled();
   }
   return false;
 }
 
 void RootView::OnMouseReleased(const ui::MouseEvent& event) {
   UpdateCursor(event);
 
   if (mouse_pressed_handler_) {
     ui::MouseEvent mouse_released(event, static_cast<View*>(this),
                                   mouse_pressed_handler_);
-    // TODO(sadrul|oshima): This is tentative solution to pass target
-    // to LauncherDelegate::ItemClicked. Remove this once crbug.com/173235
-    // is implemented.
-    ui::Event::DispatcherApi api(&mouse_released);
-    api.set_target(this);
-
-    // We allow the view to delete us from ProcessMouseReleased. As such,
+    // We allow the view to delete us from the event dispatch callback. 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);
+    DispatchEventToTarget(mouse_pressed_handler, &mouse_released);
     // WARNING: we may have been deleted.
   }
 }
 
 void RootView::OnMouseCaptureLost() {
   // TODO: this likely needs to reset touch handler too.
 
   if (mouse_pressed_handler_ || gesture_handler_) {
     // Synthesize a release event for UpdateCursor.
     if (mouse_pressed_handler_) {
@@ skipping 22 matching lines @@
   // 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(event);
-        NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
+        MouseEnterExitEvent exit(event, ui::ET_MOUSE_EXITED);
+        DispatchEventToTarget(mouse_move_handler_, &exit);
+        NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_EXITED,
+            mouse_move_handler_, v);
       }
       View* old_handler = mouse_move_handler_;
       mouse_move_handler_ = v;
-      ui::MouseEvent entered_event(event, static_cast<View*>(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,
+        MouseEnterExitEvent entered(event, ui::ET_MOUSE_ENTERED);
+        DispatchEventToTarget(mouse_move_handler_, &entered);
+        NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_ENTERED, v,
             old_handler);
       }
     }
     ui::MouseEvent moved_event(event, static_cast<View*>(this),
                                mouse_move_handler_);
-    mouse_move_handler_->OnMouseMoved(moved_event);
+    DispatchEventToTarget(mouse_move_handler_, &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(event);
-    NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, v);
+    MouseEnterExitEvent exited(event, ui::ET_MOUSE_EXITED);
+    DispatchEventToTarget(mouse_move_handler_, &exited);
+    NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_EXITED,
+        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 (!(event.flags() & ui::EF_IS_NON_CLIENT))
       widget_->SetCursor(gfx::kNullCursor);
     mouse_move_handler_ = NULL;
   }
 }
 
 void RootView::OnMouseExited(const ui::MouseEvent& event) {
   if (mouse_move_handler_ != NULL) {
-    mouse_move_handler_->OnMouseExited(event);
-    NotifyEnterExitOfDescendant(event, EVENT_EXIT, mouse_move_handler_, NULL);
+    MouseEnterExitEvent exited(event, ui::ET_MOUSE_EXITED);
+    DispatchEventToTarget(mouse_move_handler_, &exited);
+    NotifyEnterExitOfDescendant(event, ui::ET_MOUSE_EXITED,
+        mouse_move_handler_, NULL);
     mouse_move_handler_ = NULL;
   }
 }
 
 bool RootView::OnMouseWheel(const ui::MouseWheelEvent& event) {
-  bool consumed = false;
   for (View* v = GetFocusManager() ? GetFocusManager()->GetFocusedView() : NULL;
-       v && v != this && !consumed; v = v->parent())
-    consumed = v->OnMouseWheel(event);
-  return consumed;
+       v && v != this && !event.handled(); v = v->parent())
+    DispatchEventToTarget(v, const_cast<ui::MouseWheelEvent*>(&event));
+  return event.handled();
 }
 
 void RootView::SetMouseHandler(View* new_mh) {
   // If we're clearing the mouse handler, clear explicit_mouse_handler_ as well.
   explicit_mouse_handler_ = (new_mh != NULL);
   mouse_pressed_handler_ = new_mh;
   gesture_handler_ = new_mh;
   scroll_gesture_handler_ = new_mh;
   drag_info_.Reset();
 }
@@ skipping 40 matching lines @@
 }
 
 gfx::Vector2d RootView::CalculateOffsetToAncestorWithLayer(
     ui::Layer** layer_parent) {
   gfx::Vector2d offset(View::CalculateOffsetToAncestorWithLayer(layer_parent));
   if (!layer())
     offset += widget_->CalculateOffsetToAncestorWithLayer(layer_parent);
   return offset;
 }
 
+View::DragInfo* RootView::GetDragInfo() {
+  return &drag_info_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, private:
 
 // Input -----------------------------------------------------------------------
 
 void RootView::UpdateCursor(const ui::MouseEvent& event) {
   if (!(event.flags() & ui::EF_IS_NON_CLIENT)) {
     View* v = GetEventHandlerForPoint(event.location());
     ui::MouseEvent me(event, static_cast<View*>(this), v);
     widget_->SetCursor(v->GetCursor(me));
   }
 }
 
 void RootView::SetMouseLocationAndFlags(const ui::MouseEvent& event) {
   last_mouse_event_flags_ = event.flags();
   last_mouse_event_x_ = event.x();
   last_mouse_event_y_ = event.y();
 }
 
 void RootView::DispatchEventToTarget(View* target, ui::Event* event) {
   View* old_target = event_dispatch_target_;
   event_dispatch_target_ = target;
   if (DispatchEvent(target, event))
     event_dispatch_target_ = old_target;
 }
 
+void RootView::NotifyEnterExitOfDescendant(const ui::MouseEvent& event,
+                                           ui::EventType type,
+                                           View* view,
+                                           View* sibling) {
+  for (View* p = view->parent(); p; p = p->parent()) {
+    if (!p->notify_enter_exit_on_child())
+      continue;
+    if (sibling && p->Contains(sibling))
+      break;
+    // It is necessary to recreate the notify-event for each dispatch, since one
+    // of the callbacks can mark the event as handled, and that would cause
+    // incorrect event dispatch.
+    MouseEnterExitEvent notify_event(event, type);
+    DispatchEventToTarget(p, &notify_event);
+  }
+}
+
 bool RootView::CanDispatchToTarget(ui::EventTarget* target) {
   return event_dispatch_target_ == target;
 }
 
 }  // namespace internal
 }  // namespace views