[Compositor event queue] FlingCancel should clear on-going gesture flag

ui/events/blink/input_handler_proxy.cc

 // Copyright 2013 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/events/blink/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 248 matching lines @@
       fling_may_be_active_on_main_thread_(false),
       disallow_horizontal_fling_scroll_(false),
       disallow_vertical_fling_scroll_(false),
       has_fling_animation_started_(false),
       smooth_scroll_enabled_(false),
       uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()),
       touchpad_and_wheel_scroll_latching_enabled_(false),
       touch_start_result_(kEventDispositionUndefined),
       mouse_wheel_result_(kEventDispositionUndefined),
       current_overscroll_params_(nullptr),
-      has_ongoing_compositor_scroll_pinch_(false),
+      has_ongoing_compositor_scroll_fling_pinch_(false),
       tick_clock_(base::MakeUnique<base::DefaultTickClock>()) {
   DCHECK(client);
   input_handler_->BindToClient(this);
   cc::ScrollElasticityHelper* scroll_elasticity_helper =
       input_handler_->CreateScrollElasticityHelper();
   if (scroll_elasticity_helper) {
     scroll_elasticity_controller_.reset(
         new InputScrollElasticityController(scroll_elasticity_helper));
   }
   compositor_event_queue_ =
@@ skipping 30 matching lines @@
 
   // Note: Other input can race ahead of gesture input as they don't have to go
   // through the queue, but we believe it's OK to do so.
   if (!compositor_event_queue_ ||
       !IsGestureScrollOrFlingOrPinch(event_with_callback->event().type())) {
     DispatchSingleInputEvent(std::move(event_with_callback),
                              tick_clock_->NowTicks());
     return;
   }
 
-  if (has_ongoing_compositor_scroll_pinch_) {
+  if (has_ongoing_compositor_scroll_fling_pinch_) {
     bool needs_animate_input = compositor_event_queue_->empty();
     compositor_event_queue_->Queue(std::move(event_with_callback),
                                    tick_clock_->NowTicks());
     if (needs_animate_input)
       input_handler_->SetNeedsAnimateInput();
     return;
   }
 
   // We have to dispatch the event to know whether the gesture sequence will be
   // handled by the compositor or not.
@@ skipping 35 matching lines @@
   std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor =
       input_handler_->CreateLatencyInfoSwapPromiseMonitor(
           &monitored_latency_info);
 
   current_overscroll_params_.reset();
   InputHandlerProxy::EventDisposition disposition =
       HandleInputEvent(event_with_callback->event());
 
   switch (event_with_callback->event().type()) {
     case blink::WebGestureEvent::GestureScrollBegin:
+    case blink::WebGestureEvent::GestureFlingStart:
     case blink::WebGestureEvent::GesturePinchBegin:
     case blink::WebGestureEvent::GestureScrollUpdate:
     case blink::WebGestureEvent::GesturePinchUpdate:
-      has_ongoing_compositor_scroll_pinch_ = disposition == DID_HANDLE;
+      has_ongoing_compositor_scroll_fling_pinch_ = disposition == DID_HANDLE;
       break;
 
     case blink::WebGestureEvent::GestureScrollEnd:
+    case blink::WebGestureEvent::GestureFlingCancel:
     case blink::WebGestureEvent::GesturePinchEnd:
-      has_ongoing_compositor_scroll_pinch_ = false;
+      has_ongoing_compositor_scroll_fling_pinch_ = false;
       break;
     default:
       break;
   }
 
   // Will run callback for every original events.
   event_with_callback->RunCallbacks(disposition, monitored_latency_info,
                                     std::move(current_overscroll_params_));
 }
 
@@ skipping 1219 matching lines @@
                  scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
                  scroll_result));
 }
 
 void InputHandlerProxy::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ui