[InputVizard] Reset mojo connections on GPU restarts.

This CL does the following:

1. Adds disconnect handlers to
   RenderInputRouterDelegate/RenderInputRouterDelegateClient mojo
   interfaces between browser and GPU process to allow re-establishing
   these mojo connections when GPU crashes.

2. Modifies RenderInputRouterClient mojo connection setup between
   Viz-Renderer process. Moves RenderInputRouterClient mojo endpoint
   creation to the renderer. Browser forwards the PendingRemote to Viz
   using CreateCompositorFrameSink message. This takes care of GPU
   restarts since renderer requests creation of framesink when GPU
   crashes.

Bug: b:394865365
Change-Id: I12aca02dab000f9256aaf5337822174fbf87626c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6252837
Reviewed-by: Arthur Sonzogni <arthursonzogni@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Auto-Submit: Aman Verma <amanvr@google.com>
Commit-Queue: Aman Verma <amanvr@google.com>
Reviewed-by: Jonathan Ross <jonross@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1422079}

components/plugins/renderer/webview_plugin.h

@@ -203,7 +203,8 @@ class WebViewPlugin : public blink::WebPlugin, public blink::WebViewObserver {
     void CreateFrameSink(
         mojo::PendingReceiver<viz::mojom::CompositorFrameSink>
             compositor_frame_sink_receiver,
-        mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>) override {}
+        mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>,
+        mojo::PendingRemote<blink::mojom::RenderInputRouterClient>) override {}
     void RegisterRenderFrameMetadataObserver(
         mojo::PendingReceiver<cc::mojom::RenderFrameMetadataObserverClient>
             render_frame_metadata_observer_client_receiver,

components/viz/service/input/input_manager.cc

@@ -435,6 +435,8 @@ void InputManager::SetupRenderInputRouterDelegateConnection(
         rir_delegate_remote,
     mojo::PendingReceiver<input::mojom::RenderInputRouterDelegate>
         rir_delegate_receiver) {
+  TRACE_EVENT("viz", "InputManager::SetupRenderInputRouterDelegateConnection");
+
   rir_delegate_remote_map_[grouping_id].Bind(std::move(rir_delegate_remote));
   rir_delegate_remote_map_[grouping_id].set_disconnect_handler(
       base::BindOnce(&InputManager::OnRIRDelegateClientDisconnected,

content/browser/renderer_host/render_widget_host_impl.cc

@@ -741,15 +741,8 @@ void RenderWidgetHostImpl::RendererWidgetCreated(bool for_frame_widget) {
   renderer_widget_created_ = true;
 
   mojo::PendingRemote<blink::mojom::RenderInputRouterClient> browser_remote;
-  mojo::PendingReceiver<blink::mojom::RenderInputRouterClient> viz_receiver =
-      mojo::NullReceiver();
-  if (input::IsTransferInputToVizSupported()) {
-    mojo::PendingRemote<blink::mojom::RenderInputRouterClient> viz_remote;
-    viz_receiver = viz_remote.InitWithNewPipeAndPassReceiver();
-    viz_rir_client_remote_ = std::move(viz_remote);
-  }
-  blink_widget_->SetupRenderInputRouterConnections(
-      browser_remote.InitWithNewPipeAndPassReceiver(), std::move(viz_receiver));
+  blink_widget_->SetupBrowserRenderInputRouterConnections(
+      browser_remote.InitWithNewPipeAndPassReceiver());
 
   GetRenderInputRouter()->BindRenderInputRouterInterfaces(
       std::move(browser_remote));
@@ -3552,23 +3545,23 @@ void RenderWidgetHostImpl::CreateFrameSink(
     mojo::PendingReceiver<viz::mojom::CompositorFrameSink>
         compositor_frame_sink_receiver,
     mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>
-        compositor_frame_sink_client) {
+        compositor_frame_sink_client,
+    mojo::PendingRemote<blink::mojom::RenderInputRouterClient>
+        viz_rir_client_remote) {
   // Connects the viz process end of CompositorFrameSink message pipes. The
   // renderer compositor may request a new CompositorFrameSink on context
   // loss, which will destroy the existing CompositorFrameSink.
   create_frame_sink_callback_ = base::BindOnce(
       [](mojo::PendingReceiver<viz::mojom::CompositorFrameSink> receiver,
          mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient> client,
-         std::optional<mojo::PendingRemote<
-             blink::mojom::RenderInputRouterClient>> viz_rir_client_remote,
+         mojo::PendingRemote<blink::mojom::RenderInputRouterClient>
+             viz_rir_client_remote,
          bool force_enable_zoom, base::UnguessableToken grouping_id,
          const viz::FrameSinkId& frame_sink_id) {
         input::mojom::RenderInputRouterConfigPtr config;
         if (input::IsTransferInputToVizSupported()) {
-          DCHECK(viz_rir_client_remote.has_value());
-
           config = input::mojom::RenderInputRouterConfig::New();
-          config->rir_client = std::move(viz_rir_client_remote.value());
+          config->rir_client = std::move(viz_rir_client_remote);
           config->grouping_id = grouping_id;
           config->force_enable_zoom = force_enable_zoom;
         }
@@ -3577,8 +3570,7 @@ void RenderWidgetHostImpl::CreateFrameSink(
             std::move(config));
       },
       std::move(compositor_frame_sink_receiver),
-      std::move(compositor_frame_sink_client),
-      std::move(viz_rir_client_remote_),
+      std::move(compositor_frame_sink_client), std::move(viz_rir_client_remote),
       GetRenderInputRouter()->GetForceEnableZoom());
 
   MaybeDispatchBufferedFrameSinkRequest();

content/browser/renderer_host/render_widget_host_impl.h

@@ -342,7 +342,10 @@ class CONTENT_EXPORT RenderWidgetHostImpl
   void CreateFrameSink(
       mojo::PendingReceiver<viz::mojom::CompositorFrameSink>
           compositor_frame_sink_receiver,
-      mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>) override;
+      mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>
+          compositor_frame_sink_client,
+      mojo::PendingRemote<blink::mojom::RenderInputRouterClient>
+          viz_rir_client_remote) override;
   void RegisterRenderFrameMetadataObserver(
       mojo::PendingReceiver<cc::mojom::RenderFrameMetadataObserverClient>
           render_frame_metadata_observer_client_receiver,
@@ -1554,9 +1557,6 @@ class CONTENT_EXPORT RenderWidgetHostImpl
 
   std::unique_ptr<CompositorMetricRecorder> compositor_metric_recorder_;
 
-  std::optional<mojo::PendingRemote<blink::mojom::RenderInputRouterClient>>
-      viz_rir_client_remote_;
-
   base::WeakPtrFactory<RenderWidgetHostImpl> weak_factory_{this};
 };
 

content/browser/site_per_process_browsertest.cc

@@ -46,6 +46,7 @@
 #include "base/test/run_until.h"
 #include "base/test/test_future.h"
 #include "base/test/test_timeouts.h"
+#include "base/test/test_trace_processor.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "build/build_config.h"
@@ -60,6 +61,7 @@
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/gpu/compositor_util.h"
+#include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/process_lock.h"
 #include "content/browser/process_reuse_policy.h"
 #include "content/browser/renderer_host/agent_scheduling_group_host.h"
@@ -95,6 +97,8 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/context_menu_params.h"
 #include "content/public/browser/global_routing_id.h"
+#include "content/public/browser/gpu_data_manager_observer.h"
+#include "content/public/browser/gpu_utils.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_process_host_priority_client.h"
@@ -11688,6 +11692,77 @@ IN_PROC_BROWSER_TEST_P(AndroidInputBrowserTest, CheckForceEnableZoomValue) {
   EXPECT_TRUE(enabled);
 }
 
+class GpuInfoUpdateObserver : public GpuDataManagerObserver {
+ public:
+  explicit GpuInfoUpdateObserver(base::OnceClosure callback)
+      : callback_(std::move(callback)) {
+    observation_.Observe(GpuDataManager::GetInstance());
+  }
+  ~GpuInfoUpdateObserver() override = default;
+
+  void OnGpuInfoUpdate() override {
+    if (callback_) {
+      std::move(callback_).Run();
+    }
+  }
+
+ private:
+  base::OnceClosure callback_;
+  base::ScopedObservation<GpuDataManager, GpuDataManagerObserver> observation_{
+      this};
+};
+
+// Checks if RenderInputRouterDelegate mojo connection is reset when GPU process
+// restarts.
+IN_PROC_BROWSER_TEST_P(AndroidInputBrowserTest,
+                       RestartingGPUProcessResetsMojoConnection) {
+  RenderFrameSubmissionObserver render_frame_submission_observer(
+      web_contents());
+  EXPECT_TRUE(NavigateToURL(
+      shell(), embedded_test_server()->GetURL("foo.com", "/title1.html")));
+  if (render_frame_submission_observer.render_frame_count() == 0) {
+    render_frame_submission_observer.WaitForAnyFrameSubmission();
+  }
+
+  base::test::TestTraceProcessor ttp;
+  ttp.StartTrace("viz");
+
+  base::RunLoop run_loop;
+  // This observer is begin used here to signal if the GPU process has
+  // restarted.
+  GpuInfoUpdateObserver gpu_observer(run_loop.QuitClosure());
+
+  // Kill GPU process explicitly, this should trigger a restart.
+  KillGpuProcess();
+  run_loop.Run();
+
+  // Navigate to URL and wait for frame submission.
+  EXPECT_TRUE(NavigateToURL(
+      shell(), embedded_test_server()->GetURL("bar.com", "/title2.html")));
+  if (render_frame_submission_observer.render_frame_count() == 0) {
+    render_frame_submission_observer.WaitForAnyFrameSubmission();
+  }
+
+  absl::Status status = ttp.StopAndParseTrace();
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  std::string query = R"(
+    SELECT COUNT(*) AS cnt
+    FROM slice
+    WHERE name = 'InputManager::SetupRenderInputRouterDelegateConnection'
+    ORDER BY ts ASC
+  )";
+  auto result = ttp.RunQuery(query);
+  ASSERT_TRUE(result.has_value());
+
+  // `result.value()` would look something like this: {{"cnt"}, {"<num>"}}.
+  EXPECT_THAT(result.value(),
+              testing::ElementsAre(
+                  testing::ElementsAre("cnt"),
+                  testing::ElementsAre(
+                      input::IsTransferInputToVizSupported() ? "1" : "0")));
+}
+
 IN_PROC_BROWSER_TEST_P(SitePerProcessBrowserTouchActionTest,
                        ForceEnableZoomPropagatesToChild) {
   GURL main_url(embedded_test_server()->GetURL(

content/browser/web_contents/web_contents_impl.cc

@@ -1316,13 +1316,26 @@ WebContentsImpl::WebContentsImpl(BrowserContext* browser_context)
   }
 
   if (input::IsTransferInputToVizSupported()) {
-    GetHostFrameSinkManager()->SetupRenderInputRouterDelegateConnection(
-        compositor_frame_sink_grouping_id_,
-        rir_delegate_client_receiver_.BindNewPipeAndPassRemote(),
-        rir_delegate_remote_.BindNewPipeAndPassReceiver());
+    SetupRenderInputRouterDelegateConnection();
   }
 }
 
+void WebContentsImpl::SetupRenderInputRouterDelegateConnection() {
+  // Handles setting up GPU mojo endpoint connections. In general, the number of
+  // retries for setting up these mojo connections is capped by the maximum
+  // number of attempts to restart the GPU process, see
+  // GpuProcessHost::GetFallbackCrashLimit().
+  rir_delegate_client_receiver_.reset();
+  rir_delegate_remote_.reset();
+  GetHostFrameSinkManager()->SetupRenderInputRouterDelegateConnection(
+      compositor_frame_sink_grouping_id_,
+      rir_delegate_client_receiver_.BindNewPipeAndPassRemote(),
+      rir_delegate_remote_.BindNewPipeAndPassReceiver());
+  rir_delegate_client_receiver_.set_disconnect_handler(
+      base::BindOnce(&WebContentsImpl::SetupRenderInputRouterDelegateConnection,
+                     weak_factory_.GetWeakPtr()));
+}
+
 WebContentsImpl::~WebContentsImpl() {
   TRACE_EVENT0("content", "WebContentsImpl::~WebContentsImpl");
   WebContentsOfBrowserContext::Detach(*this);

content/browser/web_contents/web_contents_impl.h

@@ -2165,6 +2165,10 @@ class CONTENT_EXPORT WebContentsImpl
   // JavascriptDialogManager.
   void CancelDialogManagerDialogs(bool reset_state);
 
+  // Sets up RenderInputRouterDelegate mojo connections with InputManager on
+  // the VizCompositorThread for input handling with InputVizard.
+  void SetupRenderInputRouterDelegateConnection();
+
   // Data for core operation ---------------------------------------------------
 
   // Delegate for notifying our owner about stuff. Not owned by us.

content/public/test/fake_render_widget_host.cc

@@ -74,7 +74,9 @@ void FakeRenderWidgetHost::CreateFrameSink(
     mojo::PendingReceiver<viz::mojom::CompositorFrameSink>
         compositor_frame_sink_receiver,
     mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>
-        compositor_frame_sink_client) {}
+        compositor_frame_sink_client,
+    mojo::PendingRemote<blink::mojom::RenderInputRouterClient>
+        viz_rir_client_remote) {}
 
 void FakeRenderWidgetHost::RegisterRenderFrameMetadataObserver(
     mojo::PendingReceiver<cc::mojom::RenderFrameMetadataObserverClient>
@@ -132,9 +134,8 @@ void FakeRenderWidgetHost::AutoscrollEnd() {}
 blink::mojom::WidgetInputHandler*
 FakeRenderWidgetHost::GetWidgetInputHandler() {
   if (!widget_input_handler_) {
-    widget_remote_->SetupRenderInputRouterConnections(
-        client_remote_.BindNewPipeAndPassReceiver(),
-        /* viz_request= */ mojo::NullReceiver());
+    widget_remote_->SetupBrowserRenderInputRouterConnections(
+        client_remote_.BindNewPipeAndPassReceiver());
 
     client_remote_->GetWidgetInputHandler(
         widget_input_handler_.BindNewPipeAndPassReceiver(),

content/public/test/fake_render_widget_host.h

@@ -71,7 +71,9 @@ class FakeRenderWidgetHost : public blink::mojom::FrameWidgetHost,
       mojo::PendingReceiver<viz::mojom::CompositorFrameSink>
           compositor_frame_sink_receiver,
       mojo::PendingRemote<viz::mojom::CompositorFrameSinkClient>
-          compositor_frame_sink_client) override;
+          compositor_frame_sink_client,
+      mojo::PendingRemote<blink::mojom::RenderInputRouterClient>
+          viz_rir_client_remote) override;
   void RegisterRenderFrameMetadataObserver(
       mojo::PendingReceiver<cc::mojom::RenderFrameMetadataObserverClient>
           render_frame_metadata_observer_client_receiver,

content/test/mock_widget.cc

@@ -86,10 +86,9 @@ void MockWidget::RequestSuccessfulPresentationTimeForNextFrame(
 
 void MockWidget::CancelSuccessfulPresentationTimeRequest() {}
 
-void MockWidget::SetupRenderInputRouterConnections(
+void MockWidget::SetupBrowserRenderInputRouterConnections(
     mojo::PendingReceiver<blink::mojom::RenderInputRouterClient>
-        browser_request,
-    mojo::PendingReceiver<blink::mojom::RenderInputRouterClient> viz_request) {
+        browser_request) {
   input_receiver_.Bind(std::move(browser_request));
 }
 

content/test/mock_widget.h

@@ -71,11 +71,9 @@ class MockWidget : public blink::mojom::Widget,
       blink::mojom::RecordContentToVisibleTimeRequestPtr visible_time_request)
       override;
   void CancelSuccessfulPresentationTimeRequest() override;
-  void SetupRenderInputRouterConnections(
+  void SetupBrowserRenderInputRouterConnections(
       mojo::PendingReceiver<blink::mojom::RenderInputRouterClient>
-          browser_request,
-      mojo::PendingReceiver<blink::mojom::RenderInputRouterClient> viz_request)
-      override;
+          browser_request) override;
 
  private:
   std::optional<bool> is_hidden_;

third_party/blink/public/mojom/widget/platform_widget.mojom

@@ -66,12 +66,16 @@ interface WidgetHost {
 
   // Create a CompositorFrameSink that is associated with this widget.
   // The renderer compositor will use the returned sink to submit
-  // CompositorFrames for this widget.
+  // CompositorFrames for this widget. Sends remote to browser to connect
+  // Viz <-> Renderer RenderInputRouterClient mojo interface when InputVizard is
+  // enabled.
   CreateFrameSink(
       pending_receiver<viz.mojom.CompositorFrameSink>
           compositor_frame_sink_receiver,
       pending_remote<viz.mojom.CompositorFrameSinkClient>
-          compositor_frame_sink_client);
+          compositor_frame_sink_client,
+      pending_remote<blink.mojom.RenderInputRouterClient>
+          render_input_router_client);
 
   // Register compositor RenderFrameMetadataObserver and client.
   // This call will be made in conjunction with calling CreateFrameSink.
@@ -122,11 +126,10 @@ interface Widget {
   // none this will do nothing.
   CancelSuccessfulPresentationTimeRequest();
 
-  // Setup the RenderInputRouter mojo connections.
-  // `viz_client` is only set when `InputOnViz` flag is enabled.
-  SetupRenderInputRouterConnections(
-    pending_receiver<blink.mojom.RenderInputRouterClient> browser_client,
-    pending_receiver<blink.mojom.RenderInputRouterClient>? viz_client);
+  // Setup the RenderInputRouter mojo connection between the browser and the
+  // renderer process.
+  SetupBrowserRenderInputRouterConnections(
+    pending_receiver<blink.mojom.RenderInputRouterClient> browser_client);
 };
 
 // Implemented in Blink, this interface defines input-specific methods that will

third_party/blink/renderer/core/frame/frame_test_helpers.cc

@@ -1049,9 +1049,8 @@ void TestWebFrameWidget::BindWidgetChannels(
 
   mojo::PendingRemote<mojom::blink::RenderInputRouterClient> rir_client_remote;
   // Setup RenderInputRouter mojo connections.
-  widget_remote->SetupRenderInputRouterConnections(
-      rir_client_remote.InitWithNewPipeAndPassReceiver(),
-      /* viz_client= */ mojo::NullReceiver());
+  widget_remote->SetupBrowserRenderInputRouterConnections(
+      rir_client_remote.InitWithNewPipeAndPassReceiver());
   widget_host_->BindRenderInputRouterInterfaces(std::move(rir_client_remote));
 
   widget_host_->GetWidgetInputHandler(
@@ -1110,7 +1109,9 @@ void TestWebFrameWidgetHost::CreateFrameSink(
     mojo::PendingReceiver<viz::mojom::blink::CompositorFrameSink>
         compositor_frame_sink_receiver,
     mojo::PendingRemote<viz::mojom::blink::CompositorFrameSinkClient>
-        compositor_frame_sink_client) {}
+        compositor_frame_sink_client,
+    mojo::PendingRemote<blink::mojom::blink::RenderInputRouterClient>
+        viz_rir_client_remote) {}
 
 void TestWebFrameWidgetHost::RegisterRenderFrameMetadataObserver(
     mojo::PendingReceiver<cc::mojom::blink::RenderFrameMetadataObserverClient>

third_party/blink/renderer/core/frame/frame_test_helpers.h

@@ -193,7 +193,9 @@ class TestWebFrameWidgetHost : public mojom::blink::WidgetHost,
       mojo::PendingReceiver<viz::mojom::blink::CompositorFrameSink>
           compositor_frame_sink_receiver,
       mojo::PendingRemote<viz::mojom::blink::CompositorFrameSinkClient>
-          compositor_frame_sink_client) override;
+          compositor_frame_sink_client,
+      mojo::PendingRemote<blink::mojom::blink::RenderInputRouterClient>
+          viz_rir_client_remote) override;
   void RegisterRenderFrameMetadataObserver(
       mojo::PendingReceiver<cc::mojom::blink::RenderFrameMetadataObserverClient>
           render_frame_metadata_observer_client_receiver,

third_party/blink/renderer/platform/widget/widget_base.cc

@@ -614,19 +614,16 @@ void WidgetBase::CancelSuccessfulPresentationTimeRequest() {
   tab_switch_time_recorder_.TabWasHidden();
 }
 
-void WidgetBase::SetupRenderInputRouterConnections(
+void WidgetBase::SetupBrowserRenderInputRouterConnections(
     mojo::PendingReceiver<mojom::blink::RenderInputRouterClient>
-        browser_request,
-    mojo::PendingReceiver<mojom::blink::RenderInputRouterClient> viz_request) {
-  TRACE_EVENT("renderer", "WidgetBase::SetupRenderInputRouterConnections");
+        browser_request) {
+  TRACE_EVENT("renderer",
+              "WidgetBase::SetupBrowserRenderInputRouterConnections");
 
   // TODO(b/322833330): Investigate binding |browser_input_receiver_| on
   // RendererCompositor to break dependency on CrRendererMain and avoiding
   // contention with javascript during method calls.
   browser_input_receiver_.Bind(std::move(browser_request), task_runner_);
-  if (viz_request) {
-    viz_input_receiver_.Bind(std::move(viz_request), task_runner_);
-  }
 }
 
 void WidgetBase::ApplyViewportChanges(
@@ -813,9 +810,13 @@ void WidgetBase::FinishRequestNewLayerTreeFrameSink(
     return;
   }
 
+  viz_input_receiver_.reset();
+
   if (Platform::Current()->IsGpuCompositingDisabled()) {
-    widget_host_->CreateFrameSink(std::move(compositor_frame_sink_receiver),
-                                  std::move(compositor_frame_sink_client));
+    widget_host_->CreateFrameSink(
+        std::move(compositor_frame_sink_receiver),
+        std::move(compositor_frame_sink_client),
+        viz_input_receiver_.BindNewPipeAndPassRemote(task_runner_));
     widget_host_->RegisterRenderFrameMetadataObserver(
         std::move(render_frame_metadata_observer_client_receiver),
         std::move(render_frame_metadata_observer_remote));
@@ -885,8 +886,10 @@ void WidgetBase::FinishRequestNewLayerTreeFrameSink(
       !is_embedded_) {
     // TODO(ericrk): Collapse with non-webview registration below.
     if (::features::IsUsingVizFrameSubmissionForWebView()) {
-      widget_host_->CreateFrameSink(std::move(compositor_frame_sink_receiver),
-                                    std::move(compositor_frame_sink_client));
+      widget_host_->CreateFrameSink(
+          std::move(compositor_frame_sink_receiver),
+          std::move(compositor_frame_sink_client),
+          viz_input_receiver_.BindNewPipeAndPassRemote(task_runner_));
     }
     widget_host_->RegisterRenderFrameMetadataObserver(
         std::move(render_frame_metadata_observer_client_receiver),
@@ -910,8 +913,10 @@ void WidgetBase::FinishRequestNewLayerTreeFrameSink(
     return;
   }
 #endif
-  widget_host_->CreateFrameSink(std::move(compositor_frame_sink_receiver),
-                                std::move(compositor_frame_sink_client));
+  widget_host_->CreateFrameSink(
+      std::move(compositor_frame_sink_receiver),
+      std::move(compositor_frame_sink_client),
+      viz_input_receiver_.BindNewPipeAndPassRemote(task_runner_));
   widget_host_->RegisterRenderFrameMetadataObserver(
       std::move(render_frame_metadata_observer_client_receiver),
       std::move(render_frame_metadata_observer_remote));

third_party/blink/renderer/platform/widget/widget_base.h

@@ -166,11 +166,9 @@ class PLATFORM_EXPORT WidgetBase
       mojom::blink::RecordContentToVisibleTimeRequestPtr visible_time_request)
       override;
   void CancelSuccessfulPresentationTimeRequest() override;
-  void SetupRenderInputRouterConnections(
+  void SetupBrowserRenderInputRouterConnections(
       mojo::PendingReceiver<mojom::blink::RenderInputRouterClient>
-          browser_request,
-      mojo::PendingReceiver<mojom::blink::RenderInputRouterClient> viz_request)
-      override;
+          browser_request) override;
 
   // LayerTreeViewDelegate overrides:
   // Applies viewport related properties during a commit from the compositor