Support targeting for gestures in ViewTargeter

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/message_loop.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/view_targeter.h"
-#include "ui/views/views_switches.h"
+#include "ui/views/widget/root_view_targeter.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 typedef ui::EventDispatchDetails DispatchDetails;
 
 namespace views {
 namespace internal {
 
 namespace {
 
@@ skipping 118 matching lines @@
 RootView::RootView(Widget* widget)
     : widget_(widget),
       mouse_pressed_handler_(NULL),
       mouse_move_handler_(NULL),
       last_click_handler_(NULL),
       explicit_mouse_handler_(false),
       last_mouse_event_flags_(0),
       last_mouse_event_x_(-1),
       last_mouse_event_y_(-1),
       gesture_handler_(NULL),
+      allow_gesture_event_retargeting_(true),
       pre_dispatch_handler_(new internal::PreEventDispatchHandler(this)),
       post_dispatch_handler_(new internal::PostEventDispatchHandler),
       focus_search_(this, false, false),
       focus_traversable_parent_(NULL),
       focus_traversable_parent_view_(NULL),
       event_dispatch_target_(NULL),
       old_dispatch_target_(NULL) {
   AddPreTargetHandler(pre_dispatch_handler_.get());
   AddPostTargetHandler(post_dispatch_handler_.get());
-  SetEventTargeter(scoped_ptr<ViewTargeter>(new ViewTargeter(this)));
+  SetEventTargeter(scoped_ptr<ViewTargeter>(new RootViewTargeter(this, this)));
 }
 
 RootView::~RootView() {
   // If we have children remove them explicitly so to make sure a remove
   // notification is sent for each one of them.
   if (has_children())
     RemoveAllChildViews(true);
 }
 
 // Tree operations -------------------------------------------------------------
@@ skipping 95 matching lines @@
 
     // Ignore subsequent gesture scroll events if no handler was set for a
     // ui::ET_GESTURE_SCROLL_BEGIN event.
     if (!gesture_handler_ &&
         (gesture_event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
          gesture_event->type() == ui::ET_GESTURE_SCROLL_END ||
          gesture_event->type() == ui::ET_SCROLL_FLING_START)) {
       return DispatchDetails();
     }
 
+    // If |gesture_handler_| is non-null (as a result of dispatching a previous
+    // gesture event), then |gesture_event| should be dispatched only to
+    // |gesture_handler_|.
+    allow_gesture_event_retargeting_ = gesture_handler_ ? false : true;
+
     DispatchGestureEvent(gesture_event);
     return DispatchDetails();
   }
 
   if (event->IsTouchEvent())
     NOTREACHED() << "Touch events should not be sent to RootView.";
 
   if (event->IsMouseEvent())
     NOTREACHED() << "Should not be called with a MouseEvent.";
 
@@ skipping 375 matching lines @@
     }
 
     if (event->handled())
       return;
 
     if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       // Some view started processing gesture events, however it does not
       // process scroll-gesture events. In such case, we allow the event to
       // bubble up. |gesture_handler_| is changed to its nearest ancestor
       // that handles scroll-gesture events.
-      for (gesture_handler_ = gesture_handler_->parent();
-           gesture_handler_ && gesture_handler_ != this;
-           gesture_handler_ = gesture_handler_->parent()) {
+      gesture_handler_ = static_cast<View*>(
+          targeter()->FindNextBestTarget(gesture_handler_, event));
+      while (gesture_handler_ && gesture_handler_ != this) {
         ui::GestureEvent gesture_event(*event,
                                        static_cast<View*>(this),
                                        gesture_handler_);
         ui::EventDispatchDetails dispatch_details =
             DispatchEvent(gesture_handler_, &gesture_event);
         if (gesture_event.stopped_propagation()) {
           event->StopPropagation();
           return;
         } else if (gesture_event.handled()) {
           event->SetHandled();
           return;
         } else if (dispatch_details.dispatcher_destroyed ||
                    dispatch_details.target_destroyed) {
           return;
         }
+        gesture_handler_ = static_cast<View*>(
+            targeter()->FindNextBestTarget(gesture_handler_, event));
       }
       gesture_handler_ = NULL;
     }
 
     return;
   }
 
-  View* gesture_handler = NULL;
-  if (views::switches::IsRectBasedTargetingEnabled() &&
-      !event->details().bounding_box().IsEmpty()) {
-    // TODO(tdanderson): Pass in the bounding box to GetEventHandlerForRect()
-    // once crbug.com/313392 is resolved.
-    gfx::Rect touch_rect(event->details().bounding_box());
-    touch_rect.set_origin(event->location());
-    touch_rect.Offset(-touch_rect.width() / 2, -touch_rect.height() / 2);
-    gesture_handler = GetEventHandlerForRect(touch_rect);
-  } else {
-    gesture_handler = GetEventHandlerForPoint(event->location());
-  }
-
   // Walk up the tree until we find a view that wants the gesture event.
-  for (gesture_handler_ = gesture_handler;
-       gesture_handler_ && (gesture_handler_ != this);
-       gesture_handler_ = gesture_handler_->parent()) {
+  gesture_handler_ =
+      static_cast<View*>(targeter()->FindTargetForEvent(this, event));
+  while (gesture_handler_ && gesture_handler_ != this) {
     // Disabled views are permitted to be targets of gesture events, but
     // gesture events should never actually be dispatched to them.
     if (!gesture_handler_->enabled()) {
       event->SetHandled();
 
       // Last ui::ET_GESTURE_END should not set the gesture_handler_.
       if (event->type() == ui::ET_GESTURE_END) {
         DCHECK_EQ(1, event->details().touch_points());
         gesture_handler_ = NULL;
       }
@@ skipping 24 matching lines @@
       // Last ui::ET_GESTURE_END should not set the gesture_handler_.
       if (gesture_event.type() == ui::ET_GESTURE_END) {
         DCHECK_EQ(1, event->details().touch_points());
         gesture_handler_ = NULL;
       }
       return;
     }
 
     // The gesture event wasn't processed. Go up the view hierarchy and
     // dispatch the gesture event.
+    gesture_handler_ = static_cast<View*>(
+        targeter()->FindNextBestTarget(gesture_handler_, event));
   }
 
   gesture_handler_ = NULL;
 }
 
 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));
@@ skipping 49 matching lines @@
 
 #ifndef NDEBUG
   DCHECK(!event_dispatch_target_ || Contains(event_dispatch_target_));
 #endif
 
   return details;
 }
 
 }  // namespace internal
 }  // namespace views