Adjust cancelabilty of touchmoves that are queued when scroll start occurs

content/renderer/input/main_thread_event_queue.cc

 // Copyright 2016 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 "content/renderer/input/main_thread_event_queue.h"
 
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/common/input/event_with_latency_info.h"
 #include "content/common/input_messages.h"
 
 namespace content {
 
 namespace {
 
 const size_t kTenSeconds = 10 * 1000 * 1000;
 
 class QueuedClosure : public MainThreadEventQueueTask {
  public:
   QueuedClosure(const base::Closure& closure) : closure_(closure) {}
 
   ~QueuedClosure() override {}
 
-  CoalesceResult CoalesceWith(
+  FilterResult FilterNewEvent(
       const MainThreadEventQueueTask& other_task) override {
-    return other_task.IsWebInputEvent() ? CoalesceResult::KeepSearching
-                                        : CoalesceResult::CannotCoalesce;
+    return other_task.IsWebInputEvent() ? FilterResult::KeepIterating
+                                        : FilterResult::StopIterating;
   }
 
   bool IsWebInputEvent() const override { return false; }
 
   void Dispatch(int routing_id, MainThreadEventQueueClient*) override {
     closure_.Run();
   }
 
   void EventHandled(int routing_id,
                     blink::scheduler::RendererScheduler* renderer_scheduler,
@@ skipping 15 matching lines @@
                       bool originally_cancelable)
       : ScopedWebInputEventWithLatencyInfo(std::move(event), latency),
         dispatch_type_(dispatch_type),
         non_blocking_coalesced_count_(0),
         creation_timestamp_(base::TimeTicks::Now()),
         last_coalesced_timestamp_(creation_timestamp_),
         originally_cancelable_(originally_cancelable) {}
 
   ~QueuedWebInputEvent() override {}
 
-  CoalesceResult CoalesceWith(
-      const MainThreadEventQueueTask& other_item) override {
-    if (!other_item.IsWebInputEvent())
-      return CoalesceResult::CannotCoalesce;
+  FilterResult FilterNewEvent(
+      const MainThreadEventQueueTask& other_task) override {
+    if (!other_task.IsWebInputEvent())
+      return FilterResult::StopIterating;
 
     const QueuedWebInputEvent& other_event =
-        static_cast<const QueuedWebInputEvent&>(other_item);
+        static_cast<const QueuedWebInputEvent&>(other_task);
+    if (other_event.event().type() ==
+        blink::WebInputEvent::TouchScrollStarted) {
+      return HandleTouchScrollStartQueued();
+    }
+
     if (!event().isSameEventClass(other_event.event()))
-      return CoalesceResult::KeepSearching;
+      return FilterResult::KeepIterating;
 
     if (!ScopedWebInputEventWithLatencyInfo::CanCoalesceWith(other_event))
-      return CoalesceResult::CannotCoalesce;
+      return FilterResult::StopIterating;
 
     // If this event was blocking push the event id to the blocking
     // list before updating the dispatch_type of this event.
     if (dispatch_type_ == DISPATCH_TYPE_BLOCKING) {
       blocking_coalesced_event_ids_.push_back(
           ui::WebInputEventTraits::GetUniqueTouchEventId(event()));
     } else {
       non_blocking_coalesced_count_++;
     }
     ScopedWebInputEventWithLatencyInfo::CoalesceWith(other_event);
     last_coalesced_timestamp_ = base::TimeTicks::Now();
 
     // The newest event (|other_item|) always wins when updating fields.
     dispatch_type_ = other_event.dispatch_type_;
     originally_cancelable_ = other_event.originally_cancelable_;
 
-    return CoalesceResult::Coalesced;
+    return FilterResult::PreventQueuingEvent;

[tdresser, 2017/03/31 20:50:20]

It seems a bit weird to me that we consider coalescing to not be queueing. Could
this be called "CoalescedEvent"?

[dtapuska, 2017/03/31 21:06:10]

Done.

   }
 
   bool IsWebInputEvent() const override { return true; }
 
   void Dispatch(int routing_id, MainThreadEventQueueClient* client) override {
     // Report the coalesced count only for continuous events; otherwise
     // the zero value would be dominated by non-continuous events.
     base::TimeTicks now = base::TimeTicks::Now();
     if (IsContinuousEvent()) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
@@ skipping 40 matching lines @@
       client->SendInputEventAck(routing_id, type, ack_result, id);
       if (renderer_scheduler) {
         renderer_scheduler->DidHandleInputEventOnMainThread(event(), result);
       }
     }
   }
 
   bool originallyCancelable() const { return originally_cancelable_; }
 
  private:
+  FilterResult HandleTouchScrollStartQueued() {
+    // A TouchScrollStart will queued after this touch move which will make all
+    // previous touch moves that are queued uncancelable.
+    switch (event().type()) {
+      case blink::WebInputEvent::TouchMove: {
+        blink::WebTouchEvent& touch_event =
+            static_cast<blink::WebTouchEvent&>(event());
+        if (touch_event.dispatchType ==
+            blink::WebInputEvent::DispatchType::Blocking) {
+          touch_event.dispatchType =
+              blink::WebInputEvent::DispatchType::EventNonBlocking;
+        }
+        return FilterResult::KeepIterating;
+      }
+      case blink::WebInputEvent::TouchStart:
+      case blink::WebInputEvent::TouchEnd:
+        return FilterResult::StopIterating;
+      default:
+        return FilterResult::KeepIterating;
+    }
+  }
+
   const std::deque<uint32_t>& blockingCoalescedEventIds() const {
     return blocking_coalesced_event_ids_;
   }
   InputEventDispatchType dispatchType() const { return dispatch_type_; }
   base::TimeTicks creationTimestamp() const { return creation_timestamp_; }
   base::TimeTicks lastCoalescedTimestamp() const {
     return last_coalesced_timestamp_;
   }
 
   size_t coalescedCount() const {
@@ skipping 339 matching lines @@
     case blink::WebInputEvent::MouseWheel:
       return handle_raf_aligned_mouse_input_;
     case blink::WebInputEvent::TouchMove:
       return handle_raf_aligned_touch_input_;
     default:
       return false;
   }
 }
 
 }  // namespace content