components/input/touch_action_filter.cc - chromium/src - Git at Google

 // Copyright 2013 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "components/input/touch_action_filter.h"

 #include <math.h>

 #include "base/check_op.h"
 #include "base/notreached.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/blink/public/common/input/web_gesture_event.h"
 #include "ui/base/ui_base_features.h"
 #include "ui/events/blink/blink_features.h"

 using blink::WebInputEvent;
 using blink::WebGestureEvent;

 namespace input {
 namespace {

 // Actions on an axis are disallowed if the perpendicular axis has a filter set
 // and no filter is set for the queried axis.
 bool IsYAxisActionDisallowed(cc::TouchAction action) {
   return ((action & cc::TouchAction::kPanX) != cc::TouchAction::kNone) &&
          ((action & cc::TouchAction::kPanY) == cc::TouchAction::kNone);
 }

 bool IsXAxisActionDisallowed(cc::TouchAction action) {
   return ((action & cc::TouchAction::kPanY) != cc::TouchAction::kNone) &&
          ((action & cc::TouchAction::kPanX) == cc::TouchAction::kNone);
 }

 void SetCursorControlIfNecessary(WebGestureEvent* event,
                                  cc::TouchAction action) {
   if (event->data.scroll_begin.pointer_count != 1)
     return;
   const float abs_delta_x = fabs(event->data.scroll_begin.delta_x_hint);
   const float abs_delta_y = fabs(event->data.scroll_begin.delta_y_hint);
   if (abs_delta_x <= abs_delta_y)
     return;

   // We shouldn't reach here if kPanX is not allowed for horizontal scroll.
   DCHECK_NE(action & cc::TouchAction::kPanX, cc::TouchAction::kNone);
   if ((action & cc::TouchAction::kInternalPanXScrolls) ==
       cc::TouchAction::kInternalPanXScrolls)
     return;

   event->data.scroll_begin.cursor_control = true;
 }

 }  // namespace

 TouchActionFilter::TouchActionFilter() {
   ResetTouchAction();
 }

 TouchActionFilter::~TouchActionFilter() = default;

 FilterGestureEventResult TouchActionFilter::FilterGestureEvent(
     WebGestureEvent* gesture_event) {
   TRACE_EVENT0("input", "TouchActionFilter::FilterGestureEvent");
   if (gesture_event->SourceDevice() != blink::WebGestureDevice::kTouchscreen)
     return FilterGestureEventResult::kAllowed;

   if (has_deferred_events_) {
     TRACE_EVENT_INSTANT0("input", "Has Deferred", TRACE_EVENT_SCOPE_THREAD);
     return FilterGestureEventResult::kDelayed;
   }

   TRACE_EVENT_INSTANT1(
       "input", "active_action", TRACE_EVENT_SCOPE_THREAD, "action",
       (active_touch_action_.has_value()
            ? cc::TouchActionToString(active_touch_action_.value())
            : "n/a"));
   TRACE_EVENT_INSTANT1(
       "input", "allowed_action", TRACE_EVENT_SCOPE_THREAD, "action",
       (allowed_touch_action_.has_value()
            ? cc::TouchActionToString(allowed_touch_action_.value())
            : "n/a"));
   TRACE_EVENT_INSTANT1(
       "input", "compositor_allowed_action", TRACE_EVENT_SCOPE_THREAD, "action",
       cc::TouchActionToString(compositor_allowed_touch_action_));

   cc::TouchAction touch_action = active_touch_action_.has_value()
                                      ? active_touch_action_.value()
                                      : compositor_allowed_touch_action_;

   // Filter for allowable touch actions first (eg. before the TouchEventQueue
   // can decide to send a touch cancel event).
   switch (gesture_event->GetType()) {
     case WebInputEvent::Type::kGestureScrollBegin: {
       // In VR or virtual keyboard (https://crbug.com/880701),
       // GestureScrollBegin could come without GestureTapDown.
       // TODO(bokan): This can also happen due to the fling controller
       // filtering out the GestureTapDown due to tap suppression (i.e. tapping
       // during a fling should stop the fling, not be sent to the page). We
       // should not reset the touch action in this case! We currently work
       // around this by resetting the compositor allowed touch action in this
       // case as well but we should investigate not filtering the TapDown.
       if (!gesture_sequence_in_progress_) {
         TRACE_EVENT_INSTANT0("input", "No Sequence at GSB!",
                              TRACE_EVENT_SCOPE_THREAD);
         gesture_sequence_in_progress_ = true;
         if (allowed_touch_action_.has_value()) {
           active_touch_action_ = allowed_touch_action_;
           touch_action = allowed_touch_action_.value();
         } else {
           touch_action = compositor_allowed_touch_action_;
         }
       }
       drop_scroll_events_ = ShouldSuppressScrolling(
           *gesture_event, touch_action, active_touch_action_.has_value());
       FilterGestureEventResult res;
       if (!drop_scroll_events_) {
         if (allow_cursor_control_) {
           SetCursorControlIfNecessary(gesture_event, touch_action);
         }
         res = FilterGestureEventResult::kAllowed;
       } else if (active_touch_action_.has_value()) {
         res = FilterGestureEventResult::kFiltered;
       } else {
         TRACE_EVENT_INSTANT0("input", "Deferring Events",
                              TRACE_EVENT_SCOPE_THREAD);
         has_deferred_events_ = true;
         res = FilterGestureEventResult::kDelayed;
       }
       return res;
     }

     case WebInputEvent::Type::kGestureScrollUpdate: {
       if (drop_scroll_events_) {
         TRACE_EVENT_INSTANT0("input", "Drop Events", TRACE_EVENT_SCOPE_THREAD);
         return FilterGestureEventResult::kFiltered;
       }

       // Scrolls restricted to a specific axis shouldn't permit movement
       // in the perpendicular axis.
       //
       // Note the direction suppression with pinch-zoom here, which matches
       // Edge: a "touch-action: pan-y pinch-zoom" region allows vertical
       // two-finger scrolling but a "touch-action: pan-x pinch-zoom" region
       // doesn't.
       // TODO(mustaq): Add it to spec?
       if (IsYAxisActionDisallowed(touch_action)) {
         if (!active_touch_action_.has_value() &&
             gesture_event->data.scroll_update.delta_y != 0) {
           TRACE_EVENT_INSTANT0("input", "Defer Due to YAxis",
                                TRACE_EVENT_SCOPE_THREAD);
           has_deferred_events_ = true;
           return FilterGestureEventResult::kDelayed;
         }
         gesture_event->data.scroll_update.delta_y = 0;
       } else if (IsXAxisActionDisallowed(touch_action)) {
         if (!active_touch_action_.has_value() &&
             gesture_event->data.scroll_update.delta_x != 0) {
           TRACE_EVENT_INSTANT0("input", "Defer Due to XAxis",
                                TRACE_EVENT_SCOPE_THREAD);
           has_deferred_events_ = true;
           return FilterGestureEventResult::kDelayed;
         }
         gesture_event->data.scroll_update.delta_x = 0;
       }
       break;
     }

     case WebInputEvent::Type::kGestureFlingStart:
       // Fling controller processes FlingStart event, and we should never get
       // it here.
       NOTREACHED();

     case WebInputEvent::Type::kGestureScrollEnd:
       // Do not reset |compositor_allowed_touch_action_|. In the fling cancel
       // case, the ack for the second touch sequence start, which sets the
       // compositor allowed touch action, could arrive before the GSE of the
       // first fling sequence, we do not want to reset the compositor allowed
       // touch action.
       gesture_sequence_in_progress_ = false;
       return FilterScrollEventAndResetState();

     // Evaluate the |drop_pinch_events_| here instead of GSB because pinch
     // events could arrive without GSB, e.g. double-tap-drag.
     case WebInputEvent::Type::kGesturePinchBegin:
       drop_pinch_events_ = (touch_action & cc::TouchAction::kPinchZoom) ==
                            cc::TouchAction::kNone;
       [[fallthrough]];
     case WebInputEvent::Type::kGesturePinchUpdate:
       if (!drop_pinch_events_)
         return FilterGestureEventResult::kAllowed;
       if (!active_touch_action_.has_value()) {
         has_deferred_events_ = true;
         return FilterGestureEventResult::kDelayed;
       }
       return FilterGestureEventResult::kFiltered;
     case WebInputEvent::Type::kGesturePinchEnd:
       return FilterPinchEventAndResetState();

     // The double tap gesture is a tap ending event. If a double-tap gesture is
     // filtered out, replace it with a tap event but preserve the tap-count to
     // allow firing dblclick event in Blink.
     //
     // TODO(mustaq): This replacement of a double-tap gesture with a tap seems
     // buggy, it produces an inconsistent gesture event stream: GestureTapCancel
     // followed by GestureTap.  See crbug.com/874474#c47 for a repro.  We don't
     // know of any bug resulting from it, but it's better to fix the broken
     // assumption here at least to avoid introducing new bugs in future.
     case WebInputEvent::Type::kGestureDoubleTap:
       gesture_sequence_in_progress_ = false;
       DCHECK_EQ(1, gesture_event->data.tap.tap_count);
       if (!allow_current_double_tap_event_) {
         gesture_event->SetType(WebInputEvent::Type::kGestureTap);
         gesture_event->data.tap.tap_count = 2;
       }
       allow_current_double_tap_event_ = true;
       break;

     // If double tap is disabled, there's no reason for the tap delay.
     case WebInputEvent::Type::kGestureTapUnconfirmed: {
       DCHECK_EQ(1, gesture_event->data.tap.tap_count);
       allow_current_double_tap_event_ =
           (touch_action & cc::TouchAction::kDoubleTapZoom) !=
           cc::TouchAction::kNone;
       if (!allow_current_double_tap_event_) {
         gesture_event->SetType(WebInputEvent::Type::kGestureTap);
         drop_current_tap_ending_event_ = true;
       }
       break;
     }

     case WebInputEvent::Type::kGestureTap:
       gesture_sequence_in_progress_ = false;
       if (drop_current_tap_ending_event_) {
         drop_current_tap_ending_event_ = false;
         return FilterGestureEventResult::kFiltered;
       }
       break;

     case WebInputEvent::Type::kGestureTapCancel:
       if (drop_current_tap_ending_event_) {
         drop_current_tap_ending_event_ = false;
         return FilterGestureEventResult::kFiltered;
       }
       break;

     case WebInputEvent::Type::kGestureTapDown:
       gesture_sequence_in_progress_ = true;
       allow_cursor_control_ =
           !::features::IsTouchTextEditingRedesignEnabled() ||
           gesture_event->data.tap_down.tap_down_count <= 1;
       // In theory, the num_of_active_touches_ should be > 0 at this point. But
       // crash reports suggest otherwise.
       if (num_of_active_touches_ <= 0)
         SetTouchAction(cc::TouchAction::kAuto);
       active_touch_action_ = allowed_touch_action_;
       DCHECK(!drop_current_tap_ending_event_);
       break;

     case WebInputEvent::Type::kGestureLongPress:
       allow_cursor_control_ = false;
       break;

     case WebInputEvent::Type::kGestureLongTap:
     case WebInputEvent::Type::kGestureTwoFingerTap:
       gesture_sequence_in_progress_ = false;
       break;

     default:
       // Gesture events unrelated to touch actions (panning/zooming) are left
       // alone.
       break;
   }

   return FilterGestureEventResult::kAllowed;
 }

 void TouchActionFilter::SetTouchAction(cc::TouchAction touch_action) {
   TRACE_EVENT1("input", "TouchActionFilter::SetTouchAction", "action",
                cc::TouchActionToString(touch_action));
   allowed_touch_action_ = touch_action;
   active_touch_action_ = allowed_touch_action_;
   compositor_allowed_touch_action_ = touch_action;
 }

 FilterGestureEventResult TouchActionFilter::FilterPinchEventAndResetState() {
   if (drop_pinch_events_) {
     drop_pinch_events_ = false;
     return FilterGestureEventResult::kFiltered;
   }
   return FilterGestureEventResult::kAllowed;
 }

 FilterGestureEventResult TouchActionFilter::FilterScrollEventAndResetState() {
   if (drop_scroll_events_) {
     drop_scroll_events_ = false;
     return FilterGestureEventResult::kFiltered;
   }
   return FilterGestureEventResult::kAllowed;
 }

 void TouchActionFilter::ForceResetTouchActionForTest() {
   allowed_touch_action_.reset();
   active_touch_action_.reset();
 }

 void TouchActionFilter::OnSetTouchAction(cc::TouchAction touch_action) {
   TRACE_EVENT2("input", "TouchActionFilter::OnSetTouchAction", "action",
                cc::TouchActionToString(touch_action), "allowed",
                (allowed_touch_action_.has_value()
                     ? cc::TouchActionToString(allowed_touch_action_.value())
                     : "n/a"));
   // TODO(crbug.com/40579429): add a DCHECK for
   // |has_touch_event_handler_|.
   // For multiple fingers, we take the intersection of the touch actions for
   // all fingers that have gone down during this action.  In the majority of
   // real-world scenarios the touch action for all fingers will be the same.
   // This is left as implementation-defined in the pointer events
   // specification because of the relationship to gestures (which are off
   // limits for the spec).  I believe the following are desirable properties
   // of this choice:
   // 1. Not sensitive to finger touch order.  Behavior of putting two fingers
   //    down "at once" will be deterministic.
   // 2. Only subtractive - eg. can't trigger scrolling on a element that
   //    otherwise has scrolling disabling by the addition of a finger.
   allowed_touch_action_ =
       allowed_touch_action_.value_or(cc::TouchAction::kAuto) & touch_action;

   // When user enabled force enable zoom, we should always allow pinch-zoom
   // except for touch-action:none.
   if (force_enable_zoom_ && allowed_touch_action_ != cc::TouchAction::kNone) {
     allowed_touch_action_ =
         allowed_touch_action_.value() | cc::TouchAction::kPinchZoom;
   }
   active_touch_action_ = allowed_touch_action_;
   has_deferred_events_ = false;
 }

 void TouchActionFilter::IncreaseActiveTouches() {
   TRACE_EVENT1("input", "TouchActionFilter::IncreaseActiveTouches", "num",
                num_of_active_touches_);
   num_of_active_touches_++;
 }

 void TouchActionFilter::DecreaseActiveTouches() {
   TRACE_EVENT1("input", "TouchActionFilter::DecreaseActiveTouches", "num",
                num_of_active_touches_);
   num_of_active_touches_--;
 }

 void TouchActionFilter::ReportAndResetTouchAction() {
   if (num_of_active_touches_ <= 0) {
     ResetTouchAction();
     allow_cursor_control_ = true;
   }
 }

 void TouchActionFilter::ResetTouchAction() {
   TRACE_EVENT0("input", "TouchActionFilter::ResetTouchAction");
   // Note that resetting the action mid-sequence is tolerated. Gestures that had
   // their begin event(s) suppressed will be suppressed until the next sequence.
   if (has_touch_event_handler_) {
     allowed_touch_action_.reset();
     compositor_allowed_touch_action_ = cc::TouchAction::kAuto;
   } else {
     // Lack of a touch handler indicates that the page either has no
     // touch-action modifiers or that all its touch-action modifiers are auto.
     // Resetting the touch-action here allows forwarding of subsequent gestures
     // even if the underlying touches never reach the router.
     SetTouchAction(cc::TouchAction::kAuto);
   }
 }

 void TouchActionFilter::OnSetCompositorAllowedTouchAction(
     cc::TouchAction allowed_touch_action) {
   TRACE_EVENT2("input", "TouchActionFilter::OnSetCompositorAllowedTouchAction",
                "action", cc::TouchActionToString(allowed_touch_action),
                "current", cc::TouchActionToString(allowed_touch_action));
   // We use '&' here to account for the multiple-finger case, which is the same
   // as OnSetTouchAction.
   compositor_allowed_touch_action_ =
       compositor_allowed_touch_action_ & allowed_touch_action;
 }

 bool TouchActionFilter::ShouldSuppressScrolling(
     const blink::WebGestureEvent& gesture_event,
     cc::TouchAction touch_action,
     bool is_active_touch_action) {
   DCHECK(gesture_event.GetType() == WebInputEvent::Type::kGestureScrollBegin);
   // If kInternalPanXScrolls is true, kPanX must be true;
   DCHECK((touch_action & cc::TouchAction::kInternalPanXScrolls) ==
              cc::TouchAction::kNone ||
          (touch_action & cc::TouchAction::kPanX) != cc::TouchAction::kNone);

   if (gesture_event.data.scroll_begin.pointer_count >= 2) {
     // Any GestureScrollBegin with more than one fingers is like a pinch-zoom
     // for touch-actions, see crbug.com/632525. Therefore, we switch to
     // blocked-manipulation mode iff pinch-zoom is disallowed.
     return (touch_action & cc::TouchAction::kPinchZoom) ==
            cc::TouchAction::kNone;
   }

   const float& deltaXHint = gesture_event.data.scroll_begin.delta_x_hint;
   const float& deltaYHint = gesture_event.data.scroll_begin.delta_y_hint;

   if (deltaXHint == 0.0 && deltaYHint == 0.0)
     return false;

   const float absDeltaXHint = fabs(deltaXHint);
   const float absDeltaYHint = fabs(deltaYHint);

   // We need to wait for main-thread touch action to see if touch region is
   // writable for stylus handwriting, and accumulate scroll events until then.
   if ((gesture_event.primary_pointer_type ==
            blink::WebPointerProperties::PointerType::kPen ||
        gesture_event.primary_pointer_type ==
            blink::WebPointerProperties::PointerType::kEraser) &&
       !is_active_touch_action &&
       (touch_action & cc::TouchAction::kInternalNotWritable) !=
           cc::TouchAction::kInternalNotWritable)
     return true;

   cc::TouchAction minimal_conforming_touch_action = cc::TouchAction::kNone;
   if (absDeltaXHint > absDeltaYHint) {
     // If we're performing a horizontal gesture over a region that could
     // potentially activate cursor control, we need to wait for the real
     // main-thread touch action before making a decision since we'll need to set
     // the cursor control bit correctly.
     if (!is_active_touch_action &&
         (touch_action & cc::TouchAction::kInternalPanXScrolls) !=
             cc::TouchAction::kInternalPanXScrolls)
       return true;

     if (deltaXHint > 0)
       minimal_conforming_touch_action |= cc::TouchAction::kPanLeft;
     else if (deltaXHint < 0)
       minimal_conforming_touch_action |= cc::TouchAction::kPanRight;
   } else {
     if (deltaYHint > 0)
       minimal_conforming_touch_action |= cc::TouchAction::kPanUp;
     else if (deltaYHint < 0)
       minimal_conforming_touch_action |= cc::TouchAction::kPanDown;
   }
   DCHECK(minimal_conforming_touch_action != cc::TouchAction::kNone);

   return (touch_action & minimal_conforming_touch_action) ==
          cc::TouchAction::kNone;
 }

 void TouchActionFilter::OnHasTouchEventHandlers(bool has_handlers) {
   TRACE_EVENT1("input", "TouchActionFilter::OnHasTouchEventHandlers",
                "has handlers", has_handlers);
   // The has_touch_event_handler_ is default to false which is why we have the
   // "&&" condition here, to ensure that touch actions will be set if there is
   // no touch event consumers.
   if (has_handlers && has_touch_event_handler_ == has_handlers)
     return;
   has_touch_event_handler_ = has_handlers;
   // We have set the associated touch action if the touch start already happened
   // or there is a gesture in progress. In these cases, we should not reset the
   // associated touch action.
   if (!gesture_sequence_in_progress_ && num_of_active_touches_ <= 0) {
     ResetTouchAction();
     if (has_touch_event_handler_) {
       active_touch_action_.reset();
     }
   }
 }

 }  // namespace input
	// Copyright 2013 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "components/input/touch_action_filter.h"

	#include <math.h>

	#include "base/check_op.h"
	#include "base/notreached.h"
	#include "base/trace_event/trace_event.h"
	#include "third_party/blink/public/common/input/web_gesture_event.h"
	#include "ui/base/ui_base_features.h"
	#include "ui/events/blink/blink_features.h"

	using blink::WebInputEvent;
	using blink::WebGestureEvent;

	namespace input {
	namespace {

	// Actions on an axis are disallowed if the perpendicular axis has a filter set
	// and no filter is set for the queried axis.
	bool IsYAxisActionDisallowed(cc::TouchAction action) {
	return ((action & cc::TouchAction::kPanX) != cc::TouchAction::kNone) &&
	((action & cc::TouchAction::kPanY) == cc::TouchAction::kNone);
	}

	bool IsXAxisActionDisallowed(cc::TouchAction action) {
	return ((action & cc::TouchAction::kPanY) != cc::TouchAction::kNone) &&
	((action & cc::TouchAction::kPanX) == cc::TouchAction::kNone);
	}

	void SetCursorControlIfNecessary(WebGestureEvent* event,
	cc::TouchAction action) {
	if (event->data.scroll_begin.pointer_count != 1)
	return;
	const float abs_delta_x = fabs(event->data.scroll_begin.delta_x_hint);
	const float abs_delta_y = fabs(event->data.scroll_begin.delta_y_hint);
	if (abs_delta_x <= abs_delta_y)
	return;

	// We shouldn't reach here if kPanX is not allowed for horizontal scroll.
	DCHECK_NE(action & cc::TouchAction::kPanX, cc::TouchAction::kNone);
	if ((action & cc::TouchAction::kInternalPanXScrolls) ==
	cc::TouchAction::kInternalPanXScrolls)
	return;

	event->data.scroll_begin.cursor_control = true;
	}

	} // namespace

	TouchActionFilter::TouchActionFilter() {
	ResetTouchAction();
	}

	TouchActionFilter::~TouchActionFilter() = default;

	FilterGestureEventResult TouchActionFilter::FilterGestureEvent(
	WebGestureEvent* gesture_event) {
	TRACE_EVENT0("input", "TouchActionFilter::FilterGestureEvent");
	if (gesture_event->SourceDevice() != blink::WebGestureDevice::kTouchscreen)
	return FilterGestureEventResult::kAllowed;

	if (has_deferred_events_) {
	TRACE_EVENT_INSTANT0("input", "Has Deferred", TRACE_EVENT_SCOPE_THREAD);
	return FilterGestureEventResult::kDelayed;
	}

	TRACE_EVENT_INSTANT1(
	"input", "active_action", TRACE_EVENT_SCOPE_THREAD, "action",
	(active_touch_action_.has_value()
	? cc::TouchActionToString(active_touch_action_.value())
	: "n/a"));
	TRACE_EVENT_INSTANT1(
	"input", "allowed_action", TRACE_EVENT_SCOPE_THREAD, "action",
	(allowed_touch_action_.has_value()
	? cc::TouchActionToString(allowed_touch_action_.value())
	: "n/a"));
	TRACE_EVENT_INSTANT1(
	"input", "compositor_allowed_action", TRACE_EVENT_SCOPE_THREAD, "action",
	cc::TouchActionToString(compositor_allowed_touch_action_));

	cc::TouchAction touch_action = active_touch_action_.has_value()
	? active_touch_action_.value()
	: compositor_allowed_touch_action_;

	// Filter for allowable touch actions first (eg. before the TouchEventQueue
	// can decide to send a touch cancel event).
	switch (gesture_event->GetType()) {
	case WebInputEvent::Type::kGestureScrollBegin: {
	// In VR or virtual keyboard (https://crbug.com/880701),
	// GestureScrollBegin could come without GestureTapDown.
	// TODO(bokan): This can also happen due to the fling controller
	// filtering out the GestureTapDown due to tap suppression (i.e. tapping
	// during a fling should stop the fling, not be sent to the page). We
	// should not reset the touch action in this case! We currently work
	// around this by resetting the compositor allowed touch action in this
	// case as well but we should investigate not filtering the TapDown.
	if (!gesture_sequence_in_progress_) {
	TRACE_EVENT_INSTANT0("input", "No Sequence at GSB!",
	TRACE_EVENT_SCOPE_THREAD);
	gesture_sequence_in_progress_ = true;
	if (allowed_touch_action_.has_value()) {
	active_touch_action_ = allowed_touch_action_;
	touch_action = allowed_touch_action_.value();
	} else {
	touch_action = compositor_allowed_touch_action_;
	}
	}
	drop_scroll_events_ = ShouldSuppressScrolling(
	*gesture_event, touch_action, active_touch_action_.has_value());
	FilterGestureEventResult res;
	if (!drop_scroll_events_) {
	if (allow_cursor_control_) {
	SetCursorControlIfNecessary(gesture_event, touch_action);
	}
	res = FilterGestureEventResult::kAllowed;
	} else if (active_touch_action_.has_value()) {
	res = FilterGestureEventResult::kFiltered;
	} else {
	TRACE_EVENT_INSTANT0("input", "Deferring Events",
	TRACE_EVENT_SCOPE_THREAD);
	has_deferred_events_ = true;
	res = FilterGestureEventResult::kDelayed;
	}
	return res;
	}

	case WebInputEvent::Type::kGestureScrollUpdate: {
	if (drop_scroll_events_) {
	TRACE_EVENT_INSTANT0("input", "Drop Events", TRACE_EVENT_SCOPE_THREAD);
	return FilterGestureEventResult::kFiltered;
	}

	// Scrolls restricted to a specific axis shouldn't permit movement
	// in the perpendicular axis.
	//
	// Note the direction suppression with pinch-zoom here, which matches
	// Edge: a "touch-action: pan-y pinch-zoom" region allows vertical
	// two-finger scrolling but a "touch-action: pan-x pinch-zoom" region
	// doesn't.
	// TODO(mustaq): Add it to spec?
	if (IsYAxisActionDisallowed(touch_action)) {
	if (!active_touch_action_.has_value() &&
	gesture_event->data.scroll_update.delta_y != 0) {
	TRACE_EVENT_INSTANT0("input", "Defer Due to YAxis",
	TRACE_EVENT_SCOPE_THREAD);
	has_deferred_events_ = true;
	return FilterGestureEventResult::kDelayed;
	}
	gesture_event->data.scroll_update.delta_y = 0;
	} else if (IsXAxisActionDisallowed(touch_action)) {
	if (!active_touch_action_.has_value() &&
	gesture_event->data.scroll_update.delta_x != 0) {
	TRACE_EVENT_INSTANT0("input", "Defer Due to XAxis",
	TRACE_EVENT_SCOPE_THREAD);
	has_deferred_events_ = true;
	return FilterGestureEventResult::kDelayed;
	}
	gesture_event->data.scroll_update.delta_x = 0;
	}
	break;
	}

	case WebInputEvent::Type::kGestureFlingStart:
	// Fling controller processes FlingStart event, and we should never get
	// it here.
	NOTREACHED();

	case WebInputEvent::Type::kGestureScrollEnd:
	// Do not reset \|compositor_allowed_touch_action_\|. In the fling cancel
	// case, the ack for the second touch sequence start, which sets the
	// compositor allowed touch action, could arrive before the GSE of the
	// first fling sequence, we do not want to reset the compositor allowed
	// touch action.
	gesture_sequence_in_progress_ = false;
	return FilterScrollEventAndResetState();

	// Evaluate the \|drop_pinch_events_\| here instead of GSB because pinch
	// events could arrive without GSB, e.g. double-tap-drag.
	case WebInputEvent::Type::kGesturePinchBegin:
	drop_pinch_events_ = (touch_action & cc::TouchAction::kPinchZoom) ==
	cc::TouchAction::kNone;
	[[fallthrough]];
	case WebInputEvent::Type::kGesturePinchUpdate:
	if (!drop_pinch_events_)
	return FilterGestureEventResult::kAllowed;
	if (!active_touch_action_.has_value()) {
	has_deferred_events_ = true;
	return FilterGestureEventResult::kDelayed;
	}
	return FilterGestureEventResult::kFiltered;
	case WebInputEvent::Type::kGesturePinchEnd:
	return FilterPinchEventAndResetState();

	// The double tap gesture is a tap ending event. If a double-tap gesture is
	// filtered out, replace it with a tap event but preserve the tap-count to
	// allow firing dblclick event in Blink.
	//
	// TODO(mustaq): This replacement of a double-tap gesture with a tap seems
	// buggy, it produces an inconsistent gesture event stream: GestureTapCancel
	// followed by GestureTap. See crbug.com/874474#c47 for a repro. We don't
	// know of any bug resulting from it, but it's better to fix the broken
	// assumption here at least to avoid introducing new bugs in future.
	case WebInputEvent::Type::kGestureDoubleTap:
	gesture_sequence_in_progress_ = false;
	DCHECK_EQ(1, gesture_event->data.tap.tap_count);
	if (!allow_current_double_tap_event_) {
	gesture_event->SetType(WebInputEvent::Type::kGestureTap);
	gesture_event->data.tap.tap_count = 2;
	}
	allow_current_double_tap_event_ = true;
	break;

	// If double tap is disabled, there's no reason for the tap delay.
	case WebInputEvent::Type::kGestureTapUnconfirmed: {
	DCHECK_EQ(1, gesture_event->data.tap.tap_count);
	allow_current_double_tap_event_ =
	(touch_action & cc::TouchAction::kDoubleTapZoom) !=
	cc::TouchAction::kNone;
	if (!allow_current_double_tap_event_) {
	gesture_event->SetType(WebInputEvent::Type::kGestureTap);
	drop_current_tap_ending_event_ = true;
	}
	break;
	}

	case WebInputEvent::Type::kGestureTap:
	gesture_sequence_in_progress_ = false;
	if (drop_current_tap_ending_event_) {
	drop_current_tap_ending_event_ = false;
	return FilterGestureEventResult::kFiltered;
	}
	break;

	case WebInputEvent::Type::kGestureTapCancel:
	if (drop_current_tap_ending_event_) {
	drop_current_tap_ending_event_ = false;
	return FilterGestureEventResult::kFiltered;
	}
	break;

	case WebInputEvent::Type::kGestureTapDown:
	gesture_sequence_in_progress_ = true;
	allow_cursor_control_ =
	!::features::IsTouchTextEditingRedesignEnabled() \|\|
	gesture_event->data.tap_down.tap_down_count <= 1;
	// In theory, the num_of_active_touches_ should be > 0 at this point. But
	// crash reports suggest otherwise.
	if (num_of_active_touches_ <= 0)
	SetTouchAction(cc::TouchAction::kAuto);
	active_touch_action_ = allowed_touch_action_;
	DCHECK(!drop_current_tap_ending_event_);
	break;

	case WebInputEvent::Type::kGestureLongPress:
	allow_cursor_control_ = false;
	break;

	case WebInputEvent::Type::kGestureLongTap:
	case WebInputEvent::Type::kGestureTwoFingerTap:
	gesture_sequence_in_progress_ = false;
	break;

	default:
	// Gesture events unrelated to touch actions (panning/zooming) are left
	// alone.
	break;
	}

	return FilterGestureEventResult::kAllowed;
	}

	void TouchActionFilter::SetTouchAction(cc::TouchAction touch_action) {
	TRACE_EVENT1("input", "TouchActionFilter::SetTouchAction", "action",
	cc::TouchActionToString(touch_action));
	allowed_touch_action_ = touch_action;
	active_touch_action_ = allowed_touch_action_;
	compositor_allowed_touch_action_ = touch_action;
	}

	FilterGestureEventResult TouchActionFilter::FilterPinchEventAndResetState() {
	if (drop_pinch_events_) {
	drop_pinch_events_ = false;
	return FilterGestureEventResult::kFiltered;
	}
	return FilterGestureEventResult::kAllowed;
	}

	FilterGestureEventResult TouchActionFilter::FilterScrollEventAndResetState() {
	if (drop_scroll_events_) {
	drop_scroll_events_ = false;
	return FilterGestureEventResult::kFiltered;
	}
	return FilterGestureEventResult::kAllowed;
	}

	void TouchActionFilter::ForceResetTouchActionForTest() {
	allowed_touch_action_.reset();
	active_touch_action_.reset();
	}

	void TouchActionFilter::OnSetTouchAction(cc::TouchAction touch_action) {
	TRACE_EVENT2("input", "TouchActionFilter::OnSetTouchAction", "action",
	cc::TouchActionToString(touch_action), "allowed",
	(allowed_touch_action_.has_value()
	? cc::TouchActionToString(allowed_touch_action_.value())
	: "n/a"));
	// TODO(crbug.com/40579429): add a DCHECK for
	// \|has_touch_event_handler_\|.
	// For multiple fingers, we take the intersection of the touch actions for
	// all fingers that have gone down during this action. In the majority of
	// real-world scenarios the touch action for all fingers will be the same.
	// This is left as implementation-defined in the pointer events
	// specification because of the relationship to gestures (which are off
	// limits for the spec). I believe the following are desirable properties
	// of this choice:
	// 1. Not sensitive to finger touch order. Behavior of putting two fingers
	// down "at once" will be deterministic.
	// 2. Only subtractive - eg. can't trigger scrolling on a element that
	// otherwise has scrolling disabling by the addition of a finger.
	allowed_touch_action_ =
	allowed_touch_action_.value_or(cc::TouchAction::kAuto) & touch_action;

	// When user enabled force enable zoom, we should always allow pinch-zoom
	// except for touch-action:none.
	if (force_enable_zoom_ && allowed_touch_action_ != cc::TouchAction::kNone) {
	allowed_touch_action_ =
	allowed_touch_action_.value() \| cc::TouchAction::kPinchZoom;
	}
	active_touch_action_ = allowed_touch_action_;
	has_deferred_events_ = false;
	}

	void TouchActionFilter::IncreaseActiveTouches() {
	TRACE_EVENT1("input", "TouchActionFilter::IncreaseActiveTouches", "num",
	num_of_active_touches_);
	num_of_active_touches_++;
	}

	void TouchActionFilter::DecreaseActiveTouches() {
	TRACE_EVENT1("input", "TouchActionFilter::DecreaseActiveTouches", "num",
	num_of_active_touches_);
	num_of_active_touches_--;
	}

	void TouchActionFilter::ReportAndResetTouchAction() {
	if (num_of_active_touches_ <= 0) {
	ResetTouchAction();
	allow_cursor_control_ = true;
	}
	}

	void TouchActionFilter::ResetTouchAction() {
	TRACE_EVENT0("input", "TouchActionFilter::ResetTouchAction");
	// Note that resetting the action mid-sequence is tolerated. Gestures that had
	// their begin event(s) suppressed will be suppressed until the next sequence.
	if (has_touch_event_handler_) {
	allowed_touch_action_.reset();
	compositor_allowed_touch_action_ = cc::TouchAction::kAuto;
	} else {
	// Lack of a touch handler indicates that the page either has no
	// touch-action modifiers or that all its touch-action modifiers are auto.
	// Resetting the touch-action here allows forwarding of subsequent gestures
	// even if the underlying touches never reach the router.
	SetTouchAction(cc::TouchAction::kAuto);
	}
	}

	void TouchActionFilter::OnSetCompositorAllowedTouchAction(
	cc::TouchAction allowed_touch_action) {
	TRACE_EVENT2("input", "TouchActionFilter::OnSetCompositorAllowedTouchAction",
	"action", cc::TouchActionToString(allowed_touch_action),
	"current", cc::TouchActionToString(allowed_touch_action));
	// We use '&' here to account for the multiple-finger case, which is the same
	// as OnSetTouchAction.
	compositor_allowed_touch_action_ =
	compositor_allowed_touch_action_ & allowed_touch_action;
	}

	bool TouchActionFilter::ShouldSuppressScrolling(
	const blink::WebGestureEvent& gesture_event,
	cc::TouchAction touch_action,
	bool is_active_touch_action) {
	DCHECK(gesture_event.GetType() == WebInputEvent::Type::kGestureScrollBegin);
	// If kInternalPanXScrolls is true, kPanX must be true;
	DCHECK((touch_action & cc::TouchAction::kInternalPanXScrolls) ==
	cc::TouchAction::kNone \|\|
	(touch_action & cc::TouchAction::kPanX) != cc::TouchAction::kNone);

	if (gesture_event.data.scroll_begin.pointer_count >= 2) {
	// Any GestureScrollBegin with more than one fingers is like a pinch-zoom
	// for touch-actions, see crbug.com/632525. Therefore, we switch to
	// blocked-manipulation mode iff pinch-zoom is disallowed.
	return (touch_action & cc::TouchAction::kPinchZoom) ==
	cc::TouchAction::kNone;
	}

	const float& deltaXHint = gesture_event.data.scroll_begin.delta_x_hint;
	const float& deltaYHint = gesture_event.data.scroll_begin.delta_y_hint;

	if (deltaXHint == 0.0 && deltaYHint == 0.0)
	return false;

	const float absDeltaXHint = fabs(deltaXHint);
	const float absDeltaYHint = fabs(deltaYHint);

	// We need to wait for main-thread touch action to see if touch region is
	// writable for stylus handwriting, and accumulate scroll events until then.
	if ((gesture_event.primary_pointer_type ==
	blink::WebPointerProperties::PointerType::kPen \|\|
	gesture_event.primary_pointer_type ==
	blink::WebPointerProperties::PointerType::kEraser) &&
	!is_active_touch_action &&
	(touch_action & cc::TouchAction::kInternalNotWritable) !=
	cc::TouchAction::kInternalNotWritable)
	return true;

	cc::TouchAction minimal_conforming_touch_action = cc::TouchAction::kNone;
	if (absDeltaXHint > absDeltaYHint) {
	// If we're performing a horizontal gesture over a region that could
	// potentially activate cursor control, we need to wait for the real
	// main-thread touch action before making a decision since we'll need to set
	// the cursor control bit correctly.
	if (!is_active_touch_action &&
	(touch_action & cc::TouchAction::kInternalPanXScrolls) !=
	cc::TouchAction::kInternalPanXScrolls)
	return true;

	if (deltaXHint > 0)
	minimal_conforming_touch_action \|= cc::TouchAction::kPanLeft;
	else if (deltaXHint < 0)
	minimal_conforming_touch_action \|= cc::TouchAction::kPanRight;
	} else {
	if (deltaYHint > 0)
	minimal_conforming_touch_action \|= cc::TouchAction::kPanUp;
	else if (deltaYHint < 0)
	minimal_conforming_touch_action \|= cc::TouchAction::kPanDown;
	}
	DCHECK(minimal_conforming_touch_action != cc::TouchAction::kNone);

	return (touch_action & minimal_conforming_touch_action) ==
	cc::TouchAction::kNone;
	}

	void TouchActionFilter::OnHasTouchEventHandlers(bool has_handlers) {
	TRACE_EVENT1("input", "TouchActionFilter::OnHasTouchEventHandlers",
	"has handlers", has_handlers);
	// The has_touch_event_handler_ is default to false which is why we have the
	// "&&" condition here, to ensure that touch actions will be set if there is
	// no touch event consumers.
	if (has_handlers && has_touch_event_handler_ == has_handlers)
	return;
	has_touch_event_handler_ = has_handlers;
	// We have set the associated touch action if the touch start already happened
	// or there is a gesture in progress. In these cases, we should not reset the
	// associated touch action.
	if (!gesture_sequence_in_progress_ && num_of_active_touches_ <= 0) {
	ResetTouchAction();
	if (has_touch_event_handler_) {
	active_touch_action_.reset();
	}
	}
	}

	} // namespace input