[M120 Migration] Fix show IME
[platform/framework/web/chromium-efl.git] / third_party / blink / renderer / core / frame / web_frame_widget_impl.h
1 /*
2  * Copyright (C) 2014 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_FRAME_WIDGET_IMPL_H_
32 #define THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_FRAME_WIDGET_IMPL_H_
33
34 #include "base/functional/function_ref.h"
35 #include "base/memory/weak_ptr.h"
36 #include "base/task/single_thread_task_runner.h"
37 #include "base/time/time.h"
38 #include "base/types/pass_key.h"
39 #include "base/unguessable_token.h"
40 #include "build/build_config.h"
41 #include "cc/input/event_listener_properties.h"
42 #include "cc/input/overscroll_behavior.h"
43 #include "cc/trees/layer_tree_host.h"
44 #include "cc/trees/paint_holding_reason.h"
45 #include "services/viz/public/mojom/hit_test/input_target_client.mojom-blink.h"
46 #include "third_party/blink/public/common/input/web_coalesced_input_event.h"
47 #include "third_party/blink/public/common/input/web_gesture_device.h"
48 #include "third_party/blink/public/mojom/drag/drag.mojom-blink.h"
49 #include "third_party/blink/public/mojom/input/input_handler.mojom-blink-forward.h"
50 #include "third_party/blink/public/mojom/input/stylus_writing_gesture.mojom-blink.h"
51 #include "third_party/blink/public/mojom/manifest/display_mode.mojom-blink.h"
52 #include "third_party/blink/public/mojom/page/widget.mojom-blink.h"
53 #include "third_party/blink/public/mojom/scroll/scroll_into_view_params.mojom-blink-forward.h"
54 #include "third_party/blink/public/platform/cross_variant_mojo_util.h"
55 #include "third_party/blink/public/platform/web_drag_data.h"
56 #include "third_party/blink/public/web/web_frame_widget.h"
57 #include "third_party/blink/public/web/web_meaningful_layout.h"
58 #include "third_party/blink/renderer/core/clipboard/data_object.h"
59 #include "third_party/blink/renderer/core/core_export.h"
60 #include "third_party/blink/renderer/core/exported/web_page_popup_impl.h"
61 #include "third_party/blink/renderer/core/frame/animation_frame_timing_monitor.h"
62 #include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
63 #include "third_party/blink/renderer/core/page/drag_controller.h"
64 #include "third_party/blink/renderer/core/page/event_with_hit_test_results.h"
65 #include "third_party/blink/renderer/core/page/viewport_description.h"
66 #include "third_party/blink/renderer/platform/graphics/apply_viewport_changes.h"
67 #include "third_party/blink/renderer/platform/graphics/paint/paint_image.h"
68 #include "third_party/blink/renderer/platform/heap/member.h"
69 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_receiver.h"
70 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_remote.h"
71 #include "third_party/blink/renderer/platform/mojo/heap_mojo_receiver.h"
72 #include "third_party/blink/renderer/platform/mojo/heap_mojo_wrapper_mode.h"
73 #include "third_party/blink/renderer/platform/text/text_direction.h"
74 #include "third_party/blink/renderer/platform/widget/frame_widget.h"
75 #include "third_party/blink/renderer/platform/widget/input/widget_base_input_handler.h"
76 #include "third_party/blink/renderer/platform/widget/widget_base_client.h"
77 #include "third_party/blink/renderer/platform/wtf/casting.h"
78 #include "ui/base/dragdrop/mojom/drag_drop_types.mojom-shared.h"
79 #include "ui/base/ui_base_types.h"
80 #include "ui/gfx/ca_layer_result.h"
81
82 namespace gfx {
83 class Point;
84 class PointF;
85 }  // namespace gfx
86
87 namespace blink {
88 class AnimationWorkletMutatorDispatcherImpl;
89 class HitTestResult;
90 class HTMLPlugInElement;
91 class Page;
92 class PaintWorkletPaintDispatcher;
93 class RemoteFrame;
94 class WebLocalFrameImpl;
95 class WebPlugin;
96 class WebViewImpl;
97 class WidgetBase;
98 class WidgetEventHandler;
99 class ScreenMetricsEmulator;
100
101 // Implements WebFrameWidget for both main frames and child local root frame
102 // (OOPIF).
103 class CORE_EXPORT WebFrameWidgetImpl
104     : public GarbageCollected<WebFrameWidgetImpl>,
105       public WebFrameWidget,
106       public WidgetBaseClient,
107       public mojom::blink::FrameWidget,
108       public viz::mojom::blink::InputTargetClient,
109       public mojom::blink::FrameWidgetInputHandler,
110       public FrameWidget,
111       public AnimationFrameTimingMonitor::Client,
112       public WidgetEventHandler {
113  public:
114   struct PromiseCallbacks {
115     base::OnceCallback<void(base::TimeTicks)> swap_time_callback;
116     base::OnceCallback<void(base::TimeTicks)> presentation_time_callback;
117 #if BUILDFLAG(IS_APPLE)
118     base::OnceCallback<void(gfx::CALayerResult)>
119         core_animation_error_code_callback;
120 #endif
121     bool IsEmpty() {
122       return (!swap_time_callback &&
123 #if BUILDFLAG(IS_APPLE)
124               !core_animation_error_code_callback &&
125 #endif
126               !presentation_time_callback);
127     }
128   };
129
130   WebFrameWidgetImpl(
131       base::PassKey<WebLocalFrame>,
132       CrossVariantMojoAssociatedRemote<
133           mojom::blink::FrameWidgetHostInterfaceBase> frame_widget_host,
134       CrossVariantMojoAssociatedReceiver<mojom::blink::FrameWidgetInterfaceBase>
135           frame_widget,
136       CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase>
137           widget_host,
138       CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase>
139           widget,
140       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
141       const viz::FrameSinkId& frame_sink_id,
142       bool hidden,
143       bool never_composited,
144       bool is_for_child_local_root,
145       bool is_for_nested_main_frame,
146       bool is_for_scalable_page);
147   ~WebFrameWidgetImpl() override;
148
149   virtual void Trace(Visitor*) const;
150
151   // Shutdown the widget.
152   void Close();
153
154   // Returns the WebFrame that this widget is attached to. It will be a local
155   // root since only local roots have a widget attached.
156   WebLocalFrameImpl* LocalRootImpl() const { return local_root_.Get(); }
157
158   // Returns the bounding box of the block type node touched by the WebPoint.
159   gfx::Rect ComputeBlockBound(const gfx::Point& point_in_root_frame,
160                               bool ignore_clipping) const;
161
162   virtual void BindLocalRoot(WebLocalFrame&);
163
164   // If this widget is for the top most main frame. This is different than
165   // |ForMainFrame| because |ForMainFrame| could return true but this method
166   // returns false. If this widget is a MainFrame widget embedded in another
167   // widget, for example embedding a portal.
168   bool ForTopMostMainFrame() const;
169
170   // Adjusts whether the widget is nested or not. This is called during portal
171   // transitions.
172   void SetIsNestedMainFrameWidget(bool is_nested);
173
174   // Returns true if this widget is for a local root that is a child frame,
175   // false otherwise.
176   bool ForSubframe() const { return is_for_child_local_root_; }
177
178   // Opposite of |ForSubframe|. If this widget is for the local main frame.
179   bool ForMainFrame() const { return !ForSubframe(); }
180
181   // Called when the intrinsic size of the owning container is changing its
182   // size. This should only be called when `ForSubframe` is true.
183   void IntrinsicSizingInfoChanged(mojom::blink::IntrinsicSizingInfoPtr);
184
185   void AutoscrollStart(const gfx::PointF& position);
186   void AutoscrollFling(const gfx::Vector2dF& position);
187   void AutoscrollEnd();
188
189   bool HandleCurrentKeyboardEvent();
190
191   // Creates or returns cached mutator dispatcher. This usually requires a
192   // round trip to the compositor. The returned WeakPtr must only be
193   // dereferenced on the output |mutator_task_runner|.
194   base::WeakPtr<AnimationWorkletMutatorDispatcherImpl>
195   EnsureCompositorMutatorDispatcher(
196       scoped_refptr<base::SingleThreadTaskRunner> mutator_task_runner);
197
198   // TODO: consider merge the input and return value to be one parameter.
199   // Creates or returns cached paint dispatcher. The returned WeakPtr must only
200   // be dereferenced on the output |paint_task_runner|.
201   base::WeakPtr<PaintWorkletPaintDispatcher> EnsureCompositorPaintDispatcher(
202       scoped_refptr<base::SingleThreadTaskRunner>* paint_task_runner);
203
204   HitTestResult CoreHitTestResultAt(const gfx::PointF&);
205
206   // Registers callbacks for the corresponding renderer frame: `swap_callback`
207   // is fired with the submission (aka swap) timestamp when the frame is
208   // submitted to Viz; `presentation_callback` is fired with the presentation
209   // timestamp after the frame is presented to the user.
210   void NotifySwapAndPresentationTimeForTesting(PromiseCallbacks callbacks);
211
212   // Process the input event, invoking the callback when complete. This
213   // method will call the callback synchronously.
214   void ProcessInputEventSynchronouslyForTesting(
215       const WebCoalescedInputEvent&,
216       WidgetBaseInputHandler::HandledEventCallback);
217
218   // FrameWidget overrides.
219   cc::AnimationHost* AnimationHost() const final;
220   cc::AnimationTimeline* ScrollAnimationTimeline() const final;
221   void SetOverscrollBehavior(
222       const cc::OverscrollBehavior& overscroll_behavior) final;
223   void RequestAnimationAfterDelay(const base::TimeDelta&) final;
224   void SetRootLayer(scoped_refptr<cc::Layer>) override;
225   void RequestDecode(const cc::PaintImage&,
226                      base::OnceCallback<void(bool)>) override;
227   void NotifyPresentationTimeInBlink(
228       base::OnceCallback<void(base::TimeTicks)> presentation_callback) final;
229   void RequestBeginMainFrameNotExpected(bool request) final;
230   int GetLayerTreeId() final;
231   const cc::LayerTreeSettings* GetLayerTreeSettings() final;
232   void UpdateBrowserControlsState(cc::BrowserControlsState constraints,
233                                   cc::BrowserControlsState current,
234                                   bool animate) final;
235   void SetEventListenerProperties(cc::EventListenerClass,
236                                   cc::EventListenerProperties) final;
237   cc::EventListenerProperties EventListenerProperties(
238       cc::EventListenerClass) const final;
239   mojom::blink::DisplayMode DisplayMode() const override;
240   ui::WindowShowState WindowShowState() const override;
241   bool Resizable() const override;
242   const WebVector<gfx::Rect>& WindowSegments() const override;
243   void SetDelegatedInkMetadata(
244       std::unique_ptr<gfx::DelegatedInkMetadata> metadata) final;
245   void DidOverscroll(const gfx::Vector2dF& overscroll_delta,
246                      const gfx::Vector2dF& accumulated_overscroll,
247                      const gfx::PointF& position,
248                      const gfx::Vector2dF& velocity) override;
249   void InjectScrollbarGestureScroll(const gfx::Vector2dF& delta,
250                                     ui::ScrollGranularity granularity,
251                                     cc::ElementId scrollable_area_element_id,
252                                     WebInputEvent::Type injected_type) override;
253   void DidChangeCursor(const ui::Cursor&) override;
254   void GetCompositionCharacterBoundsInWindow(
255       Vector<gfx::Rect>* bounds_in_dips) override;
256   // Return the last calculated line bounds.
257   Vector<gfx::Rect>& GetVisibleLineBoundsOnScreen() override;
258   void UpdateLineBounds() override;
259   gfx::Range CompositionRange() override;
260   WebTextInputInfo TextInputInfo() override;
261   ui::mojom::VirtualKeyboardVisibilityRequest
262   GetLastVirtualKeyboardVisibilityRequest() override;
263   bool ShouldSuppressKeyboardForFocusedElement() override;
264   void GetEditContextBoundsInWindow(
265       absl::optional<gfx::Rect>* control_bounds,
266       absl::optional<gfx::Rect>* selection_bounds) override;
267   int32_t ComputeWebTextInputNextPreviousFlags() override;
268   void ResetVirtualKeyboardVisibilityRequest() override;
269   bool GetSelectionBoundsInWindow(gfx::Rect* focus,
270                                   gfx::Rect* anchor,
271                                   gfx::Rect* bounding_box,
272                                   base::i18n::TextDirection* focus_dir,
273                                   base::i18n::TextDirection* anchor_dir,
274                                   bool* is_anchor_first) override;
275   void ClearTextInputState() override;
276
277   bool SetComposition(const String& text,
278                       const Vector<ui::ImeTextSpan>& ime_text_spans,
279                       const gfx::Range& replacement_range,
280                       int selection_start,
281                       int selection_end) override;
282   void CommitText(const String& text,
283                   const Vector<ui::ImeTextSpan>& ime_text_spans,
284                   const gfx::Range& replacement_range,
285                   int relative_cursor_pos) override;
286   void FinishComposingText(bool keep_selection) override;
287   bool IsProvisional() override;
288   cc::ElementId GetScrollableContainerIdAt(const gfx::PointF& point) override;
289   bool ShouldHandleImeEvents() override;
290   void SetEditCommandsForNextKeyEvent(
291       Vector<mojom::blink::EditCommandPtr> edit_commands) override;
292   Vector<ui::mojom::blink::ImeTextSpanInfoPtr> GetImeTextSpansInfo(
293       const WebVector<ui::ImeTextSpan>& ime_text_spans) override;
294   void RequestMouseLock(
295       bool has_transient_user_activation,
296       bool request_unadjusted_movement,
297       mojom::blink::WidgetInputHandlerHost::RequestMouseLockCallback callback)
298       override;
299   gfx::RectF BlinkSpaceToDIPs(const gfx::RectF& rect) override;
300   gfx::Rect BlinkSpaceToEnclosedDIPs(const gfx::Rect& rect) override;
301   gfx::Size BlinkSpaceToFlooredDIPs(const gfx::Size& size) override;
302   gfx::RectF DIPsToBlinkSpace(const gfx::RectF& rect) override;
303   gfx::PointF DIPsToBlinkSpace(const gfx::PointF& point) override;
304   gfx::Point DIPsToRoundedBlinkSpace(const gfx::Point& point) override;
305   float DIPsToBlinkSpace(float scalar) override;
306   void MouseCaptureLost() override;
307   bool CanComposeInline() override;
308   bool ShouldDispatchImeEventsToPlugin() override;
309   void ImeSetCompositionForPlugin(const String& text,
310                                   const Vector<ui::ImeTextSpan>& ime_text_spans,
311                                   const gfx::Range& replacement_range,
312                                   int selection_start,
313                                   int selection_end) override;
314   void ImeCommitTextForPlugin(const String& text,
315                               const Vector<ui::ImeTextSpan>& ime_text_spans,
316                               const gfx::Range& replacement_range,
317                               int relative_cursor_pos) override;
318   void ImeFinishComposingTextForPlugin(bool keep_selection) override;
319   float GetCompositingScaleFactor() override;
320   const cc::LayerTreeDebugState& GetLayerTreeDebugState() override;
321   void SetLayerTreeDebugState(const cc::LayerTreeDebugState& state) override;
322   void SetMayThrottleIfUndrawnFrames(
323       bool may_throttle_if_undrawn_frames) override;
324   int GetVirtualKeyboardResizeHeight() const override;
325
326   void OnTaskCompletedForFrame(base::TimeTicks start_time,
327                                base::TimeTicks end_time,
328                                base::TimeTicks desired_execution_time,
329                                LocalFrame*) override;
330   void SetVirtualKeyboardResizeHeightForTesting(int);
331   bool GetMayThrottleIfUndrawnFramesForTesting();
332
333   // AnimationFrameTimingMonitor::Client overrides
334   void ReportLongAnimationFrameTiming(AnimationFrameTimingInfo* info) override;
335   bool ShouldReportLongAnimationFrameTiming() const override;
336   void ReportLongTaskTiming(base::TimeTicks start_time,
337                             base::TimeTicks end,
338                             ExecutionContext* task_context) override;
339   bool RequestedMainFramePending() override;
340   ukm::UkmRecorder* MainFrameUkmRecorder() override;
341   ukm::SourceId MainFrameUkmSourceId() override;
342   bool IsMainFrameFullyLoaded() const override;
343
344   // WebFrameWidget overrides.
345   void InitializeNonCompositing(WebNonCompositedWidgetClient* client) override;
346   WebLocalFrame* LocalRoot() const override;
347   void UpdateCompositorScrollState(
348       const cc::CompositorCommitData& commit_data) override;
349   WebInputMethodController* GetActiveWebInputMethodController() const override;
350   void DisableDragAndDrop() override;
351   WebLocalFrameImpl* FocusedWebLocalFrameInWidget() const override;
352   bool ScrollFocusedEditableElementIntoView() override;
353   void ApplyViewportChangesForTesting(
354       const ApplyViewportChangesArgs& args) override;
355   void ApplyViewportIntersectionForTesting(
356       mojom::blink::ViewportIntersectionStatePtr intersection_state);
357   void NotifyPresentationTime(
358       base::OnceCallback<void(base::TimeTicks)> callback) override;
359 #if BUILDFLAG(IS_APPLE)
360   void NotifyCoreAnimationErrorCode(
361       base::OnceCallback<void(gfx::CALayerResult)> callback) override;
362 #endif
363   void WaitForDebuggerWhenShown() override;
364   void SetTextZoomFactor(float text_zoom_factor) override;
365   float TextZoomFactor() override;
366   void SetMainFrameOverlayColor(SkColor) override;
367   void AddEditCommandForNextKeyEvent(const WebString& name,
368                                      const WebString& value) override;
369   void ClearEditCommands() override;
370   bool IsPasting() override;
371   bool HandlingSelectRange() override;
372   void ReleaseMouseLockAndPointerCaptureForTesting() override;
373   const viz::FrameSinkId& GetFrameSinkId() override;
374   WebHitTestResult HitTestResultAt(const gfx::PointF&) override;
375   void SetZoomLevelForTesting(double zoom_level) override;
376   void ResetZoomLevelForTesting() override;
377   void SetDeviceScaleFactorForTesting(float factor) override;
378   FrameWidgetTestHelper* GetFrameWidgetTestHelperForTesting() override;
379   void PrepareForFinalLifecyclUpdateForTesting() override;
380
381   // Called when a drag-n-drop operation should begin.
382   virtual void StartDragging(LocalFrame* source_frame,
383                              const WebDragData&,
384                              DragOperationsMask,
385                              const SkBitmap& drag_image,
386                              const gfx::Vector2d& cursor_offset,
387                              const gfx::Rect& drag_obj_rect);
388
389   bool DoingDragAndDrop() { return doing_drag_and_drop_; }
390   static void SetIgnoreInputEvents(
391       const base::UnguessableToken& browsing_context_group_token,
392       bool value);
393   static bool IgnoreInputEvents(
394       const base::UnguessableToken& browsing_context_group_token);
395
396   // Resets the layout tracking steps for the main frame. When
397   // `UpdateLifecycle()` is called it generates `WebMeaningfulLayout` events
398   // only once. This resets the state back to the default so it will fire new
399   // events.
400   void ResetMeaningfulLayoutStateForMainFrame();
401
402   // WebWidget overrides.
403   void InitializeCompositing(const display::ScreenInfos& screen_infos,
404                              const cc::LayerTreeSettings* settings) override;
405   void InitializeCompositingFromPreviousWidget(
406       const display::ScreenInfos& screen_infos,
407       const cc::LayerTreeSettings* settings,
408       WebFrameWidget& previous_widget) override;
409   void SetCompositorVisible(bool visible) override;
410   gfx::Size Size() override;
411   void Resize(const gfx::Size& size_with_dsf) override;
412   void SetCursor(const ui::Cursor& cursor) override;
413   bool HandlingInputEvent() override;
414   void SetHandlingInputEvent(bool handling) override;
415   void ProcessInputEventSynchronouslyForTesting(
416       const WebCoalescedInputEvent&) override;
417   WebInputEventResult DispatchBufferedTouchEvents() override;
418   WebInputEventResult HandleInputEvent(const WebCoalescedInputEvent&) override;
419   void UpdateTextInputState() override;
420   void UpdateSelectionBounds() override;
421   void ShowVirtualKeyboard() override;
422   bool HasFocus() override;
423   void SetFocus(bool focus) override;
424   void FlushInputProcessedCallback() override;
425   void CancelCompositionForPepper() override;
426   void ApplyVisualProperties(
427       const VisualProperties& visual_properties) override;
428   bool PinchGestureActiveInMainFrame() override;
429   float PageScaleInMainFrame() override;
430   const display::ScreenInfo& GetScreenInfo() override;
431   const display::ScreenInfos& GetScreenInfos() override;
432   const display::ScreenInfo& GetOriginalScreenInfo() override;
433   const display::ScreenInfos& GetOriginalScreenInfos() override;
434   gfx::Rect WindowRect() override;
435   gfx::Rect ViewRect() override;
436   void SetScreenRects(const gfx::Rect& widget_screen_rect,
437                       const gfx::Rect& window_screen_rect) override;
438   gfx::Size VisibleViewportSizeInDIPs() override;
439   bool IsHidden() const override;
440   WebString GetLastToolTipTextForTesting() const override;
441   float GetEmulatorScale() override;
442
443   // WidgetBaseClient overrides:
444   void OnCommitRequested() override;
445   void BeginMainFrame(base::TimeTicks last_frame_time) override;
446   void UpdateLifecycle(WebLifecycleUpdate requested_update,
447                        DocumentUpdateReason reason) override;
448
449   // mojom::blink::FrameWidget overrides:
450   void ShowContextMenu(ui::mojom::MenuSourceType source_type,
451                        const gfx::Point& location) override;
452   void SetViewportIntersection(
453       mojom::blink::ViewportIntersectionStatePtr intersection_state,
454       const absl::optional<VisualProperties>& visual_properties) override;
455   void DragSourceEndedAt(const gfx::PointF& point_in_viewport,
456                          const gfx::PointF& screen_point,
457                          ui::mojom::blink::DragOperation,
458                          base::OnceClosure callback) override;
459
460   // mojom::blink::FrameWidgetInputHandler overrides:
461   void HandleStylusWritingGestureAction(
462       mojom::blink::StylusWritingGestureDataPtr gesture_data,
463       HandleStylusWritingGestureActionCallback callback) override;
464
465   // Sets the display mode, which comes from the top-level browsing context and
466   // is applied to all widgets.
467   void SetDisplayMode(mojom::blink::DisplayMode);
468
469   // Sets the window show state.
470   void SetWindowShowState(ui::WindowShowState);
471
472   void SetResizable(bool);
473
474   absl::optional<gfx::Point> GetAndResetContextMenuLocation();
475
476   void BindWidgetCompositor(
477       mojo::PendingReceiver<mojom::blink::WidgetCompositor> receiver) override;
478
479   void BindInputTargetClient(
480       mojo::PendingReceiver<viz::mojom::blink::InputTargetClient> receiver)
481       override;
482
483   // viz::mojom::blink::InputTargetClient:
484   void FrameSinkIdAt(const gfx::PointF& point,
485                      const uint64_t trace_id,
486                      FrameSinkIdAtCallback callback) override;
487
488   // Called when the FrameView for this Widget's local root is created.
489   void DidCreateLocalRootView();
490
491   void SetZoomLevel(double zoom_level);
492
493   // Called when the View has auto resized.
494   virtual void DidAutoResize(const gfx::Size& size);
495
496   // This method returns the focused frame belonging to this WebWidget, that
497   // is, a focused frame with the same local root as the one corresponding
498   // to this widget. It will return nullptr if no frame is focused or, the
499   // focused frame has a different local root.
500   LocalFrame* FocusedLocalFrameInWidget() const;
501
502   // For when the embedder itself change scales on the page (e.g. devtools)
503   // and wants all of the content at the new scale to be crisp
504   void SetNeedsRecalculateRasterScales();
505
506   // Sets the background color to be filled in as gutter behind/around the
507   // painted content. Non-composited WebViews need not implement this, as they
508   // paint into another widget which has a background color of its own.
509   void SetBackgroundColor(SkColor color);
510
511   // Sets whether the prefers-reduced-motion hint has been enabled.
512   void SetPrefersReducedMotion(bool prefers_reduced_motion);
513
514   // Starts an animation of the page scale to a target scale factor and scroll
515   // offset.
516   // If use_anchor is true, destination is a point on the screen that will
517   // remain fixed for the duration of the animation.
518   // If use_anchor is false, destination is the final top-left scroll position.
519   void StartPageScaleAnimation(const gfx::Point& destination,
520                                bool use_anchor,
521                                float new_page_scale,
522                                base::TimeDelta duration);
523
524   // Called to update if scroll events should be sent.
525   void SetHaveScrollEventHandlers(bool);
526
527   // Start deferring commits to the compositor, allowing document lifecycle
528   // updates without committing the layer tree. Commits are deferred
529   // until at most the given |timeout| has passed. If multiple calls are made
530   // when deferral is active then the initial timeout applies.
531   bool StartDeferringCommits(base::TimeDelta timeout,
532                              cc::PaintHoldingReason reason);
533   // Immediately stop deferring commits.
534   void StopDeferringCommits(cc::PaintHoldingCommitTrigger);
535
536   // Pause all rendering (main and compositor thread) in the compositor.
537   [[nodiscard]] std::unique_ptr<cc::ScopedPauseRendering> PauseRendering();
538
539   // Returns the maximum bounds for buffers allocated for rasterization and
540   // compositing. This is is max texture size for GPU compositing and a browser
541   // chosen limit in software mode.
542   // Returns null if the compositing stack has not been initialized yet.
543   absl::optional<int> GetMaxRenderBufferBounds() const;
544
545   // Prevents any updates to the input for the layer tree, and the layer tree
546   // itself, and the layer tree from becoming visible.
547   std::unique_ptr<cc::ScopedDeferMainFrameUpdate> DeferMainFrameUpdate();
548
549   // Sets the amount that the top and bottom browser controls are showing, from
550   // 0 (hidden) to 1 (fully shown).
551   void SetBrowserControlsShownRatio(float top_ratio, float bottom_ratio);
552
553   // Set browser controls params. These params consist of top and bottom
554   // heights, min-heights, browser_controls_shrink_blink_size, and
555   // animate_browser_controls_height_changes. If
556   // animate_browser_controls_height_changes is set to true, changes to the
557   // browser controls height will be animated. If
558   // browser_controls_shrink_blink_size is set to true, then Blink shrunk the
559   // viewport clip layers by the top and bottom browser controls height. Top
560   // controls will translate the web page down and do not immediately scroll
561   // when hiding. The bottom controls scroll immediately and never translate the
562   // content (only clip it).
563   void SetBrowserControlsParams(cc::BrowserControlsParams params);
564
565   // This function provides zooming for find in page results when browsing with
566   // page autosize.
567   void ZoomToFindInPageRect(const gfx::Rect& rect_in_root_frame);
568
569   // Return the compositor LayerTreeHost.
570   cc::LayerTreeHost* LayerTreeHostForTesting() const;
571   // Ask compositor to composite a frame for testing. This will generate a
572   // BeginMainFrame, and update the document lifecycle.
573   void SynchronouslyCompositeForTesting(base::TimeTicks frame_time);
574
575   // Sets the device color space for testing.
576   void SetDeviceColorSpaceForTesting(const gfx::ColorSpace& color_space);
577
578   // Converts from DIPs to Blink coordinate space (ie. Viewport/Physical
579   // pixels).
580   gfx::Size DIPsToCeiledBlinkSpace(const gfx::Size& size);
581
582   void SetWindowRect(const gfx::Rect& requested_rect,
583                      const gfx::Rect& adjusted_rect);
584   void SetWindowRectSynchronouslyForTesting(const gfx::Rect& new_window_rect);
585
586   void UpdateTooltipUnderCursor(const String& tooltip_text, TextDirection dir);
587   void UpdateTooltipFromKeyboard(const String& tooltip_text,
588                                  TextDirection dir,
589                                  const gfx::Rect& bounds);
590   void ClearKeyboardTriggeredTooltip();
591
592   void ShowVirtualKeyboardOnElementFocus();
593 #if BUILDFLAG(IS_EFL)
594   void DidUpdateTextOfFocusedElementByNonUserInput();
595 #endif
596   void ProcessTouchAction(WebTouchAction touch_action);
597   void SetPanAction(mojom::blink::PanAction pan_action);
598
599   // Called to update whether low latency input mode is enabled or not.
600   void SetNeedsLowLatencyInput(bool);
601
602   // Requests unbuffered (ie. low latency) input until a pointerup
603   // event occurs.
604   void RequestUnbufferedInputEvents();
605
606   // Requests unbuffered (ie. low latency) input due to debugger being
607   // attached. Debugger needs to paint when stopped in the event handler.
608   void SetNeedsUnbufferedInputForDebugger(bool);
609
610   // Called when the main frame navigates.
611   void DidNavigate();
612
613   // Ensures all queued input in the widget has been processed and the queues
614   // emptied.
615   void FlushInputForTesting(base::OnceClosure done_callback);
616
617   // Called when the widget should get targeting input.
618   void SetMouseCapture(bool capture);
619
620   // Sets the current page scale factor and minimum / maximum limits. Both
621   // limits are initially 1 (no page scale allowed).
622   void SetPageScaleStateAndLimits(float page_scale_factor,
623                                   bool is_pinch_gesture_active,
624                                   float minimum,
625                                   float maximum);
626   void UpdateViewportDescription(
627       const ViewportDescription& viewport_description);
628
629   const viz::LocalSurfaceId& LocalSurfaceIdFromParent();
630
631   ScreenMetricsEmulator* DeviceEmulator();
632
633   // Calculates the selection bounds in the root frame. Returns bounds unchanged
634   // when there is no focused frame or no selection.
635   void CalculateSelectionBounds(
636       gfx::Rect& anchor_in_root_frame,
637       gfx::Rect& focus_in_root_frame,
638       gfx::Rect* bounding_box_in_root_frame = nullptr);
639
640   // Returns if auto resize mode is enabled.
641   bool AutoResizeMode();
642
643   void SetScreenMetricsEmulationParameters(
644       bool enabled,
645       const blink::DeviceEmulationParams& params);
646   void SetScreenInfoAndSize(const display::ScreenInfos& screen_infos,
647                             const gfx::Size& widget_size,
648                             const gfx::Size& visible_viewport_size);
649
650   // Update the surface allocation information, compositor viewport rect and
651   // screen info on the widget.
652   void UpdateSurfaceAndScreenInfo(
653       const viz::LocalSurfaceId& new_local_surface_id,
654       const gfx::Rect& compositor_viewport_pixel_rect,
655       const display::ScreenInfos& screen_infos);
656   // Similar to UpdateSurfaceAndScreenInfo but the surface allocation
657   // and compositor viewport rect remains the same.
658   void UpdateScreenInfo(const display::ScreenInfos& screen_infos);
659   void UpdateSurfaceAndCompositorRect(
660       const viz::LocalSurfaceId& new_local_surface_id,
661       const gfx::Rect& compositor_viewport_pixel_rect);
662   void UpdateCompositorViewportRect(
663       const gfx::Rect& compositor_viewport_pixel_rect);
664   void SetWindowSegments(const std::vector<gfx::Rect>& window_segments);
665   viz::FrameSinkId GetFrameSinkIdAtPoint(const gfx::PointF& point,
666                                          gfx::PointF* local_point);
667
668   // Set the pending window rect. For every SetPendingWindowRect
669   // call there must be an AckPendingWindowRect call.
670   void SetPendingWindowRect(const gfx::Rect& window_screen_rect);
671
672   // Clear a previously set pending window rect. For every SetPendingWindowRect
673   // call there must be an AckPendingWindowRect call.
674   void AckPendingWindowRect();
675
676   // Return the focused WebPlugin if there is one.
677   WebPlugin* GetFocusedPluginContainer();
678
679   // Return if there is a pending scale animation.
680   bool HasPendingPageScaleAnimation();
681
682   // Set the source URL for the compositor.
683   void SetSourceURLForCompositor(ukm::SourceId source_id, const KURL& url);
684
685   // Ask compositor to create the shared memory for smoothness ukm region.
686   base::ReadOnlySharedMemoryRegion CreateSharedMemoryForSmoothnessUkm();
687
688 #if BUILDFLAG(IS_EFL)
689   void NotifyKeyEvent(WebInputEvent::Type type, bool processed) override;
690 #endif
691
692 #if BUILDFLAG(IS_TIZEN)
693   void SetMaxRefreshRate(uint32_t max_refresh_rate) override;
694
695   void SetDrawsTransparentBackground(
696       bool draws_transparent_background) override;
697
698   void SetBackgroundColor(int32_t red,
699                           int32_t green,
700                           int32_t blue,
701                           int32_t alpha) override;
702 #endif
703
704 #if BUILDFLAG(IS_TIZEN)
705   void DidChangeLoadState(bool is_loading) override;
706 #endif
707
708   // Calculate and cache the most up to date line bounding boxes in the document
709   // coordinate space.
710   Vector<gfx::Rect> CalculateVisibleLineBoundsOnScreen();
711
712 #if BUILDFLAG(IS_TIZEN_TV)
713   void NotifyTrackInfoToBrowser(int active_track_id,
714                                 const std::string& url,
715                                 const std::string& lang);
716   void MoveFocusToBrowser(int direction);
717 #endif
718
719  protected:
720   // WidgetBaseClient overrides:
721   void WillBeginMainFrame() override;
722   void ScheduleAnimation() override;
723   void DidBeginMainFrame() override;
724   std::unique_ptr<cc::LayerTreeFrameSink> AllocateNewLayerTreeFrameSink()
725       override;
726   void WasShown(bool was_evicted) override;
727
728   // Whether compositing to LCD text should be auto determined. This can be
729   // overridden by tests to disable this.
730   virtual bool ShouldAutoDetermineCompositingToLCDTextSetting();
731
732   WidgetBase* widget_base_for_testing() const { return widget_base_.get(); }
733
734   // WebFrameWidget overrides.
735   cc::LayerTreeHost* LayerTreeHost() override;
736
737   // Determines whether the drag source is currently dragging.
738   bool doing_drag_and_drop_ = false;
739
740  private:
741   friend class WebViewImpl;
742   friend class ReportTimeSwapPromise;
743
744   void NotifySwapAndPresentationTime(PromiseCallbacks callbacks);
745
746   // WidgetBaseClient overrides.
747   void BeginCommitCompositorFrame() override;
748   void EndCommitCompositorFrame(base::TimeTicks commit_start_time,
749                                 base::TimeTicks commit_finish_time) override;
750   void ApplyViewportChanges(const cc::ApplyViewportChangesArgs& args) override;
751   void RecordDispatchRafAlignedInputTime(
752       base::TimeTicks raf_aligned_input_start_time) override;
753   void SetSuppressFrameRequestsWorkaroundFor704763Only(bool) override;
754   void RecordStartOfFrameMetrics() override;
755   void RecordEndOfFrameMetrics(
756       base::TimeTicks,
757       cc::ActiveFrameSequenceTrackers trackers) override;
758   std::unique_ptr<cc::BeginMainFrameMetrics> GetBeginMainFrameMetrics()
759       override;
760   std::unique_ptr<cc::WebVitalMetrics> GetWebVitalMetrics() override;
761   void BeginUpdateLayers() override;
762   void EndUpdateLayers() override;
763   void DidCommitAndDrawCompositorFrame() override;
764   void DidObserveFirstScrollDelay(
765       base::TimeDelta first_scroll_delay,
766       base::TimeTicks first_scroll_timestamp) override;
767   void DidCompletePageScaleAnimation() override;
768   void FocusChangeComplete() override;
769   void WillHandleGestureEvent(const WebGestureEvent& event,
770                               bool* suppress) override;
771   void WillHandleMouseEvent(const WebMouseEvent& event) override;
772   void ObserveGestureEventAndResult(
773       const WebGestureEvent& gesture_event,
774       const gfx::Vector2dF& unused_delta,
775       const cc::OverscrollBehavior& overscroll_behavior,
776       bool event_processed) override;
777   bool SupportsBufferedTouchEvents() override { return true; }
778   void DidHandleKeyEvent() override;
779   WebTextInputType GetTextInputType() override;
780   void SetCursorVisibilityState(bool is_visible) override;
781   blink::FrameWidget* FrameWidget() override { return this; }
782   void FocusChanged(mojom::blink::FocusState focus_state) override;
783   bool ShouldAckSyntheticInputImmediately() override;
784   void UpdateVisualProperties(
785       const VisualProperties& visual_properties) override;
786   bool UpdateScreenRects(const gfx::Rect& widget_screen_rect,
787                          const gfx::Rect& window_screen_rect) override;
788 #if BUILDFLAG(IS_EFL)
789   void GetContentSnapshot(const gfx::Rect& snapshot_rect,
790                           float page_scale_factor,
791                           SkBitmap* snapshot) override;
792   SkColor GetBackgroundColor() override;
793   gfx::RectF UpdateFocusedNodeBounds() override;
794   void SetLongPollingGlobalTimeout(uint64_t timeout) override;
795   void ResetLastInteractedElements() override;
796   void PrintToPdf(uint32_t width,
797                   uint32_t height,
798                   const base::FilePath& filename) override;
799   void SetMainFrameScrollbarVisible(bool visible) override;
800   bool RequestMainFrameScrollbarVisible(bool& visible) override;
801   bool QueryInputType() override;
802   void SelectClosestWord(uint32_t x, uint32_t y) override;
803   void SelectFocusedLink() override;
804   gfx::Rect RequestSelectionRect() override;
805 #if BUILDFLAG(IS_TIZEN_TV)
806   bool IsHitScrollbar() override;
807   bool IsMouseDownEventSwallowed() override;
808   void SetFloatVideoWindowState(bool enabled) override;
809   void SuspendNetworkLoading() override;
810   void ResumeNetworkLoading() override;
811 #endif
812 #endif
813
814 #if BUILDFLAG(IS_TIZEN)
815   void PauseScheduledTasks() override;
816   void UnPauseScheduledTasks() override;
817 #endif
818
819   void OrientationChanged() override;
820   void DidUpdateSurfaceAndScreen(
821       const display::ScreenInfos& previous_original_screen_infos) override;
822   gfx::Rect ViewportVisibleRect() override;
823   absl::optional<display::mojom::blink::ScreenOrientation>
824   ScreenOrientationOverride() override;
825   void WasHidden() override;
826   void RunPaintBenchmark(int repeat_count,
827                          cc::PaintBenchmarkResult& result) override;
828   KURL GetURLForDebugTrace() override;
829   float GetTestingDeviceScaleFactorOverride() override;
830   void CountDroppedPointerDownForEventTiming(unsigned count) override;
831   // mojom::blink::FrameWidget overrides.
832   void DragTargetDragEnter(const WebDragData&,
833                            const gfx::PointF& point_in_viewport,
834                            const gfx::PointF& screen_point,
835                            DragOperationsMask operations_allowed,
836                            uint32_t key_modifiers,
837                            DragTargetDragEnterCallback callback) override;
838   void DragTargetDragOver(const gfx::PointF& point_in_viewport,
839                           const gfx::PointF& screen_point,
840                           DragOperationsMask operations_allowed,
841                           uint32_t key_modifiers,
842                           DragTargetDragOverCallback callback) override;
843   void DragTargetDragLeave(const gfx::PointF& point_in_viewport,
844                            const gfx::PointF& screen_point) override;
845   void DragTargetDrop(const WebDragData&,
846                       const gfx::PointF& point_in_viewport,
847                       const gfx::PointF& screen_point,
848                       uint32_t key_modifiers,
849                       base::OnceClosure callback) override;
850   void DragSourceSystemDragEnded() override;
851   void OnStartStylusWriting(OnStartStylusWritingCallback callback) override;
852   void SetBackgroundOpaque(bool opaque) override;
853   void SetActive(bool active) override;
854   // For both mainframe and childframe change the text direction of the
855   // currently selected input field (if any).
856   void SetTextDirection(base::i18n::TextDirection direction) override;
857   // Sets the inherited effective touch action on an out-of-process iframe.
858   void SetInheritedEffectiveTouchActionForSubFrame(
859       WebTouchAction touch_action) override;
860   // Toggles render throttling for an out-of-process iframe. Local frames are
861   // throttled based on their visibility in the viewport, but remote frames
862   // have to have throttling information propagated from parent to child
863   // across processes.
864   void UpdateRenderThrottlingStatusForSubFrame(bool is_throttled,
865                                                bool subtree_throttled,
866                                                bool display_locked) override;
867   void EnableDeviceEmulation(const DeviceEmulationParams& parameters) override;
868   void DisableDeviceEmulation() override;
869   // Sets the inert bit on an out-of-process iframe, causing it to ignore
870   // input.
871   void SetIsInertForSubFrame(bool inert) override;
872 #if BUILDFLAG(IS_MAC)
873   void GetStringAtPoint(const gfx::Point& point_in_local_root,
874                         GetStringAtPointCallback callback) override;
875 #endif
876
877 #if BUILDFLAG(IS_TIZEN_TV)
878   //Browser edge scroll
879   void EdgeScrollBy(const gfx::Point& offset, const gfx::Point& mouse_position) override;
880   // notify web browser video playing status
881   bool IsVideoPlaying() override;
882   void SetTranslatedURL(const WTF::String& url) override;
883   void SetParentalRatingResult(const WTF::String& url, bool is_pass) override;
884   void SetPreferSubtitleLang(const WTF::String lang_list) override;
885 #endif
886
887   // mojom::blink::FrameWidgetInputHandler overrides.
888   void AddImeTextSpansToExistingText(
889       uint32_t start,
890       uint32_t end,
891       const Vector<ui::ImeTextSpan>& ime_text_spans) override;
892   void ClearImeTextSpansByType(uint32_t start,
893                                uint32_t end,
894                                ui::ImeTextSpan::Type type) override;
895   void SetCompositionFromExistingText(
896       int32_t start,
897       int32_t end,
898       const Vector<ui::ImeTextSpan>& ime_text_spans) override;
899   void ExtendSelectionAndDelete(int32_t before, int32_t after) override;
900   void ExtendSelectionAndReplace(uint32_t before,
901                                  uint32_t after,
902                                  const String& replacement_text) override;
903   void DeleteSurroundingText(int32_t before, int32_t after) override;
904   void DeleteSurroundingTextInCodePoints(int32_t before,
905                                          int32_t after) override;
906   void SetEditableSelectionOffsets(int32_t start, int32_t end) override;
907   void ExecuteEditCommand(const String& command, const String& value) override;
908   void Undo() override;
909   void Redo() override;
910   void Cut() override;
911   void Copy() override;
912   void CopyToFindPboard() override;
913   void CenterSelection() override;
914   void Paste() override;
915   void PasteAndMatchStyle() override;
916   void Delete() override;
917   void SelectAll() override;
918   void CollapseSelection() override;
919   void Replace(const String& word) override;
920   void ReplaceMisspelling(const String& word) override;
921   void SelectRange(const gfx::Point& base_in_dips,
922                    const gfx::Point& extent_in_dips) override;
923   void AdjustSelectionByCharacterOffset(
924       int32_t start,
925       int32_t end,
926       mojom::blink::SelectionMenuBehavior behavior) override;
927   void MoveRangeSelectionExtent(const gfx::Point& extent_in_dips) override;
928   void ScrollFocusedEditableNodeIntoView() override;
929   void WaitForPageScaleAnimationForTesting(
930       WaitForPageScaleAnimationForTestingCallback callback) override;
931   void MoveCaret(const gfx::Point& point_in_dips) override;
932   void SelectAroundCaret(mojom::blink::SelectionGranularity granularity,
933                          bool should_show_handle,
934                          bool should_show_context_menu,
935                          SelectAroundCaretCallback callback) override;
936
937   // PageWidgetEventHandler overrides:
938   WebInputEventResult HandleKeyEvent(const WebKeyboardEvent&) override;
939   void HandleMouseDown(LocalFrame&, const WebMouseEvent&) override;
940   void HandleMouseLeave(LocalFrame&, const WebMouseEvent&) override;
941   WebInputEventResult HandleMouseUp(LocalFrame&, const WebMouseEvent&) override;
942   WebInputEventResult HandleGestureEvent(const WebGestureEvent&) override;
943   WebInputEventResult HandleMouseWheel(LocalFrame&,
944                                        const WebMouseWheelEvent&) override;
945   WebInputEventResult HandleCharEvent(const WebKeyboardEvent&) override;
946
947   WebInputEventResult HandleCapturedMouseEvent(const WebCoalescedInputEvent&);
948   void MouseContextMenu(const WebMouseEvent&);
949   void CancelDrag();
950   void PresentationCallbackForMeaningfulLayout(base::TimeTicks);
951
952   void ForEachRemoteFrameControlledByWidget(
953       base::FunctionRef<void(RemoteFrame*)> callback);
954
955   void SetWindowRectSynchronously(const gfx::Rect& new_window_rect);
956
957   void SendOverscrollEventFromImplSide(const gfx::Vector2dF& overscroll_delta,
958                                        cc::ElementId scroll_latched_element_id);
959   void SendScrollEndEventFromImplSide(bool affects_outer_viewport,
960                                       cc::ElementId scroll_latched_element_id);
961
962   void RecordManipulationTypeCounts(cc::ManipulationInfo info);
963
964   enum DragAction { kDragEnter, kDragOver };
965   // Consolidate some common code between starting a drag over a target and
966   // updating a drag over a target. If we're starting a drag, |isEntering|
967   // should be true.
968   void DragTargetDragEnterOrOver(const gfx::PointF& point_in_viewport,
969                                  const gfx::PointF& screen_point,
970                                  DragAction,
971                                  uint32_t key_modifiers);
972
973   // Helper function to call VisualViewport::viewportToRootFrame().
974   gfx::PointF ViewportToRootFrame(const gfx::PointF& point_in_viewport) const;
975
976   WebViewImpl* View() const;
977
978   // Returns the page object associated with this widget. This may be null when
979   // the page is shutting down, but will be valid at all other times.
980   Page* GetPage() const;
981
982   mojom::blink::FrameWidgetHost* GetAssociatedFrameWidgetHost() const;
983
984   void InitializeCompositingInternal(const display::ScreenInfos& screen_infos,
985                                      const cc::LayerTreeSettings* settings,
986                                      WebFrameWidget* previous_widget);
987
988   // Notifies RenderWidgetHostImpl that the frame widget has painted something.
989   void DidMeaningfulLayout(WebMeaningfulLayout layout_type);
990
991   // Enable or disable auto-resize. This is part of
992   // UpdateVisualProperties though tests may call to it more directly.
993   void SetAutoResizeMode(bool auto_resize,
994                          const gfx::Size& min_size_before_dsf,
995                          const gfx::Size& max_size_before_dsf,
996                          float device_scale_factor);
997
998   void ApplyViewportIntersection(
999       mojom::blink::ViewportIntersectionStatePtr intersection_state);
1000
1001   // Called when a gesture event has been processed.
1002   void DidHandleGestureEvent(const WebGestureEvent& event);
1003
1004   // Called to update if pointerrawupdate events should be sent.
1005   void SetHasPointerRawUpdateEventHandlers(bool);
1006
1007   // Helper function to process events while pointer locked.
1008   void PointerLockMouseEvent(const WebCoalescedInputEvent&);
1009   bool IsPointerLocked();
1010
1011   // The fullscreen granted status from the most recent VisualProperties update.
1012   bool IsFullscreenGranted();
1013
1014   // Set the compositing scale factor for this widget and notify remote frames
1015   // to update their compositing scale factor.
1016   void NotifyCompositingScaleFactorChanged(float compositing_scale_factor);
1017
1018   void NotifyPageScaleFactorChanged(float page_scale_factor,
1019                                     bool is_pinch_gesture_active);
1020
1021   // Helper for notifying frame-level objects that care about input events.
1022   // TODO: With some effort, this could be folded into a common implementation
1023   // of WebViewImpl::HandleInputEvent and WebFrameWidgetImpl::HandleInputEvent.
1024   void NotifyInputObservers(const WebCoalescedInputEvent& coalesced_event);
1025
1026   Frame* FocusedCoreFrame() const;
1027
1028   // Returns the currently focused `Element` in any `LocalFrame` owned by the
1029   // associated `WebView`.
1030   Element* FocusedElement() const;
1031
1032   gfx::Rect GetAbsoluteCaretBounds();
1033
1034   // Perform a hit test for a point relative to the root frame of the page.
1035   HitTestResult HitTestResultForRootFramePos(
1036       const gfx::PointF& pos_in_root_frame);
1037
1038   // Called during |UpdateVisualProperties| to apply the new size to the widget.
1039   void ApplyVisualPropertiesSizing(const VisualProperties& visual_properties);
1040
1041   // Returns true iff the visual property state contains an update that will
1042   // change the fullscreen state (e.g. on/off or current display).
1043   bool DidChangeFullscreenState(
1044       const VisualProperties& visual_properties) const;
1045
1046   void NotifyZoomLevelChanged(LocalFrame* root);
1047
1048   // Satisfy the render blocking condition for cross-document view transitions.
1049   void NotifyViewTransitionRenderingHasBegun();
1050
1051   // True when `this` should ignore input events.
1052   bool ShouldIgnoreInputEvents();
1053
1054   // Stores the current composition line bounds. These bounds are rectangles
1055   // which surround each line of text in a currently focused input or textarea
1056   // element.
1057   Vector<gfx::Rect> input_visible_line_bounds_;
1058
1059   // A copy of the web drop data object we received from the browser.
1060   Member<DataObject> current_drag_data_;
1061
1062   // The available drag operations (copy, move link...) allowed by the source.
1063   DragOperationsMask operations_allowed_ = kDragOperationNone;
1064
1065   // The current drag operation as negotiated by the source and destination.
1066   // When not equal to DragOperationNone, the drag data can be dropped onto the
1067   // current drop target in this WebView (the drop target can accept the drop).
1068   DragController::Operation drag_operation_;
1069
1070   // This field stores drag/drop related info for the event that is currently
1071   // being handled. If the current event results in starting a drag/drop
1072   // session, this info is sent to the browser along with other drag/drop info.
1073   mojom::blink::DragEventSourceInfo possible_drag_event_info_;
1074
1075   // Base functionality all widgets have. This is a member as to avoid
1076   // complicated inheritance structures.
1077   std::unique_ptr<WidgetBase> widget_base_;
1078
1079   // Compositing scale factor for all frames attached to this widget sent from
1080   // the remote parent frame.
1081   float compositing_scale_factor_ = 1.f;
1082
1083   // The last seen page scale state, which comes from the main frame if we're
1084   // in a child frame. This state is propagated through the RenderWidget tree
1085   // passed to any new child RenderWidget.
1086   float page_scale_factor_in_mainframe_ = 1.f;
1087   bool is_pinch_gesture_active_in_mainframe_ = false;
1088
1089   // If set, the (plugin) element which has mouse capture.
1090   Member<HTMLPlugInElement> mouse_capture_element_;
1091
1092   // The size of the widget in viewport coordinates. This is slightly different
1093   // than the WebViewImpl::size_ since isn't set in auto resize mode.
1094   absl::optional<gfx::Size> size_;
1095
1096   // The amount the top-most widget has been resized by the virtual keyboard,
1097   // in physical pixels.
1098   int virtual_keyboard_resize_height_physical_px_ = 0;
1099
1100   static bool ignore_input_events_;
1101
1102   const viz::FrameSinkId frame_sink_id_;
1103
1104   // WebFrameWidget is associated with a subtree of the frame tree,
1105   // corresponding to a maximal connected tree of LocalFrames. This member
1106   // points to the root of that subtree.
1107   Member<WebLocalFrameImpl> local_root_;
1108
1109   mojom::blink::DisplayMode display_mode_;
1110   ui::WindowShowState window_show_state_;
1111   bool resizable_;
1112
1113   WebVector<gfx::Rect> window_segments_;
1114
1115   // This is owned by the LayerTreeHostImpl, and should only be used on the
1116   // compositor thread, so we keep the TaskRunner where you post tasks to
1117   // make that happen.
1118   base::WeakPtr<AnimationWorkletMutatorDispatcherImpl> mutator_dispatcher_;
1119   scoped_refptr<base::SingleThreadTaskRunner> mutator_task_runner_;
1120
1121   // The |paint_dispatcher_| should only be dereferenced on the
1122   // |paint_task_runner_| (in practice this is the compositor thread). We keep a
1123   // copy of it here to provide to new PaintWorkletProxyClient objects (which
1124   // run on the worklet thread) so that they can talk to the
1125   // PaintWorkletPaintDispatcher on the compositor thread.
1126   base::WeakPtr<PaintWorkletPaintDispatcher> paint_dispatcher_;
1127   scoped_refptr<base::SingleThreadTaskRunner> paint_task_runner_;
1128
1129   // WebFrameWidgetImpl is not tied to ExecutionContext
1130   HeapMojoAssociatedRemote<mojom::blink::FrameWidgetHost> frame_widget_host_{
1131       nullptr};
1132   // WebFrameWidgetImpl is not tied to ExecutionContext
1133   HeapMojoAssociatedReceiver<mojom::blink::FrameWidget, WebFrameWidgetImpl>
1134       receiver_{this, nullptr};
1135   HeapMojoReceiver<viz::mojom::blink::InputTargetClient, WebFrameWidgetImpl>
1136       input_target_receiver_{this, nullptr};
1137
1138   // Different consumers in the browser process makes different assumptions, so
1139   // must always send the first IPC regardless of value.
1140   absl::optional<bool> has_touch_handlers_;
1141
1142   Vector<mojom::blink::EditCommandPtr> edit_commands_;
1143
1144   absl::optional<gfx::Point> host_context_menu_location_;
1145   uint32_t last_capture_sequence_number_ = 0u;
1146
1147   // Indicates whether tab-initiated fullscreen was granted.
1148   bool is_fullscreen_granted_ = false;
1149
1150   // Indicates whether we need to consume scroll gestures to move cursor.
1151   bool swipe_to_move_cursor_activated_ = false;
1152
1153   // Set when a measurement begins, reset when the measurement is taken.
1154   absl::optional<base::TimeTicks> update_layers_start_time_;
1155
1156   // Metrics for gathering time for commit of compositor frame.
1157   absl::optional<base::TimeTicks> commit_compositor_frame_start_time_;
1158   absl::optional<base::TimeTicks> next_commit_compositor_frame_start_time_;
1159
1160   // Present when emulation is enabled, only on a main frame's WebFrameWidget.
1161   // Used to override values given from the browser such as ScreenInfo,
1162   // WidgetScreenRect, WindowScreenRect, and the widget's size.
1163   Member<ScreenMetricsEmulator> device_emulator_;
1164
1165   Member<AnimationFrameTimingMonitor> animation_frame_timing_monitor_;
1166
1167   // keyPress events to be suppressed if the associated keyDown event was
1168   // handled.
1169   bool suppress_next_keypress_event_ = false;
1170
1171   // Whether drag and drop is supported by this widget. When disabled
1172   // any drag operation that is started will be canceled immediately.
1173   bool drag_and_drop_disabled_ = false;
1174
1175   // A callback client for non-composited frame widgets.
1176   WebNonCompositedWidgetClient* non_composited_client_ = nullptr;
1177
1178   // This struct contains data that is only valid for child local root widgets.
1179   // You should use `child_data()` to access it.
1180   struct ChildLocalRootData {
1181     gfx::Rect compositor_visible_rect;
1182     bool did_suspend_parsing = false;
1183   } child_local_root_data_;
1184
1185   ChildLocalRootData& child_data() {
1186     DCHECK(ForSubframe());
1187     return child_local_root_data_;
1188   }
1189
1190   // Web tests override the zoom factor in the renderer with this. We store it
1191   // to keep the override if the browser passes along VisualProperties with the
1192   // real device scale factor. A value of -INFINITY means this is ignored.
1193   // It is always valid to read this variable but it can only be set for main
1194   // frame widgets.
1195   double zoom_level_for_testing_ = -INFINITY;
1196
1197   // Web tests override the device scale factor in the renderer with this. We
1198   // store it to keep the override if the browser passes along VisualProperties
1199   // with the real device scale factor. A value of 0.f means this is ignored.
1200   // It is always valid to read this variable but it can only be set for main
1201   // frame widgets.
1202   float device_scale_factor_for_testing_ = 0;
1203
1204   // This struct contains data that is only valid for main frame widgets.
1205   // You should use `main_data()` to access it.
1206   struct MainFrameData {
1207     // `UpdateLifecycle()` generates `WebMeaningfulLayout` events these
1208     // variables track what events should be generated. They are only applicable
1209     // for main frame widgets.
1210     bool should_dispatch_first_visually_non_empty_layout = false;
1211     bool should_dispatch_first_layout_after_finished_parsing = false;
1212     bool should_dispatch_first_layout_after_finished_loading = false;
1213     // Last background color sent to the browser. Only set for main frames.
1214     absl::optional<SkColor> last_background_color;
1215     // This bit is used to tell if this is a nested widget (an "inner web
1216     // contents") like a <webview> or <portal> widget. If false, the widget is
1217     // the top level widget.
1218     bool is_for_nested_main_frame = false;
1219   } main_frame_data_;
1220
1221   MainFrameData& main_data() {
1222     DCHECK(ForMainFrame());
1223     return main_frame_data_;
1224   }
1225
1226   const MainFrameData& main_data() const {
1227     DCHECK(ForMainFrame());
1228     return main_frame_data_;
1229   }
1230
1231   // Whether this widget is for a child local root, or otherwise a main frame.
1232   // Prefer using |ForSubframe()| for distinguishing subframes and
1233   // |widget_base_.is_embedded()| for subframes and embedded main frames (i.e.,
1234   // all embedded scenarios).
1235   const bool is_for_child_local_root_;
1236
1237   // Whether this widget is for a portal, guest view, or top level frame.
1238   // These may have a page scale node, so it is important to plumb this
1239   // information through to avoid breaking assumptions.
1240   const bool is_for_scalable_page_;
1241
1242   WaitForPageScaleAnimationForTestingCallback
1243       page_scale_animation_for_testing_callback_;
1244
1245   // This stores the last hidden page popup. If a GestureTap attempts to open
1246   // the popup that is closed by its previous GestureTapDown, the popup remains
1247   // closed.
1248   scoped_refptr<WebPagePopupImpl> last_hidden_page_popup_;
1249
1250   base::WeakPtrFactory<mojom::blink::FrameWidgetInputHandler>
1251       input_handler_weak_ptr_factory_{this};
1252 };
1253
1254 }  // namespace blink
1255
1256 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_FRAME_WEB_FRAME_WIDGET_IMPL_H_