Stop inheriting mojom from FrameWidget, pass the interface explicitly

This removes a usage of WidgetBaseClient from outside of WidgetBase,
by passing the main thread implementation of the mojom interface
FrameWidgetInputHandler through WidgetBase to the WidgetInputHandler
classes, and on to the FrameWidgetInputHandlerImpl. Then that class
can access the WebFrameWidgetImpl's version of the mojom interface
through the pointer.

R=dtapuska@chromium.org

Change-Id: I26286cab13cad88bcb906f4ec879834be676db32
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2563080
Commit-Queue: danakj <danakj@chromium.org>
Reviewed-by: Dave Tapuska <dtapuska@chromium.org>
Cr-Commit-Position: refs/heads/master@{#832618}

third_party/blink/renderer/core/exported/web_page_popup_impl.cc

@@ -279,7 +279,7 @@ WebPagePopupImpl::WebPagePopupImpl(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : popup_widget_host_(std::move(popup_widget_host)),
       widget_base_(
-          std::make_unique<WidgetBase>(this,
+          std::make_unique<WidgetBase>(/*widget_base_client=*/this,
                                        std::move(widget_host),
                                        std::move(widget),
                                        task_runner,
@@ -439,10 +439,11 @@ cc::LayerTreeHost* WebPagePopupImpl::InitializeCompositing(
     const cc::LayerTreeSettings* settings) {
   // Careful Initialize() is called after InitializeCompositing, so don't do
   // much work here.
-  widget_base_->InitializeCompositing(
-      main_thread_scheduler, task_graph_runner,
-      /*for_child_local_root_frame=*/false, screen_info,
-      std::move(ukm_recorder_factory), settings);
+  widget_base_->InitializeCompositing(main_thread_scheduler, task_graph_runner,
+                                      /*for_child_local_root_frame=*/false,
+                                      screen_info,
+                                      std::move(ukm_recorder_factory), settings,
+                                      /*frame_widget_input_handler=*/nullptr);
   return widget_base_->LayerTreeHost();
 }
 

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

@@ -342,7 +342,7 @@ WebFrameWidgetImpl::WebFrameWidgetImpl(
     bool never_composited,
     bool is_for_child_local_root,
     bool is_for_nested_main_frame)
-    : widget_base_(std::make_unique<WidgetBase>(this,
+    : widget_base_(std::make_unique<WidgetBase>(/*widget_base_client=*/this,
                                                 std::move(widget_host),
                                                 std::move(widget),
                                                 task_runner,
@@ -406,6 +406,9 @@ void WebFrameWidgetImpl::Close() {
   client_ = nullptr;
   widget_base_->Shutdown();
   widget_base_.reset();
+  // These WeakPtrs must be invalidated for WidgetInputHandlerManager at the
+  // same time as the WidgetBase is.
+  input_handler_weak_ptr_factory_.InvalidateWeakPtrs();
   receiver_.reset();
   input_target_receiver_.reset();
   self_keep_alive_.Clear();
@@ -1939,7 +1942,8 @@ cc::LayerTreeHost* WebFrameWidgetImpl::InitializeCompositing(
     const cc::LayerTreeSettings* settings) {
   widget_base_->InitializeCompositing(
       main_thread_scheduler, task_graph_runner, is_for_child_local_root_,
-      screen_info, std::move(ukm_recorder_factory), settings);
+      screen_info, std::move(ukm_recorder_factory), settings,
+      input_handler_weak_ptr_factory_.GetWeakPtr());
 
   LocalFrameView* frame_view;
   if (is_for_child_local_root_) {

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

@@ -31,6 +31,7 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_FRAME_WIDGET_IMPL_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_FRAME_WIDGET_IMPL_H_
 
+#include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/types/pass_key.h"
 #include "build/build_config.h"
@@ -41,6 +42,7 @@
 #include "services/viz/public/mojom/hit_test/input_target_client.mojom-blink.h"
 #include "third_party/blink/public/common/input/web_coalesced_input_event.h"
 #include "third_party/blink/public/common/input/web_gesture_device.h"
+#include "third_party/blink/public/mojom/input/input_handler.mojom-blink.h"
 #include "third_party/blink/public/mojom/manifest/display_mode.mojom-blink.h"
 #include "third_party/blink/public/mojom/page/drag.mojom-blink.h"
 #include "third_party/blink/public/mojom/page/widget.mojom-blink.h"
@@ -96,6 +98,7 @@ class CORE_EXPORT WebFrameWidgetImpl
       public WidgetBaseClient,
       public mojom::blink::FrameWidget,
       public viz::mojom::blink::InputTargetClient,
+      public mojom::blink::FrameWidgetInputHandler,
       public FrameWidget,
       public PageWidgetEventHandler {
  public:
@@ -172,7 +175,7 @@ class CORE_EXPORT WebFrameWidgetImpl
 
   HitTestResult CoreHitTestResultAt(const gfx::PointF&);
 
-  // FrameWidget overrides:
+  // FrameWidget overrides.
   WebWidgetClient* Client() const final { return client_; }
   cc::AnimationHost* AnimationHost() const final;
   void SetOverscrollBehavior(
@@ -240,52 +243,13 @@ class CORE_EXPORT WebFrameWidgetImpl
   bool ShouldHandleImeEvents() override;
   void SetEditCommandsForNextKeyEvent(
       Vector<mojom::blink::EditCommandPtr> edit_commands) override;
-
-  void AddImeTextSpansToExistingText(
-      uint32_t start,
-      uint32_t end,
-      const Vector<ui::ImeTextSpan>& ime_text_spans) override;
   Vector<ui::mojom::blink::ImeTextSpanInfoPtr> GetImeTextSpansInfo(
       const WebVector<ui::ImeTextSpan>& ime_text_spans) override;
-  void ClearImeTextSpansByType(uint32_t start,
-                               uint32_t end,
-                               ui::ImeTextSpan::Type type) override;
-  void SetCompositionFromExistingText(
-      int32_t start,
-      int32_t end,
-      const Vector<ui::ImeTextSpan>& ime_text_spans) override;
-  void ExtendSelectionAndDelete(int32_t before, int32_t after) override;
-  void DeleteSurroundingText(int32_t before, int32_t after) override;
-  void DeleteSurroundingTextInCodePoints(int32_t before,
-                                         int32_t after) override;
-  void SetEditableSelectionOffsets(int32_t start, int32_t end) override;
-  void ExecuteEditCommand(const String& command, const String& value) override;
-  void Undo() override;
-  void Redo() override;
-  void Cut() override;
-  void Copy() override;
-  void CopyToFindPboard() override;
-  void Paste() override;
-  void PasteAndMatchStyle() override;
-  void Delete() override;
-  void SelectAll() override;
-  void CollapseSelection() override;
-  void Replace(const String& word) override;
-  void ReplaceMisspelling(const String& word) override;
-  void SelectRange(const gfx::Point& base_in_dips,
-                   const gfx::Point& extent_in_dips) override;
-  void AdjustSelectionByCharacterOffset(
-      int32_t start,
-      int32_t end,
-      mojom::blink::SelectionMenuBehavior behavior) override;
-  void MoveRangeSelectionExtent(const gfx::Point& extent_in_dips) override;
-  void ScrollFocusedEditableNodeIntoRect(
-      const gfx::Rect& rect_in_dips) override;
-  void ZoomToFindInPageRect(const WebRect& rect_in_root_frame) override;
-  void MoveCaret(const gfx::Point& point_in_dips) override;
-#if defined(OS_ANDROID)
-  void SelectWordAroundCaret(SelectWordAroundCaretCallback callback) override;
-#endif
+  void RequestMouseLock(
+      bool has_transient_user_activation,
+      bool request_unadjusted_movement,
+      mojom::blink::WidgetInputHandlerHost::RequestMouseLockCallback callback)
+      override;
   gfx::RectF BlinkSpaceToDIPs(const gfx::RectF& rect) override;
   gfx::Rect BlinkSpaceToEnclosedDIPs(const gfx::Rect& rect) override;
   gfx::Size BlinkSpaceToFlooredDIPs(const gfx::Size& size) override;
@@ -293,11 +257,6 @@ class CORE_EXPORT WebFrameWidgetImpl
   gfx::PointF DIPsToBlinkSpace(const gfx::PointF& point) override;
   gfx::Point DIPsToRoundedBlinkSpace(const gfx::Point& point) override;
   float DIPsToBlinkSpace(float scalar) override;
-  void RequestMouseLock(
-      bool has_transient_user_activation,
-      bool request_unadjusted_movement,
-      mojom::blink::WidgetInputHandlerHost::RequestMouseLockCallback callback)
-      override;
   void MouseCaptureLost() override;
   bool CanComposeInline() override;
   bool ShouldDispatchImeEventsToPlugin() override;
@@ -312,7 +271,7 @@ class CORE_EXPORT WebFrameWidgetImpl
                               int relative_cursor_pos) override;
   void ImeFinishComposingTextForPlugin(bool keep_selection) override;
 
-  // WebFrameWidget implementation.
+  // WebFrameWidget overrides.
   WebLocalFrame* LocalRoot() const override;
   void SendOverscrollEventFromImplSide(
       const gfx::Vector2dF& overscroll_delta,
@@ -344,6 +303,7 @@ class CORE_EXPORT WebFrameWidgetImpl
   void SetZoomLevelForTesting(double zoom_level) override;
   void ResetZoomLevelForTesting() override;
   void SetDeviceScaleFactorForTesting(float factor) override;
+  void ZoomToFindInPageRect(const WebRect& rect_in_root_frame) override;
   FrameWidgetTestHelper* GetFrameWidgetTestHelperForTesting() override;
 
   // Called when a drag-n-drop operation should begin.
@@ -362,7 +322,7 @@ class CORE_EXPORT WebFrameWidgetImpl
   // events.
   void ResetMeaningfulLayoutStateForMainFrame();
 
-  // WebWidget overrides:
+  // WebWidget overrides.
   cc::LayerTreeHost* InitializeCompositing(
       scheduler::WebThreadScheduler* main_thread_scheduler,
       cc::TaskGraphRunner* task_graph_runner,
@@ -611,7 +571,7 @@ class CORE_EXPORT WebFrameWidgetImpl
   friend class WebViewImpl;
   friend class ReportTimeSwapPromise;
 
-  // WidgetBaseClient overrides:
+  // WidgetBaseClient overrides.
   void BeginCommitCompositorFrame() override;
   void EndCommitCompositorFrame(base::TimeTicks commit_start_time) override;
   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
@@ -712,6 +672,50 @@ class CORE_EXPORT WebFrameWidgetImpl
                         GetStringAtPointCallback callback) override;
 #endif
 
+  // mojom::blink::FrameWidgetInputHandler overrides.
+  void AddImeTextSpansToExistingText(
+      uint32_t start,
+      uint32_t end,
+      const Vector<ui::ImeTextSpan>& ime_text_spans) override;
+  void ClearImeTextSpansByType(uint32_t start,
+                               uint32_t end,
+                               ui::ImeTextSpan::Type type) override;
+  void SetCompositionFromExistingText(
+      int32_t start,
+      int32_t end,
+      const Vector<ui::ImeTextSpan>& ime_text_spans) override;
+  void ExtendSelectionAndDelete(int32_t before, int32_t after) override;
+  void DeleteSurroundingText(int32_t before, int32_t after) override;
+  void DeleteSurroundingTextInCodePoints(int32_t before,
+                                         int32_t after) override;
+  void SetEditableSelectionOffsets(int32_t start, int32_t end) override;
+  void ExecuteEditCommand(const String& command, const String& value) override;
+  void Undo() override;
+  void Redo() override;
+  void Cut() override;
+  void Copy() override;
+  void CopyToFindPboard() override;
+  void Paste() override;
+  void PasteAndMatchStyle() override;
+  void Delete() override;
+  void SelectAll() override;
+  void CollapseSelection() override;
+  void Replace(const String& word) override;
+  void ReplaceMisspelling(const String& word) override;
+  void SelectRange(const gfx::Point& base_in_dips,
+                   const gfx::Point& extent_in_dips) override;
+  void AdjustSelectionByCharacterOffset(
+      int32_t start,
+      int32_t end,
+      mojom::blink::SelectionMenuBehavior behavior) override;
+  void MoveRangeSelectionExtent(const gfx::Point& extent_in_dips) override;
+  void ScrollFocusedEditableNodeIntoRect(
+      const gfx::Rect& rect_in_dips) override;
+  void MoveCaret(const gfx::Point& point_in_dips) override;
+#if defined(OS_ANDROID)
+  void SelectWordAroundCaret(SelectWordAroundCaretCallback callback) override;
+#endif
+
   // PageWidgetEventHandler overrides:
   WebInputEventResult HandleKeyEvent(const WebKeyboardEvent&) override;
   void HandleMouseDown(LocalFrame&, const WebMouseEvent&) override;
@@ -992,6 +996,9 @@ class CORE_EXPORT WebFrameWidgetImpl
   scoped_refptr<WebPagePopupImpl> last_hidden_page_popup_;
 
   SelfKeepAlive<WebFrameWidgetImpl> self_keep_alive_;
+
+  base::WeakPtrFactory<mojom::blink::FrameWidgetInputHandler>
+      input_handler_weak_ptr_factory_{this};
 };
 
 }  // namespace blink

third_party/blink/renderer/platform/widget/DEPS

 include_rules = [
-    "+cc/mojo_embedder/async_layer_tree_frame_sink.h",
-    "+cc/paint/element_id.h",
-    "+cc/trees/browser_controls_params.h",
-    "+cc/trees/latency_info_swap_promise_monitor.h",
-    "+cc/trees/layer_tree_host.h",
-    "+cc/trees/layer_tree_settings.h",
-    "+cc/trees/ukm_manager.h",
+    "+cc",
+    "-cc/ipc",
+    "-cc/mojom",
+    "-cc/test",
     "+components/viz/common",
     "+gpu/command_buffer/client/shared_memory_limits.h",
     "+gpu/command_buffer/common/context_creation_attribs.h",

third_party/blink/renderer/platform/widget/compositing/widget_compositor_unittest.cc

@@ -77,8 +77,8 @@ class WidgetCompositorTest : public cc::LayerTreeTest {
     ignore_result(widget_host_remote.BindNewEndpointAndPassDedicatedReceiver());
 
     widget_base_ = std::make_unique<WidgetBase>(
-        &client_, widget_host_remote.Unbind(), std::move(widget_receiver),
-        base::ThreadTaskRunnerHandle::Get(),
+        /*widget_base_client=*/&client_, widget_host_remote.Unbind(),
+        std::move(widget_receiver), base::ThreadTaskRunnerHandle::Get(),
         /*is_hidden=*/false,
         /*never_composited=*/false,
         /*is_for_child_local_root=*/false);

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

@@ -31,10 +31,9 @@ namespace blink {
 // on this class occur on the main thread. input/FrameWidgetInputHandlerImpl
 // which also implements the FrameWidgetInputHandler interface runs on the
 // compositor thread and proxies calls to this class.
-class PLATFORM_EXPORT FrameWidget
-    : public mojom::blink::FrameWidgetInputHandler {
+class PLATFORM_EXPORT FrameWidget {
  public:
-  ~FrameWidget() override;
+  virtual ~FrameWidget();
 
   // Returns the WebWidgetClient, which is implemented outside of blink.
   virtual WebWidgetClient* Client() const = 0;

third_party/blink/renderer/platform/widget/input/frame_widget_input_handler_impl.h

@@ -40,8 +40,12 @@ class WidgetBase;
 class PLATFORM_EXPORT FrameWidgetInputHandlerImpl
     : public mojom::blink::FrameWidgetInputHandler {
  public:
+  // The `widget` and `frame_widget_input_handler` should be invalidated
+  // at the same time.
   FrameWidgetInputHandlerImpl(
       base::WeakPtr<WidgetBase> widget,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+          frame_widget_input_handler,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
       scoped_refptr<MainThreadEventQueue> input_event_queue);
   ~FrameWidgetInputHandlerImpl() override;
@@ -112,12 +116,16 @@ class PLATFORM_EXPORT FrameWidgetInputHandlerImpl
   };
 
   void RunOnMainThread(base::OnceClosure closure);
-  static void ExecuteCommandOnMainThread(base::WeakPtr<WidgetBase> widget,
-                                         const char* command,
-                                         UpdateState state);
+  static void ExecuteCommandOnMainThread(
+      base::WeakPtr<WidgetBase> widget,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler> handler,
+      const char* command,
+      UpdateState state);
 
-  // |widget_| should only be accessed on the main thread.
+  // These should only be accessed on the main thread.
   base::WeakPtr<WidgetBase> widget_;
+  base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+      main_thread_frame_widget_input_handler_;
 
   scoped_refptr<MainThreadEventQueue> input_event_queue_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;

third_party/blink/renderer/platform/widget/input/widget_input_handler_impl.cc

@@ -38,13 +38,16 @@ WidgetInputHandlerImpl::WidgetInputHandlerImpl(
     scoped_refptr<WidgetInputHandlerManager> manager,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
     scoped_refptr<MainThreadEventQueue> input_event_queue,
-    base::WeakPtr<WidgetBase> widget)
+    base::WeakPtr<WidgetBase> widget,
+    base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+        frame_widget_input_handler)
     : main_thread_task_runner_(main_thread_task_runner),
       input_handler_manager_(manager),
       input_event_queue_(input_event_queue),
-      widget_(widget) {}
+      widget_(std::move(widget)),
+      frame_widget_input_handler_(std::move(frame_widget_input_handler)) {}
 
-WidgetInputHandlerImpl::~WidgetInputHandlerImpl() {}
+WidgetInputHandlerImpl::~WidgetInputHandlerImpl() = default;
 
 void WidgetInputHandlerImpl::SetReceiver(
     mojo::PendingReceiver<mojom::blink::WidgetInputHandler>
@@ -173,7 +176,8 @@ void WidgetInputHandlerImpl::GetFrameWidgetInputHandler(
         frame_receiver) {
   mojo::MakeSelfOwnedAssociatedReceiver(
       std::make_unique<FrameWidgetInputHandlerImpl>(
-          widget_, main_thread_task_runner_, input_event_queue_),
+          widget_, frame_widget_input_handler_, main_thread_task_runner_,
+          input_event_queue_),
       std::move(frame_receiver));
 }
 

third_party/blink/renderer/platform/widget/input/widget_input_handler_impl.h

@@ -23,11 +23,15 @@ class WidgetInputHandlerManager;
 // is done so that events stay in order relative to other events.
 class WidgetInputHandlerImpl : public mojom::blink::WidgetInputHandler {
  public:
+  // The `widget` and `frame_widget_input_handler` should be invalidated
+  // at the same time.
   WidgetInputHandlerImpl(
       scoped_refptr<WidgetInputHandlerManager> manager,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
       scoped_refptr<MainThreadEventQueue> input_event_queue,
-      base::WeakPtr<WidgetBase> widget);
+      base::WeakPtr<WidgetBase> widget,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+          frame_widget_input_handler);
   ~WidgetInputHandlerImpl() override;
 
   void SetReceiver(mojo::PendingReceiver<mojom::blink::WidgetInputHandler>
@@ -78,6 +82,8 @@ class WidgetInputHandlerImpl : public mojom::blink::WidgetInputHandler {
   scoped_refptr<WidgetInputHandlerManager> input_handler_manager_;
   scoped_refptr<MainThreadEventQueue> input_event_queue_;
   base::WeakPtr<WidgetBase> widget_;
+  base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+      frame_widget_input_handler_;
 
   // This callback is used to respond to the WaitForInputProcessed Mojo
   // message. We keep it around so that we can respond even if the renderer is

third_party/blink/renderer/platform/widget/input/widget_input_handler_manager.cc

@@ -171,14 +171,17 @@ class SynchronousCompositorProxyRegistry
 
 scoped_refptr<WidgetInputHandlerManager> WidgetInputHandlerManager::Create(
     base::WeakPtr<WidgetBase> widget,
+    base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+        frame_widget_input_handler,
     bool never_composited,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     scheduler::WebThreadScheduler* main_thread_scheduler,
     bool uses_input_handler) {
   scoped_refptr<WidgetInputHandlerManager> manager =
-      new WidgetInputHandlerManager(std::move(widget), never_composited,
-                                    std::move(compositor_task_runner),
-                                    main_thread_scheduler);
+      new WidgetInputHandlerManager(
+          std::move(widget), std::move(frame_widget_input_handler),
+          never_composited, std::move(compositor_task_runner),
+          main_thread_scheduler);
   if (uses_input_handler)
     manager->InitInputHandler();
 
@@ -193,10 +196,14 @@ scoped_refptr<WidgetInputHandlerManager> WidgetInputHandlerManager::Create(
 
 WidgetInputHandlerManager::WidgetInputHandlerManager(
     base::WeakPtr<WidgetBase> widget,
+    base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+        frame_widget_input_handler,
     bool never_composited,
     scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
     scheduler::WebThreadScheduler* main_thread_scheduler)
-    : widget_(widget),
+    : widget_(std::move(widget)),
+      frame_widget_input_handler_(std::move(frame_widget_input_handler)),
+
       widget_scheduler_(main_thread_scheduler->CreateWidgetScheduler()),
       main_thread_scheduler_(main_thread_scheduler),
       input_event_queue_(base::MakeRefCounted<MainThreadEventQueue>(
@@ -635,7 +642,8 @@ void WidgetInputHandlerManager::BindChannel(
   // |compositor_task_runner_| as events might get out of order.
   WidgetInputHandlerImpl* handler = new WidgetInputHandlerImpl(
       this, main_thread_task_runner_,
-      compositor_task_runner_ ? input_event_queue_ : nullptr, widget_);
+      compositor_task_runner_ ? input_event_queue_ : nullptr, widget_,
+      frame_widget_input_handler_);
   handler->SetReceiver(std::move(receiver));
 }
 

third_party/blink/renderer/platform/widget/input/widget_input_handler_manager.h

@@ -68,8 +68,12 @@ class PLATFORM_EXPORT WidgetInputHandlerManager final
   };
 
  public:
+  // The `widget` and `frame_widget_input_handler` should be invalidated
+  // at the same time.
   static scoped_refptr<WidgetInputHandlerManager> Create(
       base::WeakPtr<WidgetBase> widget_base,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+          frame_widget_input_handler,
       bool never_composited,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
       scheduler::WebThreadScheduler* main_thread_scheduler,
@@ -168,6 +172,8 @@ class PLATFORM_EXPORT WidgetInputHandlerManager final
  private:
   WidgetInputHandlerManager(
       base::WeakPtr<WidgetBase> widget,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+          frame_widget_input_handler,
       bool never_composited,
       scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner,
       scheduler::WebThreadScheduler* main_thread_scheduler);
@@ -251,6 +257,8 @@ class PLATFORM_EXPORT WidgetInputHandlerManager final
 
   // Only valid to be called on the main thread.
   base::WeakPtr<WidgetBase> widget_;
+  base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+      frame_widget_input_handler_;
   std::unique_ptr<scheduler::WebWidgetScheduler> widget_scheduler_;
   scheduler::WebThreadScheduler* main_thread_scheduler_;
 

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

@@ -176,7 +176,9 @@ void WidgetBase::InitializeCompositing(
     bool for_child_local_root_frame,
     const ScreenInfo& screen_info,
     std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory,
-    const cc::LayerTreeSettings* settings) {
+    const cc::LayerTreeSettings* settings,
+    base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+        frame_widget_input_handler) {
   main_thread_compositor_task_runner_ =
       main_thread_scheduler->CompositorTaskRunner();
 
@@ -219,9 +221,9 @@ void WidgetBase::InitializeCompositing(
   // WidgetBaseInputHandler.
   bool uses_input_handler = frame_widget;
   widget_input_handler_manager_ = WidgetInputHandlerManager::Create(
-      weak_ptr_factory_.GetWeakPtr(), never_composited_,
-      std::move(compositor_input_task_runner), main_thread_scheduler,
-      uses_input_handler);
+      weak_ptr_factory_.GetWeakPtr(), std::move(frame_widget_input_handler),
+      never_composited_, std::move(compositor_input_task_runner),
+      main_thread_scheduler, uses_input_handler);
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();

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

@@ -75,13 +75,22 @@ class PLATFORM_EXPORT WidgetBase : public mojom::blink::Widget,
   // Initialize the compositor. |settings| is typically null. When |settings| is
   // null the default settings will be used, tests may provide a |settings|
   // object to override the defaults.
+  //
+  // TODO(dtapuska): The WebFrameWidgetImpl should be responsible for making
+  // the FrameWidgetInputHandlerImpl, but currently it is done in the general
+  // widget input handler classes directly, so we have to plumb through the
+  // main-thread mojom implementation.
+  // The `frame_widget_input_handler` must be invalidated when the WidgetBase is
+  // destroyed/invalidated.
   void InitializeCompositing(
       scheduler::WebThreadScheduler* main_thread_scheduler,
       cc::TaskGraphRunner* task_graph_runner,
       bool for_child_local_root_frame,
       const ScreenInfo& screen_info,
       std::unique_ptr<cc::UkmRecorderFactory> ukm_recorder_factory,
-      const cc::LayerTreeSettings* settings);
+      const cc::LayerTreeSettings* settings,
+      base::WeakPtr<mojom::blink::FrameWidgetInputHandler>
+          frame_widget_input_handler);
 
   // Shutdown the compositor.
   void Shutdown();
@@ -355,6 +364,8 @@ class PLATFORM_EXPORT WidgetBase : public mojom::blink::Widget,
   const bool is_for_child_local_root_;
   // When true, the device scale factor is a part of blink coordinates.
   const bool use_zoom_for_dsf_;
+
+  // The client which handles behaviour specific to the type of widget.
   WidgetBaseClient* const client_;
 
   mojo::AssociatedRemote<mojom::blink::WidgetHost> widget_host_;

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

@@ -8,11 +8,14 @@
 #include <vector>
 
 #include "base/time/time.h"
+#include "cc/metrics/frame_sequence_tracker_collection.h"
 #include "cc/paint/element_id.h"
+#include "cc/trees/layer_tree_host_client.h"
 #include "third_party/blink/public/common/metrics/document_update_reason.h"
 #include "third_party/blink/public/mojom/page/widget.mojom-blink.h"
 #include "third_party/blink/public/mojom/widget/screen_orientation.mojom-blink.h"
 #include "third_party/blink/public/platform/input/input_handler_proxy.h"
+#include "third_party/blink/public/platform/web_input_event_result.h"
 #include "third_party/blink/public/platform/web_text_input_type.h"
 #include "third_party/blink/public/web/web_lifecycle_update.h"