[WIP] Allow scroll events to permanently change the default gesture handler in RootView

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"
@@ skipping 141 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),
-      scroll_gesture_handler_(NULL),
       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)));
@@ skipping 83 matching lines @@
   //                   eventually remove this function altogether. See
   //                   crbug.com/348083.
 
   if (event->IsKeyEvent())
     return EventProcessor::OnEventFromSource(event);
 
   if (event->IsScrollEvent())
     return EventProcessor::OnEventFromSource(event);
 
   if (event->IsGestureEvent()) {
-    // Ignore subsequent gesture scroll events if no handler was set for a
-    // ui::ET_GESTURE_SCROLL_BEGIN event.
-    if (!gesture_handler_ &&
-        (event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
-         event->type() == ui::ET_GESTURE_SCROLL_END ||
-         event->type() == ui::ET_SCROLL_FLING_START)) {
+    ui::GestureEvent* gesture_event = event->AsGestureEvent();
+
+    // Do not dispatch ui::ET_GESTURE_BEGIN events.
+    if (gesture_event->type() == ui::ET_GESTURE_BEGIN)
+      return DispatchDetails();
+
+    // Do not dispatch ui::ET_GESTURE_END events, but reset the gesture handler
+    // if this ui::ET_GESTURE_END event corresponds to the removal of the final
+    // touch point.
+    if (gesture_event->type() == ui::ET_GESTURE_END) {
+      if (gesture_event->details().touch_points() <= 1) {
+        // In case a drag was in progress, reset all the handlers. Otherwise,
+        // just reset the gesture handler.
+        if (gesture_handler_ && gesture_handler_ == mouse_pressed_handler_)
+          SetMouseHandler(NULL);
+        else
+          gesture_handler_ = NULL;
+      }
+
       return DispatchDetails();
     }
 
-    DispatchGestureEvent(event->AsGestureEvent());
+    // Do not dispatch 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();
+    }
+
+    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.";
 
   return DispatchDetails();
@@ skipping 260 matching lines @@
     }
   }
   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();
 }
 
 void RootView::GetAccessibleState(ui::AXViewState* state) {
   state->name = widget_->widget_delegate()->GetAccessibleWindowTitle();
   state->role = widget_->widget_delegate()->GetAccessibleWindowRole();
 }
 
 void RootView::UpdateParentLayer() {
   if (layer())
     ReparentLayer(gfx::Vector2d(GetMirroredX(), y()), widget_->GetLayer());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, protected:
 
 void RootView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   widget_->ViewHierarchyChanged(details);
 
   if (!details.is_add) {
     if (!explicit_mouse_handler_ && mouse_pressed_handler_ == details.child)
       mouse_pressed_handler_ = NULL;
     if (mouse_move_handler_ == details.child)
       mouse_move_handler_ = NULL;
-    if (gesture_handler_ == details.child)
+    if (gesture_handler_ == details.child) {
       gesture_handler_ = NULL;
-    if (scroll_gesture_handler_ == details.child)
-      scroll_gesture_handler_ = NULL;
+    }
     if (event_dispatch_target_ == details.child)
       event_dispatch_target_ = NULL;
     if (old_dispatch_target_ == details.child)
       old_dispatch_target_ = NULL;
   }
 }
 
 void RootView::VisibilityChanged(View* /*starting_from*/, bool is_visible) {
   if (!is_visible) {
     // When the root view is being hidden (e.g. when widget is minimized)
     // handlers are reset, so that after it is reshown, events are not captured
     // by old handlers.
     explicit_mouse_handler_ = false;
     mouse_pressed_handler_ = NULL;
     mouse_move_handler_ = NULL;
     gesture_handler_ = NULL;
-    scroll_gesture_handler_ = NULL;
     event_dispatch_target_ = NULL;
     old_dispatch_target_ = NULL;
   }
 }
 
 void RootView::OnPaint(gfx::Canvas* canvas) {
   if (!layer() || !layer()->fills_bounds_opaquely())
     canvas->DrawColor(SK_ColorBLACK, SkXfermode::kClear_Mode);
 
   View::OnPaint(canvas);
@@ skipping 11 matching lines @@
   return &drag_info_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootView, private:
 
 // Input -----------------------------------------------------------------------
 
 void RootView::DispatchGestureEvent(ui::GestureEvent* event) {
   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_;
-    ui::GestureEvent handler_event(*event, static_cast<View*>(this), handler);
+    // |gesture_handler_| can be deleted during processing.
+    ui::GestureEvent handler_event(*event,
+                                   static_cast<View*>(this),
+                                   gesture_handler_);
     ui::EventDispatchDetails dispatch_details =
-        DispatchEvent(handler, &handler_event);
+        DispatchEvent(gesture_handler_, &handler_event);
     if (dispatch_details.dispatcher_destroyed)
       return;
 
-    if (event->type() == ui::ET_GESTURE_END &&
-        event->details().touch_points() <= 1) {
-      // In case a drag was in progress, reset all the handlers. Otherwise, just
-      // reset the gesture handler.
-      if (gesture_handler_ == mouse_pressed_handler_)
-        SetMouseHandler(NULL);
-      else
-        gesture_handler_ = NULL;
-    }
-
-    if (scroll_gesture_handler_ &&
-        (event->type() == ui::ET_GESTURE_SCROLL_END ||
-         event->type() == ui::ET_SCROLL_FLING_START)) {
-      scroll_gesture_handler_ = NULL;
-    }
-
     if (handler_event.stopped_propagation()) {
       event->StopPropagation();
       return;
     } else if (handler_event.handled()) {
       event->SetHandled();
       return;
     }
 
-    if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN &&
-        !scroll_gesture_handler_) {
+    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, 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()) {
+      // 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()) {
         ui::GestureEvent gesture_event(*event, static_cast<View*>(this),
-                                       scroll_gesture_handler_);
+                                       gesture_handler_);
         ui::EventDispatchDetails dispatch_details =
-            DispatchEvent(scroll_gesture_handler_, &gesture_event);
+            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;
         }
       }
-      scroll_gesture_handler_ = NULL;
+      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()) {
-    if (!gesture_handler_->enabled()) {
-      // Disabled views eat events but are treated as not handled.
+    // Disabled views eat events but are treated as not handled.
+    if (!gesture_handler_->enabled())
       return;
-    }
 
     // See if this view wants to handle the Gesture.
     ui::GestureEvent gesture_event(*event, static_cast<View*>(this),
                                    gesture_handler_);
     ui::EventDispatchDetails dispatch_details =
         DispatchEvent(gesture_handler_, &gesture_event);
     if (dispatch_details.dispatcher_destroyed)
       return;
 
     // 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;
 
     if (gesture_event.handled()) {
-      if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
-        scroll_gesture_handler_ = gesture_handler_;
       if (gesture_event.stopped_propagation())
         event->StopPropagation();
       else
         event->SetHandled();
-      // Last ui::ET_GESTURE_END should not set the gesture_handler_.
-      if (gesture_event.type() == ui::ET_GESTURE_END &&
-          event->details().touch_points() <= 1) {
-        gesture_handler_ = NULL;
-      }
       return;
     }
 
     // The gesture event wasn't processed. Go up the view hierarchy and
     // dispatch the gesture event.
   }
 
   gesture_handler_ = NULL;
 }
 
@@ skipping 54 matching lines @@
 
 #ifndef NDEBUG
   DCHECK(!event_dispatch_target_ || Contains(event_dispatch_target_));
 #endif
 
   return details;
 }
 
 }  // namespace internal
 }  // namespace views