Delegate delegated ink trails to RWHI from RWHIER.

Delegates forwarding pointer events to viz for use in a delegated ink
trail to RWHI from RWHIER since the implementation in viz doesn't need
to use mojo and hence would need to be implemented differently. This
change is required to remove the dependency of
RenderWidgetHostInputEventRouter on RenderWidgetHostViewBase.

Doc Link:
https://docs.google.com/document/d/1dgbvnRChsvfMpXceQ24UbTdFwJpmk5VIl7WXHwExAC4/edit?tab=t.0#heading=h.7wb78gd5w8i0

Bug: b:330555923
Change-Id: I83dd4d9fd07056fa5e12ed2ea61ac22f792f18d4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5453438
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Reviewed-by: Jonathan Ross <jonross@chromium.org>
Commit-Queue: Aman Verma <amanvr@google.com>
Cr-Commit-Position: refs/heads/main@{#1297560}

content/browser/renderer_host/render_widget_host_delegate.cc

@@ -149,6 +149,11 @@ bool RenderWidgetHostDelegate::IsWidgetForPrimaryMainFrame(
   return false;
 }
 
+gfx::mojom::DelegatedInkPointRenderer*
+RenderWidgetHostDelegate::GetDelegatedInkRenderer(ui::Compositor* compositor) {
+  return nullptr;
+}
+
 ukm::SourceId RenderWidgetHostDelegate::GetCurrentPageUkmSourceId() {
   return ukm::kInvalidSourceId;
 }

content/browser/renderer_host/render_widget_host_delegate.h

@@ -24,6 +24,7 @@
 #include "third_party/blink/public/mojom/input/input_handler.mojom-shared.h"
 #include "third_party/blink/public/mojom/manifest/display_mode.mojom.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/gfx/mojom/delegated_ink_point_renderer.mojom.h"
 #include "ui/gfx/native_widget_types.h"
 
 namespace blink {
@@ -38,6 +39,10 @@ class Rect;
 class Size;
 }  // namespace gfx
 
+namespace ui {
+class Compositor;
+}  // namespace ui
+
 namespace content {
 
 class BrowserAccessibilityManager;
@@ -285,6 +290,13 @@ class CONTENT_EXPORT RenderWidgetHostDelegate {
   // the WebContents.
   virtual VisibleTimeRequestTrigger& GetVisibleTimeRequestTrigger() = 0;
 
+  // Returns the delegated ink point renderer associated with this WebContents
+  // for dispatching delegated ink points to viz. This also attempts to setup
+  // mojo connection using |compositor|, if the DelegatedInkPointRenderer
+  // interface is not bound.
+  virtual gfx::mojom::DelegatedInkPointRenderer* GetDelegatedInkRenderer(
+      ui::Compositor* compositor);
+
   // Inner WebContents Helpers -------------------------------------------------
   //
   // These functions are helpers in managing a hierarchy of WebContents

content/browser/renderer_host/render_widget_host_impl.cc

@@ -127,6 +127,7 @@
 #include "ui/base/ime/mojom/text_input_state.mojom.h"
 #include "ui/base/ui_base_features.h"
 #include "ui/base/ui_base_switches.h"
+#include "ui/compositor/compositor.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/display_util.h"
 #include "ui/display/screen.h"
@@ -2534,6 +2535,51 @@ RenderWidgetHostViewInput* RenderWidgetHostImpl::GetPointerLockView() {
   return delegate()->GetPointerLockWidget()->GetView();
 }
 
+void RenderWidgetHostImpl::ForwardDelegatedInkPoint(
+    gfx::DelegatedInkPoint& delegated_ink_point,
+    bool& ended_delegated_ink_trail) {
+  if (!view_) {
+    return;
+  }
+
+  auto* delegated_ink_point_renderer =
+      delegate_->GetDelegatedInkRenderer(view_->GetCompositor());
+  if (!delegated_ink_point_renderer) {
+    return;
+  }
+
+  TRACE_EVENT_WITH_FLOW1("delegated_ink_trails",
+                         "Forwarding delegated ink point from browser.",
+                         TRACE_ID_GLOBAL(delegated_ink_point.trace_id()),
+                         TRACE_EVENT_FLAG_FLOW_OUT, "delegated point",
+                         delegated_ink_point.ToString());
+
+  // Calling this will result in IPC calls to get |delegated_ink_point| to
+  // viz. The decision to do this here was made with the understanding that
+  // the IPC overhead will result in a minor increase in latency for getting
+  // this event to the renderer. However, by sending it here, the event is
+  // given the greatest possible chance to make it to viz before
+  // DrawAndSwap() is called, allowing more points to be drawn as part of
+  // the delegated ink trail, and thus reducing user perceived latency.
+  delegated_ink_point_renderer->StoreDelegatedInkPoint(delegated_ink_point);
+  ended_delegated_ink_trail = false;
+}
+
+void RenderWidgetHostImpl::ResetDelegatedInkPointPrediction(
+    bool& ended_delegated_ink_trail) {
+  auto* delegated_ink_point_renderer =
+      delegate_->GetDelegatedInkRenderer(nullptr);
+  if (delegated_ink_point_renderer && !ended_delegated_ink_trail) {
+    // Let viz know that the most recent point it received from us is probably
+    // the last point the user is inking, so it shouldn't predict anything
+    // beyond it.
+    TRACE_EVENT_INSTANT0("delegated_ink_trails", "Delegated ink trail ended",
+                         TRACE_EVENT_SCOPE_THREAD);
+    delegated_ink_point_renderer->ResetPrediction();
+    ended_delegated_ink_trail = true;
+  }
+}
+
 const cc::RenderFrameMetadata&
 RenderWidgetHostImpl::GetLastRenderFrameMetadata() {
   return render_frame_metadata_provider()->LastRenderFrameMetadata();

content/browser/renderer_host/render_widget_host_impl.h

@@ -359,6 +359,10 @@ class CONTENT_EXPORT RenderWidgetHostImpl
   const cc::RenderFrameMetadata& GetLastRenderFrameMetadata() override;
   std::unique_ptr<RenderInputRouterIterator> GetEmbeddedRenderInputRouters()
       override;
+  void ForwardDelegatedInkPoint(gfx::DelegatedInkPoint& delegated_ink_point,
+                                bool& ended_delegated_ink_trail) override;
+  void ResetDelegatedInkPointPrediction(
+      bool& ended_delegated_ink_trail) override;
 
   // Update the stored set of visual properties for the renderer. If 'propagate'
   // is true, the new properties will be sent to the renderer process.

content/browser/renderer_host/render_widget_host_input_event_router.cc

@@ -2051,53 +2051,21 @@ void RenderWidgetHostInputEventRouter::ForwardDelegatedInkPoint(
 
   if (IsMoveEvent(input_event.GetTypeAsUiEventType()) && metadata &&
       hovering == metadata.value().delegated_ink_is_hovering) {
-    if (!delegated_ink_point_renderer_.is_bound()) {
-      ui::Compositor* compositor =
-          static_cast<RenderWidgetHostViewBase*>(target_view)->GetCompositor();
-
-      // The remote can't be bound if the compositor is null, so bail if that
-      // is the case so we don't crash by trying to use an unbound remote.
-      if (!compositor)
-        return;
-
-      TRACE_EVENT_INSTANT0("delegated_ink_trails",
-                           "Binding mojo interface for delegated ink points.",
-                           TRACE_EVENT_SCOPE_THREAD);
-      compositor->SetDelegatedInkPointRenderer(
-          delegated_ink_point_renderer_.BindNewPipeAndPassReceiver());
-      delegated_ink_point_renderer_.reset_on_disconnect();
-    }
-
     gfx::PointF position = pointer_properties.PositionInWidget();
     root_view->TransformPointToRootSurface(&position);
     position.Scale(target_view->GetDeviceScaleFactor());
 
     gfx::DelegatedInkPoint delegated_ink_point(
         position, input_event.TimeStamp(), pointer_properties.id);
-    TRACE_EVENT_WITH_FLOW1("delegated_ink_trails",
-                           "Forwarding delegated ink point from browser.",
-                           TRACE_ID_GLOBAL(delegated_ink_point.trace_id()),
-                           TRACE_EVENT_FLAG_FLOW_OUT, "delegated point",
-                           delegated_ink_point.ToString());
 
-    // Calling this will result in IPC calls to get |delegated_ink_point| to
-    // viz. The decision to do this here was made with the understanding that
-    // the IPC overhead will result in a minor increase in latency for getting
-    // this event to the renderer. However, by sending it here, the event is
-    // given the greatest possible chance to make it to viz before
-    // DrawAndSwap() is called, allowing more points to be drawn as part of
-    // the delegated ink trail, and thus reducing user perceived latency.
-    delegated_ink_point_renderer_->StoreDelegatedInkPoint(delegated_ink_point);
-    ended_delegated_ink_trail_ = false;
-  } else if (delegated_ink_point_renderer_.is_bound() &&
-             !ended_delegated_ink_trail_) {
-    // Let viz know that the most recent point it received from us is probably
-    // the last point the user is inking, so it shouldn't predict anything
-    // beyond it.
-    TRACE_EVENT_INSTANT0("delegated_ink_trails", "Delegated ink trail ended",
-                         TRACE_EVENT_SCOPE_THREAD);
-    delegated_ink_point_renderer_->ResetPrediction();
-    ended_delegated_ink_trail_ = true;
+    target_view->GetViewRenderInputRouter()
+        ->delegate()
+        ->ForwardDelegatedInkPoint(delegated_ink_point,
+                                   ended_delegated_ink_trail_);
+  } else {
+    target_view->GetViewRenderInputRouter()
+        ->delegate()
+        ->ResetDelegatedInkPointPrediction(ended_delegated_ink_trail_);
   }
 }
 

content/browser/renderer_host/render_widget_host_input_event_router.h

@@ -355,11 +355,6 @@ class CONTENT_EXPORT RenderWidgetHostInputEventRouter final
       const blink::WebPointerProperties& pointer_properties,
       bool hovering);
 
-  void FlushForTest() { delegated_ink_point_renderer_.FlushForTesting(); }
-  bool IsDelegatedInkRendererBoundForTest() {
-    return delegated_ink_point_renderer_.is_bound();
-  }
-
   FrameSinkIdOwnerMap owner_map_;
   TargetMap touchscreen_gesture_target_map_;
   // This field is not a raw_ptr<> because of a reference to raw_ptr in
@@ -472,10 +467,6 @@ class CONTENT_EXPORT RenderWidgetHostInputEventRouter final
   mutable gfx::PointF mouse_down_post_transformed_coordinate_;
   raw_ptr<RenderWidgetHostViewInput> last_mouse_down_target_ = nullptr;
 
-  // Remote end of the connection for sending delegated ink points to viz to
-  // support the delegated ink trails feature.
-  mojo::Remote<gfx::mojom::DelegatedInkPointRenderer>
-      delegated_ink_point_renderer_;
   // Used to know if we have already told viz to reset prediction because the
   // final point of the delegated ink trail has been sent. True when prediction
   // has already been reset for the most recent trail, false otherwise. This

content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc

@@ -332,7 +332,7 @@ class RenderWidgetHostInputEventRouterTest : public testing::Test {
       RenderWidgetHostViewBase* gesture_target,
       bool should_cancel);
 
-  void FlushInkRenderer() { rwhier()->FlushForTest(); }
+  void FlushInkRenderer() { delegate_->FlushInkRenderer(); }
 
   BrowserTaskEnvironment task_environment_;
 

content/browser/site_per_process_hit_test_browsertest.cc

@@ -7466,7 +7466,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessDelegatedInkBrowserTest,
   RenderWidgetHostInputEventRouter* router =
       web_contents()->GetInputEventRouter();
 
-  EXPECT_FALSE(router->IsDelegatedInkRendererBoundForTest());
+  EXPECT_FALSE(web_contents()->IsDelegatedInkRendererBoundForTest());
 
   // Target MouseMove to child frame.
   blink::WebMouseEvent mouse_event(
@@ -7509,7 +7509,7 @@ IN_PROC_BROWSER_TEST_F(SitePerProcessDelegatedInkBrowserTest,
 
   EXPECT_FALSE(main_frame_monitor.EventWasReceived());
   EXPECT_TRUE(child_frame_monitor.EventWasReceived());
-  EXPECT_TRUE(router->IsDelegatedInkRendererBoundForTest());
+  EXPECT_TRUE(web_contents()->IsDelegatedInkRendererBoundForTest());
 }
 #endif  // USE_AURA
 

content/browser/web_contents/web_contents_impl.cc

@@ -189,6 +189,7 @@
 #include "ui/color/color_provider_key.h"
 #include "ui/color/color_provider_manager.h"
 #include "ui/color/color_provider_utils.h"
+#include "ui/compositor/compositor.h"
 #include "ui/display/screen.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/events/base_event_utils.h"
@@ -10727,6 +10728,26 @@ VisibleTimeRequestTrigger& WebContentsImpl::GetVisibleTimeRequestTrigger() {
   return visible_time_request_trigger_;
 }
 
+gfx::mojom::DelegatedInkPointRenderer* WebContentsImpl::GetDelegatedInkRenderer(
+    ui::Compositor* compositor) {
+  if (!delegated_ink_point_renderer_.is_bound()) {
+    // The remote can't be bound if the compositor is null, so bail if
+    // that is the case so we don't crash by trying to use an unbound
+    // remote.
+    if (!compositor) {
+      return nullptr;
+    }
+
+    TRACE_EVENT_INSTANT0("delegated_ink_trails",
+                         "Binding mojo interface for delegated ink points.",
+                         TRACE_EVENT_SCOPE_THREAD);
+    compositor->SetDelegatedInkPointRenderer(
+        delegated_ink_point_renderer_.BindNewPipeAndPassReceiver());
+    delegated_ink_point_renderer_.reset_on_disconnect();
+  }
+  return delegated_ink_point_renderer_.get();
+}
+
 std::unique_ptr<PrerenderHandle> WebContentsImpl::StartPrerendering(
     const GURL& prerendering_url,
     PreloadingTriggerType trigger_type,

content/browser/web_contents/web_contents_impl.h

@@ -291,6 +291,10 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
   // Return RenderWidgetHostView from RWHIER.
   std::vector<RenderWidgetHostView*> GetRenderWidgetHostViewsForTests();
 
+  bool IsDelegatedInkRendererBoundForTest() {
+    return delegated_ink_point_renderer_.is_bound();
+  }
+
   // Adds the given accessibility mode to the current accessibility mode
   // bitmap.
   void AddAccessibilityModeForTesting(ui::AXMode mode);
@@ -1073,6 +1077,8 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
   void DidChangeScreenOrientation() override;
   gfx::Rect GetWindowsControlsOverlayRect() const override;
   VisibleTimeRequestTrigger& GetVisibleTimeRequestTrigger() final;
+  gfx::mojom::DelegatedInkPointRenderer* GetDelegatedInkRenderer(
+      ui::Compositor* compositor) override;
 
   // RenderFrameHostManager::Delegate ------------------------------------------
 
@@ -2118,6 +2124,11 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
   // presenting through tab capture APIs.
   mojo::Remote<device::mojom::WakeLock> capture_wake_lock_;
 
+  // Remote end of the connection for sending delegated ink points to viz to
+  // support the delegated ink trails feature.
+  mojo::Remote<gfx::mojom::DelegatedInkPointRenderer>
+      delegated_ink_point_renderer_;
+
   // The visibility of the WebContents. Initialized from
   // |CreateParams::initially_hidden|. Updated from
   // UpdateWebContentsVisibility(), WasShown(), WasHidden(), WasOccluded().

content/common/input/render_input_router_delegate.h

@@ -6,6 +6,7 @@
 #define CONTENT_COMMON_INPUT_RENDER_INPUT_ROUTER_DELEGATE_H_
 
 #include "cc/trees/render_frame_metadata.h"
+#include "ui/gfx/delegated_ink_point.h"
 
 namespace content {
 
@@ -23,6 +24,17 @@ class CONTENT_EXPORT RenderInputRouterDelegate {
 
   virtual std::unique_ptr<RenderInputRouterIterator>
   GetEmbeddedRenderInputRouters() = 0;
+
+  // Forwards |delegated_ink_point| to viz over IPC to be drawn as part of
+  // delegated ink trail, resetting the |ended_delegated_ink_trail| flag.
+  virtual void ForwardDelegatedInkPoint(
+      gfx::DelegatedInkPoint& delegated_ink_point,
+      bool& ended_delegated_ink_trail) = 0;
+  // Instructs viz to reset prediction for delegated ink trails, indicating that
+  // the trail has ended. Updates the |ended_delegated_ink_trail| flag to
+  // reflect this change.
+  virtual void ResetDelegatedInkPointPrediction(
+      bool& ended_delegated_ink_trail) = 0;
 };
 
 }  // namespace content

content/test/mock_render_widget_host_delegate.cc

@@ -10,6 +10,7 @@
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/common/input/native_web_keyboard_event.h"
+#include "ui/compositor/compositor.h"
 #include "ui/display/screen.h"
 
 namespace content {
@@ -84,4 +85,19 @@ MockRenderWidgetHostDelegate::GetVisibleTimeRequestTrigger() {
   return visible_time_request_trigger_;
 }
 
+gfx::mojom::DelegatedInkPointRenderer*
+MockRenderWidgetHostDelegate::GetDelegatedInkRenderer(
+    ui::Compositor* compositor) {
+  if (!delegated_ink_point_renderer_.is_bound()) {
+    if (!compositor) {
+      return nullptr;
+    }
+
+    compositor->SetDelegatedInkPointRenderer(
+        delegated_ink_point_renderer_.BindNewPipeAndPassReceiver());
+    delegated_ink_point_renderer_.reset_on_disconnect();
+  }
+  return delegated_ink_point_renderer_.get();
+}
+
 }  // namespace content

content/test/mock_render_widget_host_delegate.h

@@ -41,6 +41,8 @@ class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
   }
   void CreateInputEventRouter();
 
+  void FlushInkRenderer() { delegated_ink_point_renderer_.FlushForTesting(); }
+
   // RenderWidgetHostDelegate:
   void ResizeDueToAutoResize(RenderWidgetHostImpl* render_widget_host,
                              const gfx::Size& new_size) override;
@@ -63,11 +65,15 @@ class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
   bool IsFullscreen() override;
   RenderViewHostDelegateView* GetDelegateView() override;
   VisibleTimeRequestTrigger& GetVisibleTimeRequestTrigger() override;
+  gfx::mojom::DelegatedInkPointRenderer* GetDelegatedInkRenderer(
+      ui::Compositor* compositor) override;
 
  private:
   std::unique_ptr<NativeWebKeyboardEvent> last_event_;
   raw_ptr<RenderWidgetHostImpl, DanglingUntriaged> rwh_ = nullptr;
   std::unique_ptr<RenderWidgetHostInputEventRouter> rwh_input_event_router_;
+  mojo::Remote<gfx::mojom::DelegatedInkPointRenderer>
+      delegated_ink_point_renderer_;
   bool is_fullscreen_ = false;
   TextInputManager text_input_manager_;
   raw_ptr<RenderWidgetHostImpl, DanglingUntriaged> focused_widget_ = nullptr;