Ignore the rest of the scroll sequence if GSB is ignored.

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 240 matching lines @@
     : client_(client),
       input_handler_(input_handler),
       deferred_fling_cancel_time_seconds_(0),
       synchronous_input_handler_(nullptr),
       allow_root_animate_(true),
 #ifndef NDEBUG
       expect_scroll_update_end_(false),
 #endif
       gesture_scroll_on_impl_thread_(false),
       gesture_pinch_on_impl_thread_(false),
+      scroll_sequence_ignored_(false),
       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_(
           touchpad_and_wheel_scroll_latching_enabled),
       touch_result_(kEventDispositionUndefined),
       mouse_wheel_result_(kEventDispositionUndefined),
@@ skipping 578 matching lines @@
                            "InputHandlerProxy::handle_input gesture scroll",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = true;
       result = DID_HANDLE;
       break;
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
       result = DID_NOT_HANDLE;
       break;
     case cc::InputHandler::SCROLL_IGNORED:
+      scroll_sequence_ignored_ = true;
       result = DROP_EVENT;
       break;
   }
   if (scroll_elasticity_controller_ && result != DID_NOT_HANDLE)
     HandleScrollElasticityOverscroll(gesture_event,
                                      cc::InputHandlerScrollResult());
 
   return result;
 }
 
 InputHandlerProxy::EventDisposition
 InputHandlerProxy::HandleGestureScrollUpdate(
     const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
 #endif
+
+  if (scroll_sequence_ignored_)
+    return DROP_EVENT;
+
   if (!gesture_scroll_on_impl_thread_ && !gesture_pinch_on_impl_thread_)
     return DID_NOT_HANDLE;
 
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   gfx::Point scroll_point(gesture_event.x, gesture_event.y);
   gfx::Vector2dF scroll_delta(-gesture_event.data.scroll_update.delta_x,
                               -gesture_event.data.scroll_update.delta_y);
 
   if (ShouldAnimate(gesture_event.data.scroll_update.delta_units !=
                     blink::WebGestureEvent::ScrollUnits::kPixels)) {
@@ skipping 41 matching lines @@
   expect_scroll_update_end_ = false;
 #endif
   if (ShouldAnimate(gesture_event.data.scroll_end.delta_units !=
                     blink::WebGestureEvent::ScrollUnits::kPixels)) {
     // Do nothing if the scroll is being animated; the scroll animation will
     // generate the ScrollEnd when it is done.
   } else {
     cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
     input_handler_->ScrollEnd(&scroll_state);
   }
+
+  if (scroll_sequence_ignored_) {
+    scroll_sequence_ignored_ = false;
+    return DROP_EVENT;
+  }
+
   if (!gesture_scroll_on_impl_thread_)
     return DID_NOT_HANDLE;
 
   if (scroll_elasticity_controller_)
     HandleScrollElasticityOverscroll(gesture_event,
                                      cc::InputHandlerScrollResult());
 
   gesture_scroll_on_impl_thread_ = false;
   return DID_HANDLE;
 }
@@ skipping 715 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