components/input/render_widget_host_view_input.cc - chromium/src.git - 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/render_widget_host_view_input.h"

 #include "base/notreached.h"
 #include "components/input/render_widget_host_input_event_router.h"
 #include "ui/gfx/geometry/dip_util.h"

 namespace input {

 RenderWidgetHostViewInput::RenderWidgetHostViewInput() = default;
 RenderWidgetHostViewInput::~RenderWidgetHostViewInput() = default;

 void RenderWidgetHostViewInput::NotifyObserversAboutShutdown() {
   // Note: RenderWidgetHostInputEventRouter is an observer, and uses the
   // following notification to remove this view from its surface owners map.
   for (auto& observer : observers_) {
     observer.OnRenderWidgetHostViewInputDestroyed(this);
   }
   // All observers are required to disconnect after they are notified.
   CHECK(observers_.empty());
 }

 void RenderWidgetHostViewInput::ProcessAckedTouchEvent(
     const input::TouchEventWithLatencyInfo& touch,
     blink::mojom::InputEventResultState ack_result) {
   DUMP_WILL_BE_NOTREACHED();
 }

 viz::FrameSinkId RenderWidgetHostViewInput::GetRootFrameSinkId() {
   return viz::FrameSinkId();
 }

 bool RenderWidgetHostViewInput::ScreenRectIsUnstableFor(
     const blink::WebInputEvent& event) {
   return false;
 }

 bool RenderWidgetHostViewInput::ScreenRectIsUnstableForIOv2For(
     const blink::WebInputEvent& event) {
   return false;
 }

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

 gfx::PointF RenderWidgetHostViewInput::TransformRootPointToViewCoordSpace(
     const gfx::PointF& point) {
   return point;
 }

 bool RenderWidgetHostViewInput::TransformPointToLocalCoordSpace(
     const gfx::PointF& point,
     const viz::FrameSinkId& original_frame_sink_id,
     gfx::PointF* transformed_point) {
   viz::FrameSinkId target_frame_sink_id = GetFrameSinkId();
   if (!original_frame_sink_id.is_valid() || !target_frame_sink_id.is_valid()) {
     return false;
   }
   if (original_frame_sink_id == target_frame_sink_id) {
     return true;
   }
   if (!GetViewRenderInputRouter() || !GetViewRenderInputRouter()->delegate()) {
     return false;
   }
   auto* router = GetViewRenderInputRouter()->delegate()->GetInputEventRouter();
   if (!router) {
     return false;
   }
   *transformed_point = point;
   return TransformPointToTargetCoordSpace(
       router->FindViewFromFrameSinkId(original_frame_sink_id),
       router->FindViewFromFrameSinkId(target_frame_sink_id), point,
       transformed_point);
 }

 bool RenderWidgetHostViewInput::TransformPointToCoordSpaceForView(
     const gfx::PointF& point,
     input::RenderWidgetHostViewInput* target_view,
     gfx::PointF* transformed_point) {
   NOTREACHED();
 }

 bool RenderWidgetHostViewInput::GetTransformToViewCoordSpace(
     input::RenderWidgetHostViewInput* target_view,
     gfx::Transform* transform) {
   CHECK(transform);
   if (target_view == this) {
     transform->MakeIdentity();
     return true;
   }

   viz::FrameSinkId root_frame_sink_id = GetRootFrameSinkId();
   if (!root_frame_sink_id.is_valid()) {
     return false;
   }

   const auto& display_hit_test_query_map = GetDisplayHitTestQuery();
   const auto iter = display_hit_test_query_map.find(root_frame_sink_id);
   if (iter == display_hit_test_query_map.end()) {
     return false;
   }
   viz::HitTestQuery* query = iter->second.get();

   gfx::Transform transform_this_to_root;
   if (GetFrameSinkId() != root_frame_sink_id) {
     gfx::Transform transform_root_to_this;
     if (!query->GetTransformToTarget(GetFrameSinkId(),
                                      &transform_root_to_this)) {
       return false;
     }
     if (!transform_root_to_this.GetInverse(&transform_this_to_root)) {
       return false;
     }
   }
   gfx::Transform transform_root_to_target;
   if (!query->GetTransformToTarget(target_view->GetFrameSinkId(),
                                    &transform_root_to_target)) {
     return false;
   }

   // TODO(wjmaclean): In TransformPointToTargetCoordSpace the device scale
   // factor is taken from the original view ... does that matter? Presumably
   // all the views have the same dsf.
   float device_scale_factor = GetDeviceScaleFactor();
   gfx::Transform transform_to_pixel;
   transform_to_pixel.Scale(device_scale_factor, device_scale_factor);
   gfx::Transform transform_from_pixel;
   transform_from_pixel.Scale(1.f / device_scale_factor,
                              1.f / device_scale_factor);

   // Note: gfx::Transform includes optimizations to early-out for scale = 1 or
   // concatenating an identity matrix, so we don't add those checks here.
   transform->MakeIdentity();

   transform->PostConcat(transform_to_pixel);
   transform->PostConcat(transform_this_to_root);
   transform->PostConcat(transform_root_to_target);
   transform->PostConcat(transform_from_pixel);

   return true;
 }

 input::RenderWidgetHostViewInput*
 RenderWidgetHostViewInput::GetParentViewInput() {
   return nullptr;
 }

 blink::mojom::InputEventResultState RenderWidgetHostViewInput::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
   // By default, input events are simply forwarded to the renderer.
   return blink::mojom::InputEventResultState::kNotConsumed;
 }

 void RenderWidgetHostViewInput::WheelEventAck(
     const blink::WebMouseWheelEvent& event,
     blink::mojom::InputEventResultState ack_result) {}

 void RenderWidgetHostViewInput::GestureEventAck(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultSource ack_source,
     blink::mojom::InputEventResultState ack_result) {}

 void RenderWidgetHostViewInput::ChildDidAckGestureEvent(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {}

 void RenderWidgetHostViewInput::DisplayCursor(const ui::Cursor& cursor) {
   return;
 }

 input::CursorManager* RenderWidgetHostViewInput::GetCursorManager() {
   return nullptr;
 }

 void RenderWidgetHostViewInput::TransformPointToRootSurface(
     gfx::PointF* point) {
   return;
 }

 int RenderWidgetHostViewInput::GetMouseWheelMinimumGranularity() const {
   // Most platforms can specify the floating-point delta in the wheel event so
   // they don't have a minimum granularity. Android is currently the only
   // platform that overrides this.
   return 0;
 }

 void RenderWidgetHostViewInput::AddObserver(
     input::RenderWidgetHostViewInputObserver* observer) {
   observers_.AddObserver(observer);
 }

 void RenderWidgetHostViewInput::RemoveObserver(
     input::RenderWidgetHostViewInputObserver* observer) {
   observers_.RemoveObserver(observer);
 }

 void RenderWidgetHostViewInput::StopFling() {
   if (!GetViewRenderInputRouter()) {
     return;
   }

   GetViewRenderInputRouter()->StopFling();

   // In case of scroll bubbling tells the child's fling controller which is in
   // charge of generating GSUs to stop flinging.
   if (GetViewRenderInputRouter()->delegate() &&
       GetViewRenderInputRouter()->delegate()->GetInputEventRouter()) {
     GetViewRenderInputRouter()->delegate()->GetInputEventRouter()->StopFling();
   }
 }

 void RenderWidgetHostViewInput::StopFlingingIfNecessary(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   // Reset view_stopped_flinging_for_test_ at the beginning of the scroll
   // sequence.
   if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
     view_stopped_flinging_for_test_ = false;
   }

   bool processed = blink::mojom::InputEventResultState::kConsumed == ack_result;
   if (!processed &&
       event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate &&
       event.data.scroll_update.inertial_phase ==
           blink::WebGestureEvent::InertialPhaseState::kMomentum &&
       event.SourceDevice() != blink::WebGestureDevice::kSyntheticAutoscroll) {
     StopFling();
     view_stopped_flinging_for_test_ = true;
   }
 }

 void RenderWidgetHostViewInput::ForwardTouchpadZoomEventIfNecessary(
     const blink::WebGestureEvent& event,
     blink::mojom::InputEventResultState ack_result) {
   if (!event.IsTouchpadZoomEvent()) {
     return;
   }
   if (!event.NeedsWheelEvent()) {
     return;
   }

   switch (event.GetType()) {
     case blink::WebInputEvent::Type::kGesturePinchBegin:
       // Don't send the begin event until we get the first unconsumed update, so
       // that we elide pinch gesture steams consisting of only a begin and end.
       pending_touchpad_pinch_begin_ = event;
       pending_touchpad_pinch_begin_->SetNeedsWheelEvent(false);
       break;
     case blink::WebInputEvent::Type::kGesturePinchUpdate:
       if (ack_result != blink::mojom::InputEventResultState::kConsumed &&
           !event.data.pinch_update.zoom_disabled) {
         if (pending_touchpad_pinch_begin_) {
           GetViewRenderInputRouter()->ForwardGestureEvent(
               *pending_touchpad_pinch_begin_);
           pending_touchpad_pinch_begin_.reset();
         }
         // Now that the synthetic wheel event has gone unconsumed, we have the
         // pinch event actually change the page scale.
         blink::WebGestureEvent pinch_event(event);
         pinch_event.SetNeedsWheelEvent(false);
         GetViewRenderInputRouter()->ForwardGestureEvent(pinch_event);
       }
       break;
     case blink::WebInputEvent::Type::kGesturePinchEnd:
       if (pending_touchpad_pinch_begin_) {
         pending_touchpad_pinch_begin_.reset();
       } else {
         blink::WebGestureEvent pinch_end_event(event);
         pinch_end_event.SetNeedsWheelEvent(false);
         GetViewRenderInputRouter()->ForwardGestureEvent(pinch_end_event);
       }
       break;
     case blink::WebInputEvent::Type::kGestureDoubleTap:
       if (ack_result != blink::mojom::InputEventResultState::kConsumed) {
         blink::WebGestureEvent double_tap(event);
         double_tap.SetNeedsWheelEvent(false);
         // TODO(mcnee): Support double-tap zoom gesture for OOPIFs. For now,
         // we naively send this to the main frame. If this is over an OOPIF,
         // then the iframe element will incorrectly be used for the scale
         // calculation rather than the element in the OOPIF.
         // https://crbug.com/758348
         GetViewRenderInputRouter()->ForwardGestureEvent(double_tap);
       }
       break;
     default:
       NOTREACHED();
   }
 }

 // TODO(wjmaclean): Would it simplify this function if we re-implemented it
 // using GetTransformToViewCoordSpace()?
 bool RenderWidgetHostViewInput::TransformPointToTargetCoordSpace(
     input::RenderWidgetHostViewInput* original_view,
     input::RenderWidgetHostViewInput* target_view,
     const gfx::PointF& point,
     gfx::PointF* transformed_point) const {
   CHECK(original_view);
   CHECK(target_view);
   viz::FrameSinkId root_frame_sink_id = original_view->GetRootFrameSinkId();
   if (!root_frame_sink_id.is_valid()) {
     return false;
   }
   const auto& display_hit_test_query_map = GetDisplayHitTestQuery();
   const auto iter = display_hit_test_query_map.find(root_frame_sink_id);
   if (iter == display_hit_test_query_map.end()) {
     return false;
   }
   viz::HitTestQuery* query = iter->second.get();

   std::vector<viz::FrameSinkId> target_ancestors;
   target_ancestors.push_back(target_view->GetFrameSinkId());

   input::RenderWidgetHostViewInput* cur_view = target_view;
   while (cur_view->GetParentViewInput()) {
     cur_view = cur_view->GetParentViewInput();
     if (!cur_view) {
       return false;
     }
     target_ancestors.push_back(cur_view->GetFrameSinkId());
   }
   if (target_ancestors.back() != root_frame_sink_id) {
     target_ancestors.push_back(root_frame_sink_id);
   }

   float device_scale_factor = original_view->GetDeviceScaleFactor();
   CHECK_GT(device_scale_factor, 0.0f);
   // TODO(crbug.com/41460959): Optimize so that |point_in_pixels| doesn't need
   // to be in the coordinate space of the root surface in HitTestQuery.
   gfx::Transform transform_root_to_original;
   query->GetTransformToTarget(original_view->GetFrameSinkId(),
                               &transform_root_to_original);
   const std::optional<gfx::PointF> point_in_pixels =
       transform_root_to_original.InverseMapPoint(
           gfx::ConvertPointToPixels(point, device_scale_factor));
   if (!point_in_pixels.has_value()) {
     return false;
   }
   gfx::PointF transformed_point_in_physical_pixels;
   if (!query->TransformLocationForTarget(
           target_ancestors, *point_in_pixels,
           &transformed_point_in_physical_pixels)) {
     return false;
   }
   *transformed_point = gfx::ConvertPointToDips(
       transformed_point_in_physical_pixels, device_scale_factor);
   return true;
 }

 }  // 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/render_widget_host_view_input.h"

	#include "base/notreached.h"
	#include "components/input/render_widget_host_input_event_router.h"
	#include "ui/gfx/geometry/dip_util.h"

	namespace input {

	RenderWidgetHostViewInput::RenderWidgetHostViewInput() = default;
	RenderWidgetHostViewInput::~RenderWidgetHostViewInput() = default;

	void RenderWidgetHostViewInput::NotifyObserversAboutShutdown() {
	// Note: RenderWidgetHostInputEventRouter is an observer, and uses the
	// following notification to remove this view from its surface owners map.
	for (auto& observer : observers_) {
	observer.OnRenderWidgetHostViewInputDestroyed(this);
	}
	// All observers are required to disconnect after they are notified.
	CHECK(observers_.empty());
	}

	void RenderWidgetHostViewInput::ProcessAckedTouchEvent(
	const input::TouchEventWithLatencyInfo& touch,
	blink::mojom::InputEventResultState ack_result) {
	DUMP_WILL_BE_NOTREACHED();
	}

	viz::FrameSinkId RenderWidgetHostViewInput::GetRootFrameSinkId() {
	return viz::FrameSinkId();
	}

	bool RenderWidgetHostViewInput::ScreenRectIsUnstableFor(
	const blink::WebInputEvent& event) {
	return false;
	}

	bool RenderWidgetHostViewInput::ScreenRectIsUnstableForIOv2For(
	const blink::WebInputEvent& event) {
	return false;
	}

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

	gfx::PointF RenderWidgetHostViewInput::TransformRootPointToViewCoordSpace(
	const gfx::PointF& point) {
	return point;
	}

	bool RenderWidgetHostViewInput::TransformPointToLocalCoordSpace(
	const gfx::PointF& point,
	const viz::FrameSinkId& original_frame_sink_id,
	gfx::PointF* transformed_point) {
	viz::FrameSinkId target_frame_sink_id = GetFrameSinkId();
	if (!original_frame_sink_id.is_valid() \|\| !target_frame_sink_id.is_valid()) {
	return false;
	}
	if (original_frame_sink_id == target_frame_sink_id) {
	return true;
	}
	if (!GetViewRenderInputRouter() \|\| !GetViewRenderInputRouter()->delegate()) {
	return false;
	}
	auto* router = GetViewRenderInputRouter()->delegate()->GetInputEventRouter();
	if (!router) {
	return false;
	}
	*transformed_point = point;
	return TransformPointToTargetCoordSpace(
	router->FindViewFromFrameSinkId(original_frame_sink_id),
	router->FindViewFromFrameSinkId(target_frame_sink_id), point,
	transformed_point);
	}

	bool RenderWidgetHostViewInput::TransformPointToCoordSpaceForView(
	const gfx::PointF& point,
	input::RenderWidgetHostViewInput* target_view,
	gfx::PointF* transformed_point) {
	NOTREACHED();
	}

	bool RenderWidgetHostViewInput::GetTransformToViewCoordSpace(
	input::RenderWidgetHostViewInput* target_view,
	gfx::Transform* transform) {
	CHECK(transform);
	if (target_view == this) {
	transform->MakeIdentity();
	return true;
	}

	viz::FrameSinkId root_frame_sink_id = GetRootFrameSinkId();
	if (!root_frame_sink_id.is_valid()) {
	return false;
	}

	const auto& display_hit_test_query_map = GetDisplayHitTestQuery();
	const auto iter = display_hit_test_query_map.find(root_frame_sink_id);
	if (iter == display_hit_test_query_map.end()) {
	return false;
	}
	viz::HitTestQuery* query = iter->second.get();

	gfx::Transform transform_this_to_root;
	if (GetFrameSinkId() != root_frame_sink_id) {
	gfx::Transform transform_root_to_this;
	if (!query->GetTransformToTarget(GetFrameSinkId(),
	&transform_root_to_this)) {
	return false;
	}
	if (!transform_root_to_this.GetInverse(&transform_this_to_root)) {
	return false;
	}
	}
	gfx::Transform transform_root_to_target;
	if (!query->GetTransformToTarget(target_view->GetFrameSinkId(),
	&transform_root_to_target)) {
	return false;
	}

	// TODO(wjmaclean): In TransformPointToTargetCoordSpace the device scale
	// factor is taken from the original view ... does that matter? Presumably
	// all the views have the same dsf.
	float device_scale_factor = GetDeviceScaleFactor();
	gfx::Transform transform_to_pixel;
	transform_to_pixel.Scale(device_scale_factor, device_scale_factor);
	gfx::Transform transform_from_pixel;
	transform_from_pixel.Scale(1.f / device_scale_factor,
	1.f / device_scale_factor);

	// Note: gfx::Transform includes optimizations to early-out for scale = 1 or
	// concatenating an identity matrix, so we don't add those checks here.
	transform->MakeIdentity();

	transform->PostConcat(transform_to_pixel);
	transform->PostConcat(transform_this_to_root);
	transform->PostConcat(transform_root_to_target);
	transform->PostConcat(transform_from_pixel);

	return true;
	}

	input::RenderWidgetHostViewInput*
	RenderWidgetHostViewInput::GetParentViewInput() {
	return nullptr;
	}

	blink::mojom::InputEventResultState RenderWidgetHostViewInput::FilterInputEvent(
	const blink::WebInputEvent& input_event) {
	// By default, input events are simply forwarded to the renderer.
	return blink::mojom::InputEventResultState::kNotConsumed;
	}

	void RenderWidgetHostViewInput::WheelEventAck(
	const blink::WebMouseWheelEvent& event,
	blink::mojom::InputEventResultState ack_result) {}

	void RenderWidgetHostViewInput::GestureEventAck(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultSource ack_source,
	blink::mojom::InputEventResultState ack_result) {}

	void RenderWidgetHostViewInput::ChildDidAckGestureEvent(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {}

	void RenderWidgetHostViewInput::DisplayCursor(const ui::Cursor& cursor) {
	return;
	}

	input::CursorManager* RenderWidgetHostViewInput::GetCursorManager() {
	return nullptr;
	}

	void RenderWidgetHostViewInput::TransformPointToRootSurface(
	gfx::PointF* point) {
	return;
	}

	int RenderWidgetHostViewInput::GetMouseWheelMinimumGranularity() const {
	// Most platforms can specify the floating-point delta in the wheel event so
	// they don't have a minimum granularity. Android is currently the only
	// platform that overrides this.
	return 0;
	}

	void RenderWidgetHostViewInput::AddObserver(
	input::RenderWidgetHostViewInputObserver* observer) {
	observers_.AddObserver(observer);
	}

	void RenderWidgetHostViewInput::RemoveObserver(
	input::RenderWidgetHostViewInputObserver* observer) {
	observers_.RemoveObserver(observer);
	}

	void RenderWidgetHostViewInput::StopFling() {
	if (!GetViewRenderInputRouter()) {
	return;
	}

	GetViewRenderInputRouter()->StopFling();

	// In case of scroll bubbling tells the child's fling controller which is in
	// charge of generating GSUs to stop flinging.
	if (GetViewRenderInputRouter()->delegate() &&
	GetViewRenderInputRouter()->delegate()->GetInputEventRouter()) {
	GetViewRenderInputRouter()->delegate()->GetInputEventRouter()->StopFling();
	}
	}

	void RenderWidgetHostViewInput::StopFlingingIfNecessary(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {
	// Reset view_stopped_flinging_for_test_ at the beginning of the scroll
	// sequence.
	if (event.GetType() == blink::WebInputEvent::Type::kGestureScrollBegin) {
	view_stopped_flinging_for_test_ = false;
	}

	bool processed = blink::mojom::InputEventResultState::kConsumed == ack_result;
	if (!processed &&
	event.GetType() == blink::WebInputEvent::Type::kGestureScrollUpdate &&
	event.data.scroll_update.inertial_phase ==
	blink::WebGestureEvent::InertialPhaseState::kMomentum &&
	event.SourceDevice() != blink::WebGestureDevice::kSyntheticAutoscroll) {
	StopFling();
	view_stopped_flinging_for_test_ = true;
	}
	}

	void RenderWidgetHostViewInput::ForwardTouchpadZoomEventIfNecessary(
	const blink::WebGestureEvent& event,
	blink::mojom::InputEventResultState ack_result) {
	if (!event.IsTouchpadZoomEvent()) {
	return;
	}
	if (!event.NeedsWheelEvent()) {
	return;
	}

	switch (event.GetType()) {
	case blink::WebInputEvent::Type::kGesturePinchBegin:
	// Don't send the begin event until we get the first unconsumed update, so
	// that we elide pinch gesture steams consisting of only a begin and end.
	pending_touchpad_pinch_begin_ = event;
	pending_touchpad_pinch_begin_->SetNeedsWheelEvent(false);
	break;
	case blink::WebInputEvent::Type::kGesturePinchUpdate:
	if (ack_result != blink::mojom::InputEventResultState::kConsumed &&
	!event.data.pinch_update.zoom_disabled) {
	if (pending_touchpad_pinch_begin_) {
	GetViewRenderInputRouter()->ForwardGestureEvent(
	*pending_touchpad_pinch_begin_);
	pending_touchpad_pinch_begin_.reset();
	}
	// Now that the synthetic wheel event has gone unconsumed, we have the
	// pinch event actually change the page scale.
	blink::WebGestureEvent pinch_event(event);
	pinch_event.SetNeedsWheelEvent(false);
	GetViewRenderInputRouter()->ForwardGestureEvent(pinch_event);
	}
	break;
	case blink::WebInputEvent::Type::kGesturePinchEnd:
	if (pending_touchpad_pinch_begin_) {
	pending_touchpad_pinch_begin_.reset();
	} else {
	blink::WebGestureEvent pinch_end_event(event);
	pinch_end_event.SetNeedsWheelEvent(false);
	GetViewRenderInputRouter()->ForwardGestureEvent(pinch_end_event);
	}
	break;
	case blink::WebInputEvent::Type::kGestureDoubleTap:
	if (ack_result != blink::mojom::InputEventResultState::kConsumed) {
	blink::WebGestureEvent double_tap(event);
	double_tap.SetNeedsWheelEvent(false);
	// TODO(mcnee): Support double-tap zoom gesture for OOPIFs. For now,
	// we naively send this to the main frame. If this is over an OOPIF,
	// then the iframe element will incorrectly be used for the scale
	// calculation rather than the element in the OOPIF.
	// https://crbug.com/758348
	GetViewRenderInputRouter()->ForwardGestureEvent(double_tap);
	}
	break;
	default:
	NOTREACHED();
	}
	}

	// TODO(wjmaclean): Would it simplify this function if we re-implemented it
	// using GetTransformToViewCoordSpace()?
	bool RenderWidgetHostViewInput::TransformPointToTargetCoordSpace(
	input::RenderWidgetHostViewInput* original_view,
	input::RenderWidgetHostViewInput* target_view,
	const gfx::PointF& point,
	gfx::PointF* transformed_point) const {
	CHECK(original_view);
	CHECK(target_view);
	viz::FrameSinkId root_frame_sink_id = original_view->GetRootFrameSinkId();
	if (!root_frame_sink_id.is_valid()) {
	return false;
	}
	const auto& display_hit_test_query_map = GetDisplayHitTestQuery();
	const auto iter = display_hit_test_query_map.find(root_frame_sink_id);
	if (iter == display_hit_test_query_map.end()) {
	return false;
	}
	viz::HitTestQuery* query = iter->second.get();

	std::vector<viz::FrameSinkId> target_ancestors;
	target_ancestors.push_back(target_view->GetFrameSinkId());

	input::RenderWidgetHostViewInput* cur_view = target_view;
	while (cur_view->GetParentViewInput()) {
	cur_view = cur_view->GetParentViewInput();
	if (!cur_view) {
	return false;
	}
	target_ancestors.push_back(cur_view->GetFrameSinkId());
	}
	if (target_ancestors.back() != root_frame_sink_id) {
	target_ancestors.push_back(root_frame_sink_id);
	}

	float device_scale_factor = original_view->GetDeviceScaleFactor();
	CHECK_GT(device_scale_factor, 0.0f);
	// TODO(crbug.com/41460959): Optimize so that \|point_in_pixels\| doesn't need
	// to be in the coordinate space of the root surface in HitTestQuery.
	gfx::Transform transform_root_to_original;
	query->GetTransformToTarget(original_view->GetFrameSinkId(),
	&transform_root_to_original);
	const std::optional<gfx::PointF> point_in_pixels =
	transform_root_to_original.InverseMapPoint(
	gfx::ConvertPointToPixels(point, device_scale_factor));
	if (!point_in_pixels.has_value()) {
	return false;
	}
	gfx::PointF transformed_point_in_physical_pixels;
	if (!query->TransformLocationForTarget(
	target_ancestors, *point_in_pixels,
	&transformed_point_in_physical_pixels)) {
	return false;
	}
	*transformed_point = gfx::ConvertPointToDips(
	transformed_point_in_physical_pixels, device_scale_factor);
	return true;
	}

	} // namespace input