Drag and drop cleans up touch sequences from the source window.

ui/events/gestures/gesture_recognizer.h

 // 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.
 
 #ifndef UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_H_
 #define UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 44 matching lines @@
   // |source_device_id|, within
   // GestureConfiguration::max_separation_for_gesture_touches_in_pixels of
   // |location|, or NULL if no such point exists.
   virtual GestureConsumer* GetTargetForLocation(
       const gfx::PointF& location, int source_device_id) = 0;
 
   // Cancels all touches except those targeted to |not_cancelled|. If
   // |not_cancelled| == nullptr, cancels all touches.
   virtual void CancelActiveTouchesExcept(GestureConsumer* not_cancelled) = 0;
 
-  // Makes |new_consumer| the target for events previously targeting
-  // |current_consumer|. Touches targeting all other targets are
-  // canceled. The caller is responsible for updating the state of the
-  // consumers to be aware of this transfer of control (there are no
-  // ENTERED/EXITED events).
-  virtual void TransferEventsTo(GestureConsumer* current_consumer,
+  // Transfer the gesture stream from the drag source (current_consumer) to the
+  // consumer used for dragging (new_consumer). This dispatches cancel events to
+  // |current_consumer| to ensure that its touch stream remains valid.
+  virtual void BeginDragAndDrop(GestureConsumer* current_consumer,
                                 GestureConsumer* new_consumer) = 0;
 
+  // Transfer the gesture stream from the drag source (current_consumer) to the
+  // consumer used for dragging (new_consumer). This doesn't dispatch cancel
+  // events to |current_consumer|.
+  virtual void BeginTabDrag(GestureConsumer* current_consumer,

[sadrul, 2016/05/03 18:38:16]

GR is a fairly low-level component; it shouldn't need to know to behave
differently for high-level concepts like tab-drag. I would go with
TransferEventsTo(current, new, should_cancel_current). The caller can decide
whether it wants the cancel events or not.

[tdresser, 2016/05/03 18:56:42]

That was my instinct initially too, but I changed my mind upon further
reflection.

I agree that this is bad, but I think it's bad because the behavior of drag and
drop and tab dragging is logically coupled tightly to this behavior. Pretending
the tight coupling doesn't exist by giving things a general name doesn't prevent
the tight coupling. The correct fix here requires decoupling the behavior of tab
drag and drag and drop from the gesture recognizer, but this would likely be
fairly difficult, of questionable value, and definitely not merge-able to M51.

I think it's important that it be clear that these are not general purpose
methods that you should call when you want to transfer an event stream, but very
specific methods with behavior tailored for specific use cases.

We really don't want additional consumers of these methods, and I think making
them extremely specific is a good approach.

The behaviors required for tab drag vs. drag and drop are pretty fundamentally
different, and I think being explicit about this is worth the layering
violation.

[sadrul, 2016/05/04 13:28:18]

I think it's OK for the 'transfer sequence from A to B' to specify whether to
explicitly cancel the sequence in A or not, but I can also see that the caller
may not really know whether they want the cancels or not. So I am OK with what
you have here.

+                            GestureConsumer* new_consumer) = 0;
+
   // If a gesture is underway for |consumer| |point| is set to the last touch
   // point and true is returned. If no touch events have been processed for
   // |consumer| false is returned and |point| is untouched.
   virtual bool GetLastTouchPointForTarget(GestureConsumer* consumer,
                                           gfx::PointF* point) = 0;
 
   // Sends a touch cancel event for every active touch. Returns true iff any
   // touch cancels were sent.
   virtual bool CancelActiveTouches(GestureConsumer* consumer) = 0;
 
   // Subscribes |helper| for dispatching async gestures such as long press.
   // The Gesture Recognizer does NOT take ownership of |helper| and it is the
   // responsibility of the |helper| to call |RemoveGestureEventHelper()| on
   // destruction.
   virtual void AddGestureEventHelper(GestureEventHelper* helper) = 0;
 
   // Unsubscribes |helper| from async gesture dispatch.
   // Since the GestureRecognizer does not own the |helper|, it is not deleted
   // and must be cleaned up appropriately by the caller.
   virtual void RemoveGestureEventHelper(GestureEventHelper* helper) = 0;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_GESTURES_GESTURE_RECOGNIZER_H_