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

 // Copyright 2024 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/child_frame_input_helper.h"

 #include "base/trace_event/trace_event.h"
 #include "components/input/features.h"
 #include "components/input/render_input_router.h"
 #include "components/input/render_widget_host_input_event_router.h"
 #include "third_party/blink/public/common/frame/frame_visual_properties.h"

 namespace input {

 ChildFrameInputHelper::~ChildFrameInputHelper() = default;

 ChildFrameInputHelper::ChildFrameInputHelper(RenderWidgetHostViewInput* view,
                                              Delegate* delegate)
     : view_(view), delegate_(delegate) {
   CHECK(view);
 }

 void ChildFrameInputHelper::NotifyHitTestRegionUpdated(
     const viz::AggregatedHitTestRegion& region) {
   std::optional<gfx::RectF> screen_rect =
       region.transform.InverseMapRect(gfx::RectF(region.rect));
   if (!screen_rect) {
     last_stable_screen_rect_ = gfx::RectF();
     last_stable_screen_rect_for_iov2_ = gfx::RectF();
     screen_rect_stable_since_ = base::TimeTicks::Now();
     screen_rect_stable_since_for_iov2_ = base::TimeTicks::Now();
     return;
   }

   // Convert to DIP
   screen_rect->Scale(1. / view_->GetDeviceScaleFactor());

   // Movement as a proportion of frame size
   double horizontal_movement =
       screen_rect->width()
           ? std::abs(last_stable_screen_rect_.x() - screen_rect->x()) /
                 screen_rect->width()
           : 0.0;
   double vertical_movement =
       screen_rect->height()
           ? std::abs(last_stable_screen_rect_.y() - screen_rect->y()) /
                 screen_rect->height()
           : 0.0;
   if ((ToRoundedSize(screen_rect->size()) !=
        ToRoundedSize(last_stable_screen_rect_.size())) ||
       horizontal_movement >
           blink::FrameVisualProperties::MaxChildFrameScreenRectMovement() ||
       vertical_movement >
           blink::FrameVisualProperties::MaxChildFrameScreenRectMovement()) {
     last_stable_screen_rect_ = *screen_rect;
     screen_rect_stable_since_ = base::TimeTicks::Now();
   }
   // The legacy logic is based on manhattan distance.
   if ((ToRoundedSize(screen_rect->size()) !=
        ToRoundedSize(last_stable_screen_rect_for_iov2_.size())) ||
       (std::abs(last_stable_screen_rect_for_iov2_.x() - screen_rect->x()) +
            std::abs(last_stable_screen_rect_for_iov2_.y() - screen_rect->y()) >
        blink::FrameVisualProperties::
            MaxChildFrameScreenRectMovementForIOv2())) {
     last_stable_screen_rect_for_iov2_ = *screen_rect;
     screen_rect_stable_since_for_iov2_ = base::TimeTicks::Now();
   }
 }

 bool ChildFrameInputHelper::ScreenRectIsUnstableFor(
     const blink::WebInputEvent& event) {
   // Some tests generate events with artificial timestamps; ignore these.
   if (event.TimeStamp() < screen_rect_stable_since_) {
     return false;
   }
   if (event.TimeStamp() -
           base::Milliseconds(
               blink::FrameVisualProperties::MinScreenRectStableTimeMs()) <
       screen_rect_stable_since_) {
     return true;
   }
   if (auto* parent = view_->GetParentViewInput()) {
     return parent->ScreenRectIsUnstableFor(event);
   }
   return false;
 }

 bool ChildFrameInputHelper::ScreenRectIsUnstableForIOv2For(
     const blink::WebInputEvent& event) {
   // Some tests generate events with artificial timestamps; ignore these.
   if (event.TimeStamp() < screen_rect_stable_since_for_iov2_) {
     return false;
   }
   if (event.TimeStamp() -
           base::Milliseconds(blink::FrameVisualProperties::
                                  MinScreenRectStableTimeMsForIOv2()) <
       screen_rect_stable_since_for_iov2_) {
     return true;
   }
   if (RenderWidgetHostViewInput* parent = view_->GetParentViewInput()) {
     return parent->ScreenRectIsUnstableForIOv2For(event);
   }
   return false;
 }

 gfx::PointF ChildFrameInputHelper::TransformPointToRootCoordSpaceF(
     const gfx::PointF& point) {
   return TransformPointToRootCoordSpace(point);
 }

 gfx::PointF ChildFrameInputHelper::TransformPointToRootCoordSpace(
     const gfx::PointF& point) {
   if (!delegate_) {
     return point;
   }

   gfx::PointF transformed_point;
   TransformPointToCoordSpaceForView(point, delegate_->GetRootViewInput(),
                                     view_->GetFrameSinkId(),
                                     &transformed_point);
   return transformed_point;
 }

 gfx::PointF ChildFrameInputHelper::TransformRootPointToViewCoordSpace(
     const gfx::PointF& point) {
   if (!delegate_) {
     return point;
   }

   auto* root_rwhv = delegate_->GetRootViewInput();
   if (!root_rwhv) {
     return point;
   }

   gfx::PointF transformed_point;
   if (!root_rwhv->TransformPointToCoordSpaceForView(point, view_,
                                                     &transformed_point)) {
     return point;
   }
   return transformed_point;
 }

 bool ChildFrameInputHelper::TransformPointToCoordSpaceForView(
     const gfx::PointF& point,
     input::RenderWidgetHostViewInput* target_view,
     gfx::PointF* transformed_point) {
   if (target_view == view_) {
     *transformed_point = point;
     return true;
   }

   return TransformPointToCoordSpaceForView(
       point, target_view, view_->GetFrameSinkId(), transformed_point);
 }

 bool ChildFrameInputHelper::TransformPointToCoordSpaceForView(
     const gfx::PointF& point,
     input::RenderWidgetHostViewInput* target_view,
     const viz::FrameSinkId& local_frame_sink_id,
     gfx::PointF* transformed_point) {
   if (!delegate_) {
     return false;
   }

   RenderWidgetHostViewInput* root_view = delegate_->GetRootViewInput();
   if (!root_view) {
     return false;
   }

   // It is possible that neither the original surface or target surface is an
   // ancestor of the other in the RenderWidgetHostView tree (e.g. they could
   // be siblings). To account for this, the point is first transformed into the
   // root coordinate space and then the root is asked to perform the conversion.
   if (!root_view->TransformPointToLocalCoordSpace(point, local_frame_sink_id,
                                                   transformed_point)) {
     return false;
   }

   if (target_view == root_view) {
     return true;
   }

   return root_view->TransformPointToCoordSpaceForView(
       *transformed_point, target_view, transformed_point);
 }

 void ChildFrameInputHelper::TransformPointToRootSurface(gfx::PointF* point) {
   // This function is called by RenderWidgetHostInputEventRouter only for
   // root-views.
   NOTREACHED();
 }

 blink::mojom::InputEventResultState ChildFrameInputHelper::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
   // A child renderer should never receive a GesturePinch event. Pinch events
   // can still be targeted to a child, but they must be processed without
   // sending the pinch event to the child (e.g. touchpad pinch synthesizes
   // wheel events to send to the child renderer).
   if (blink::WebInputEvent::IsPinchGestureEventType(input_event.GetType())) {
     const blink::WebGestureEvent& gesture_event =
         static_cast<const blink::WebGestureEvent&>(input_event);
     // Touchscreen pinch events may be targeted to a child in order to have the
     // child's TouchActionFilter filter them, but we may encounter
     // https://crbug.com/771330 which would let the pinch events through.
     if (gesture_event.SourceDevice() == blink::WebGestureDevice::kTouchscreen) {
       return blink::mojom::InputEventResultState::kConsumed;
     }
     DUMP_WILL_BE_NOTREACHED();
   }

   if (input_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
     const blink::WebGestureEvent& gesture_event =
         static_cast<const blink::WebGestureEvent&>(input_event);
     // Zero-velocity touchpad flings are an Aura-specific signal that the
     // touchpad scroll has ended, and should not be forwarded to the renderer.
     if (gesture_event.SourceDevice() == blink::WebGestureDevice::kTouchpad &&
         !gesture_event.data.fling_start.velocity_x &&
         !gesture_event.data.fling_start.velocity_y) {
       // Here we indicate that there was no consumer for this event, as
       // otherwise the fling animation system will try to run an animation
       // and will also expect a notification when the fling ends. Since
       // CrOS just uses the GestureFlingStart with zero-velocity as a means
       // of indicating that touchpad scroll has ended, we don't actually want
       // a fling animation.
       // Note: this event handling is modeled on similar code in
       // TenderWidgetHostViewAura::FilterInputEvent().
       return blink::mojom::InputEventResultState::kNoConsumerExists;
     }
   }

   if (is_scroll_sequence_bubbling_ &&
       (input_event.GetType() ==
        blink::WebInputEvent::Type::kGestureScrollUpdate) &&
       delegate_) {
     // If we're bubbling, then to preserve latching behaviour, the child should
     // not consume this event. If the child has added its viewport to the scroll
     // chain, then any GSU events we send to the renderer could be consumed,
     // even though we intend for them to be bubbled. So we immediately bubble
     // any scroll updates without giving the child a chance to consume them.
     // If the child has not added its viewport to the scroll chain, then we
     // know that it will not attempt to consume the rest of the scroll
     // sequence.
     return blink::mojom::InputEventResultState::kNoConsumerExists;
   }

   return blink::mojom::InputEventResultState::kNotConsumed;
 }

 void ChildFrameInputHelper::StopFlingingIfNecessary(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   // In case of scroll bubbling the target view is in charge of stopping the
   // fling if needed.
   if (is_scroll_sequence_bubbling_) {
     return;
   }

   // Delegates to RenderWidgetHostViewInput to stop flinging if the GSU event
   // with momentum phase was not consumed by the renderer.
   view_->RenderWidgetHostViewInput::StopFlingingIfNecessary(event, ack_result);
 }

 void ChildFrameInputHelper::GestureEventAckHelper(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultSource ack_source,
     blink::mojom::InputEventResultState ack_result) {
   // Stop flinging if a GSU event with momentum phase is sent to the renderer
   // but not consumed.
   StopFlingingIfNecessary(event, ack_result);

   if (event.IsTouchpadZoomEvent()) {
     ProcessTouchpadZoomEventAckInRoot(event, ack_source, ack_result);
   }

   // GestureScrollBegin is a blocking event; It is forwarded for bubbling if
   // its ack is not consumed. For the rest of the scroll events
   // (GestureScrollUpdate, GestureScrollEnd) are bubbled if the
   // GestureScrollBegin was bubbled. If the browser consumed the event, the
   // event was filtered and shouldn't affect the state of scroll bubbling.
   bool event_filtered =
       ack_source == blink::mojom::InputEventResultSource::kBrowser &&
       ack_result == blink::mojom::InputEventResultState::kConsumed;

   // TODO(crbug.com/346629231): Remove flag guard once this lands. Prior to the
   // fix this section was always entered.
   if (!event_filtered ||
       !base::FeatureList::IsEnabled(input::features::kScrollBubblingFix)) {
     if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
       DCHECK(!is_scroll_sequence_bubbling_);
       is_scroll_sequence_bubbling_ =
           ack_result == blink::mojom::InputEventResultState::kNotConsumed ||
           ack_result == blink::mojom::InputEventResultState::kNoConsumerExists;
     }

     if (is_scroll_sequence_bubbling_ &&
         (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin ||
          event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
          event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd)) {
       const bool can_continue = BubbleScrollEvent(event);
       if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd ||
           !can_continue) {
         is_scroll_sequence_bubbling_ = false;
       }
     }
   }

   TRACE_EVENT_INSTANT0("input", "Did_Ack_To_Frame_Connector",
                        TRACE_EVENT_SCOPE_THREAD);
   DidAckGestureEvent(event, ack_result);
 }

 void ChildFrameInputHelper::ForwardTouchpadZoomEventIfNecessary(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   // ACKs of synthetic wheel events for touchpad pinch or double tap are
   // processed in the root RWHV.
   NOTREACHED();
 }

 void ChildFrameInputHelper::ProcessTouchpadZoomEventAckInRoot(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultSource ack_source,
     blink::mojom::InputEventResultState ack_result) {
   DCHECK(event.IsTouchpadZoomEvent());
   if (!delegate_) {
     return;
   }
   auto* root_view = delegate_->GetRootViewInput();
   if (!root_view) {
     return;
   }

   blink::WebGestureEvent root_event(event);
   const gfx::PointF root_point =
       TransformPointToRootCoordSpaceF(event.PositionInWidget());
   root_event.SetPositionInWidget(root_point);
   root_view->GestureEventAck(root_event, ack_source, ack_result);
 }

 bool ChildFrameInputHelper::BubbleScrollEvent(
     const blink::WebGestureEvent& event) {
   TRACE_EVENT1("input", "ChildFrameInputHelper::BubbleScrollEvent", "type",
                blink::WebInputEvent::GetName(event.GetType()));
   DCHECK(event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin ||
          event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate ||
          event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd);

   if (!delegate_) {
     return false;
   }
   auto* parent_view = delegate_->GetParentViewInput();

   if (!parent_view) {
     return false;
   }

   auto* event_router = parent_view->GetViewRenderInputRouter()
                            ->delegate()
                            ->GetInputEventRouter();

   // We will only convert the coordinates back to the root here. The
   // RenderWidgetHostInputEventRouter will determine which ancestor view will
   // receive a resent gesture event, so it will be responsible for converting to
   // the coordinates of the target view.
   blink::WebGestureEvent resent_gesture_event(event);
   const gfx::PointF root_point =
       view_->TransformPointToRootCoordSpaceF(event.PositionInWidget());
   resent_gesture_event.SetPositionInWidget(root_point);
   // When a gesture event is bubbled to the parent frame, set the allowed touch
   // action of the parent frame to Auto so that this gesture event is allowed.
   parent_view->GetViewRenderInputRouter()
       ->input_router()
       ->ForceSetTouchActionAuto();

   TRACE_EVENT_INSTANT0("input", "Did_Bubble_To_InputEventRouter",
                        TRACE_EVENT_SCOPE_THREAD);
   return event_router->BubbleScrollEvent(parent_view, view_,
                                          resent_gesture_event);
 }

 void ChildFrameInputHelper::DidAckGestureEvent(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   if (!delegate_) {
     return;
   }

   auto* root_view = delegate_->GetRootViewInput();
   if (!root_view) {
     return;
   }

   root_view->ChildDidAckGestureEvent(event, ack_result);
 }

 }  // namespace input
	// Copyright 2024 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/child_frame_input_helper.h"

	#include "base/trace_event/trace_event.h"
	#include "components/input/features.h"
	#include "components/input/render_input_router.h"
	#include "components/input/render_widget_host_input_event_router.h"
	#include "third_party/blink/public/common/frame/frame_visual_properties.h"

	namespace input {

	ChildFrameInputHelper::~ChildFrameInputHelper() = default;

	ChildFrameInputHelper::ChildFrameInputHelper(RenderWidgetHostViewInput* view,
	Delegate* delegate)
	: view_(view), delegate_(delegate) {
	CHECK(view);
	}

	void ChildFrameInputHelper::NotifyHitTestRegionUpdated(
	const viz::AggregatedHitTestRegion& region) {
	std::optional<gfx::RectF> screen_rect =
	region.transform.InverseMapRect(gfx::RectF(region.rect));
	if (!screen_rect) {
	last_stable_screen_rect_ = gfx::RectF();
	last_stable_screen_rect_for_iov2_ = gfx::RectF();
	screen_rect_stable_since_ = base::TimeTicks::Now();
	screen_rect_stable_since_for_iov2_ = base::TimeTicks::Now();
	return;
	}

	// Convert to DIP
	screen_rect->Scale(1. / view_->GetDeviceScaleFactor());

	// Movement as a proportion of frame size
	double horizontal_movement =
	screen_rect->width()
	? std::abs(last_stable_screen_rect_.x() - screen_rect->x()) /
	screen_rect->width()
	: 0.0;
	double vertical_movement =
	screen_rect->height()
	? std::abs(last_stable_screen_rect_.y() - screen_rect->y()) /
	screen_rect->height()
	: 0.0;
	if ((ToRoundedSize(screen_rect->size()) !=
	ToRoundedSize(last_stable_screen_rect_.size())) \|\|
	horizontal_movement >
	blink::FrameVisualProperties::MaxChildFrameScreenRectMovement() \|\|
	vertical_movement >
	blink::FrameVisualProperties::MaxChildFrameScreenRectMovement()) {
	last_stable_screen_rect_ = *screen_rect;
	screen_rect_stable_since_ = base::TimeTicks::Now();
	}
	// The legacy logic is based on manhattan distance.
	if ((ToRoundedSize(screen_rect->size()) !=
	ToRoundedSize(last_stable_screen_rect_for_iov2_.size())) \|\|
	(std::abs(last_stable_screen_rect_for_iov2_.x() - screen_rect->x()) +
	std::abs(last_stable_screen_rect_for_iov2_.y() - screen_rect->y()) >
	blink::FrameVisualProperties::
	MaxChildFrameScreenRectMovementForIOv2())) {
	last_stable_screen_rect_for_iov2_ = *screen_rect;
	screen_rect_stable_since_for_iov2_ = base::TimeTicks::Now();
	}
	}

	bool ChildFrameInputHelper::ScreenRectIsUnstableFor(
	const blink::WebInputEvent& event) {
	// Some tests generate events with artificial timestamps; ignore these.
	if (event.TimeStamp() < screen_rect_stable_since_) {
	return false;
	}
	if (event.TimeStamp() -
	base::Milliseconds(
	blink::FrameVisualProperties::MinScreenRectStableTimeMs()) <
	screen_rect_stable_since_) {
	return true;
	}
	if (auto* parent = view_->GetParentViewInput()) {
	return parent->ScreenRectIsUnstableFor(event);
	}
	return false;
	}

	bool ChildFrameInputHelper::ScreenRectIsUnstableForIOv2For(
	const blink::WebInputEvent& event) {
	// Some tests generate events with artificial timestamps; ignore these.
	if (event.TimeStamp() < screen_rect_stable_since_for_iov2_) {
	return false;
	}
	if (event.TimeStamp() -
	base::Milliseconds(blink::FrameVisualProperties::
	MinScreenRectStableTimeMsForIOv2()) <
	screen_rect_stable_since_for_iov2_) {
	return true;
	}
	if (RenderWidgetHostViewInput* parent = view_->GetParentViewInput()) {
	return parent->ScreenRectIsUnstableForIOv2For(event);
	}
	return false;
	}

	gfx::PointF ChildFrameInputHelper::TransformPointToRootCoordSpaceF(
	const gfx::PointF& point) {
	return TransformPointToRootCoordSpace(point);
	}

	gfx::PointF ChildFrameInputHelper::TransformPointToRootCoordSpace(
	const gfx::PointF& point) {
	if (!delegate_) {
	return point;
	}

	gfx::PointF transformed_point;
	TransformPointToCoordSpaceForView(point, delegate_->GetRootViewInput(),
	view_->GetFrameSinkId(),
	&transformed_point);
	return transformed_point;
	}

	gfx::PointF ChildFrameInputHelper::TransformRootPointToViewCoordSpace(
	const gfx::PointF& point) {
	if (!delegate_) {
	return point;
	}

	auto* root_rwhv = delegate_->GetRootViewInput();
	if (!root_rwhv) {
	return point;
	}

	gfx::PointF transformed_point;
	if (!root_rwhv->TransformPointToCoordSpaceForView(point, view_,
	&transformed_point)) {
	return point;
	}
	return transformed_point;
	}

	bool ChildFrameInputHelper::TransformPointToCoordSpaceForView(
	const gfx::PointF& point,
	input::RenderWidgetHostViewInput* target_view,
	gfx::PointF* transformed_point) {
	if (target_view == view_) {
	*transformed_point = point;
	return true;
	}

	return TransformPointToCoordSpaceForView(
	point, target_view, view_->GetFrameSinkId(), transformed_point);
	}

	bool ChildFrameInputHelper::TransformPointToCoordSpaceForView(
	const gfx::PointF& point,
	input::RenderWidgetHostViewInput* target_view,
	const viz::FrameSinkId& local_frame_sink_id,
	gfx::PointF* transformed_point) {
	if (!delegate_) {
	return false;
	}

	RenderWidgetHostViewInput* root_view = delegate_->GetRootViewInput();
	if (!root_view) {
	return false;
	}

	// It is possible that neither the original surface or target surface is an
	// ancestor of the other in the RenderWidgetHostView tree (e.g. they could
	// be siblings). To account for this, the point is first transformed into the
	// root coordinate space and then the root is asked to perform the conversion.
	if (!root_view->TransformPointToLocalCoordSpace(point, local_frame_sink_id,
	transformed_point)) {
	return false;
	}

	if (target_view == root_view) {
	return true;
	}

	return root_view->TransformPointToCoordSpaceForView(
	*transformed_point, target_view, transformed_point);
	}

	void ChildFrameInputHelper::TransformPointToRootSurface(gfx::PointF* point) {
	// This function is called by RenderWidgetHostInputEventRouter only for
	// root-views.
	NOTREACHED();
	}

	blink::mojom::InputEventResultState ChildFrameInputHelper::FilterInputEvent(
	const blink::WebInputEvent& input_event) {
	// A child renderer should never receive a GesturePinch event. Pinch events
	// can still be targeted to a child, but they must be processed without
	// sending the pinch event to the child (e.g. touchpad pinch synthesizes
	// wheel events to send to the child renderer).
	if (blink::WebInputEvent::IsPinchGestureEventType(input_event.GetType())) {
	const blink::WebGestureEvent& gesture_event =
	static_cast<const blink::WebGestureEvent&>(input_event);
	// Touchscreen pinch events may be targeted to a child in order to have the
	// child's TouchActionFilter filter them, but we may encounter
	// https://crbug.com/771330 which would let the pinch events through.
	if (gesture_event.SourceDevice() == blink::WebGestureDevice::kTouchscreen) {
	return blink::mojom::InputEventResultState::kConsumed;
	}
	DUMP_WILL_BE_NOTREACHED();
	}

	if (input_event.GetType() == blink::WebInputEvent::Type::kGestureFlingStart) {
	const blink::WebGestureEvent& gesture_event =
	static_cast<const blink::WebGestureEvent&>(input_event);
	// Zero-velocity touchpad flings are an Aura-specific signal that the
	// touchpad scroll has ended, and should not be forwarded to the renderer.
	if (gesture_event.SourceDevice() == blink::WebGestureDevice::kTouchpad &&
	!gesture_event.data.fling_start.velocity_x &&
	!gesture_event.data.fling_start.velocity_y) {
	// Here we indicate that there was no consumer for this event, as
	// otherwise the fling animation system will try to run an animation
	// and will also expect a notification when the fling ends. Since
	// CrOS just uses the GestureFlingStart with zero-velocity as a means
	// of indicating that touchpad scroll has ended, we don't actually want
	// a fling animation.
	// Note: this event handling is modeled on similar code in
	// TenderWidgetHostViewAura::FilterInputEvent().
	return blink::mojom::InputEventResultState::kNoConsumerExists;
	}
	}

	if (is_scroll_sequence_bubbling_ &&
	(input_event.GetType() ==
	blink::WebInputEvent::Type::kGestureScrollUpdate) &&
	delegate_) {
	// If we're bubbling, then to preserve latching behaviour, the child should
	// not consume this event. If the child has added its viewport to the scroll
	// chain, then any GSU events we send to the renderer could be consumed,
	// even though we intend for them to be bubbled. So we immediately bubble
	// any scroll updates without giving the child a chance to consume them.
	// If the child has not added its viewport to the scroll chain, then we
	// know that it will not attempt to consume the rest of the scroll
	// sequence.
	return blink::mojom::InputEventResultState::kNoConsumerExists;
	}

	return blink::mojom::InputEventResultState::kNotConsumed;
	}

	void ChildFrameInputHelper::StopFlingingIfNecessary(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {
	// In case of scroll bubbling the target view is in charge of stopping the
	// fling if needed.
	if (is_scroll_sequence_bubbling_) {
	return;
	}

	// Delegates to RenderWidgetHostViewInput to stop flinging if the GSU event
	// with momentum phase was not consumed by the renderer.
	view_->RenderWidgetHostViewInput::StopFlingingIfNecessary(event, ack_result);
	}

	void ChildFrameInputHelper::GestureEventAckHelper(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultSource ack_source,
	blink::mojom::InputEventResultState ack_result) {
	// Stop flinging if a GSU event with momentum phase is sent to the renderer
	// but not consumed.
	StopFlingingIfNecessary(event, ack_result);

	if (event.IsTouchpadZoomEvent()) {
	ProcessTouchpadZoomEventAckInRoot(event, ack_source, ack_result);
	}

	// GestureScrollBegin is a blocking event; It is forwarded for bubbling if
	// its ack is not consumed. For the rest of the scroll events
	// (GestureScrollUpdate, GestureScrollEnd) are bubbled if the
	// GestureScrollBegin was bubbled. If the browser consumed the event, the
	// event was filtered and shouldn't affect the state of scroll bubbling.
	bool event_filtered =
	ack_source == blink::mojom::InputEventResultSource::kBrowser &&
	ack_result == blink::mojom::InputEventResultState::kConsumed;

	// TODO(crbug.com/346629231): Remove flag guard once this lands. Prior to the
	// fix this section was always entered.
	if (!event_filtered \|\|
	!base::FeatureList::IsEnabled(input::features::kScrollBubblingFix)) {
	if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
	DCHECK(!is_scroll_sequence_bubbling_);
	is_scroll_sequence_bubbling_ =
	ack_result == blink::mojom::InputEventResultState::kNotConsumed \|\|
	ack_result == blink::mojom::InputEventResultState::kNoConsumerExists;
	}

	if (is_scroll_sequence_bubbling_ &&
	(event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin \|\|
	event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate \|\|
	event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd)) {
	const bool can_continue = BubbleScrollEvent(event);
	if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd \|\|
	!can_continue) {
	is_scroll_sequence_bubbling_ = false;
	}
	}
	}

	TRACE_EVENT_INSTANT0("input", "Did_Ack_To_Frame_Connector",
	TRACE_EVENT_SCOPE_THREAD);
	DidAckGestureEvent(event, ack_result);
	}

	void ChildFrameInputHelper::ForwardTouchpadZoomEventIfNecessary(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {
	// ACKs of synthetic wheel events for touchpad pinch or double tap are
	// processed in the root RWHV.
	NOTREACHED();
	}

	void ChildFrameInputHelper::ProcessTouchpadZoomEventAckInRoot(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultSource ack_source,
	blink::mojom::InputEventResultState ack_result) {
	DCHECK(event.IsTouchpadZoomEvent());
	if (!delegate_) {
	return;
	}
	auto* root_view = delegate_->GetRootViewInput();
	if (!root_view) {
	return;
	}

	blink::WebGestureEvent root_event(event);
	const gfx::PointF root_point =
	TransformPointToRootCoordSpaceF(event.PositionInWidget());
	root_event.SetPositionInWidget(root_point);
	root_view->GestureEventAck(root_event, ack_source, ack_result);
	}

	bool ChildFrameInputHelper::BubbleScrollEvent(
	const blink::WebGestureEvent& event) {
	TRACE_EVENT1("input", "ChildFrameInputHelper::BubbleScrollEvent", "type",
	blink::WebInputEvent::GetName(event.GetType()));
	DCHECK(event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin \|\|
	event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate \|\|
	event.GetType() == blink::WebInputEvent::Type::kGestureScrollEnd);

	if (!delegate_) {
	return false;
	}
	auto* parent_view = delegate_->GetParentViewInput();

	if (!parent_view) {
	return false;
	}

	auto* event_router = parent_view->GetViewRenderInputRouter()
	->delegate()
	->GetInputEventRouter();

	// We will only convert the coordinates back to the root here. The
	// RenderWidgetHostInputEventRouter will determine which ancestor view will
	// receive a resent gesture event, so it will be responsible for converting to
	// the coordinates of the target view.
	blink::WebGestureEvent resent_gesture_event(event);
	const gfx::PointF root_point =
	view_->TransformPointToRootCoordSpaceF(event.PositionInWidget());
	resent_gesture_event.SetPositionInWidget(root_point);
	// When a gesture event is bubbled to the parent frame, set the allowed touch
	// action of the parent frame to Auto so that this gesture event is allowed.
	parent_view->GetViewRenderInputRouter()
	->input_router()
	->ForceSetTouchActionAuto();

	TRACE_EVENT_INSTANT0("input", "Did_Bubble_To_InputEventRouter",
	TRACE_EVENT_SCOPE_THREAD);
	return event_router->BubbleScrollEvent(parent_view, view_,
	resent_gesture_event);
	}

	void ChildFrameInputHelper::DidAckGestureEvent(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {
	if (!delegate_) {
	return;
	}

	auto* root_view = delegate_->GetRootViewInput();
	if (!root_view) {
	return;
	}

	root_view->ChildDidAckGestureEvent(event, ack_result);
	}

	} // namespace input