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

   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 #include "third_party/blink/renderer/core/frame/web_frame_widget_impl.h"
  32
  33 #include <memory>
  34 #include <utility>
  35
  36 #include "base/auto_reset.h"
  37 #include "base/debug/crash_logging.h"
  38 #include "base/debug/dump_without_crashing.h"
  39 #include "base/functional/callback_helpers.h"
  40 #include "base/functional/function_ref.h"
  41 #include "base/metrics/histogram_macros.h"
  42 #include "base/numerics/safe_conversions.h"
  43 #include "base/task/single_thread_task_runner.h"
  44 #include "base/time/time.h"
  45 #include "build/build_config.h"
  46 #include "cc/animation/animation_host.h"
  47 #include "cc/base/features.h"
  48 #include "cc/trees/compositor_commit_data.h"
  49 #include "cc/trees/layer_tree_host.h"
  50 #include "cc/trees/swap_promise.h"
  51 #include "cc/trees/ukm_manager.h"
  52 #include "third_party/blink/public/common/features.h"
  53 #include "third_party/blink/public/mojom/frame/intrinsic_sizing_info.mojom-blink.h"
  54 #include "third_party/blink/public/mojom/input/input_handler.mojom-blink.h"
  55 #include "third_party/blink/public/mojom/input/touch_event.mojom-blink.h"
  56 #include "third_party/blink/public/platform/platform.h"
  57 #include "third_party/blink/public/web/web_autofill_client.h"
  58 #include "third_party/blink/public/web/web_local_frame.h"
  59 #include "third_party/blink/public/web/web_local_frame_client.h"
  60 #include "third_party/blink/public/web/web_non_composited_widget_client.h"
  61 #include "third_party/blink/public/web/web_performance_metrics_for_reporting.h"
  62 #include "third_party/blink/public/web/web_plugin.h"
  63 #include "third_party/blink/public/web/web_settings.h"
  64 #include "third_party/blink/public/web/web_view_client.h"
  65 #include "third_party/blink/renderer/core/content_capture/content_capture_manager.h"
  66 #include "third_party/blink/renderer/core/core_initializer.h"
  67 #include "third_party/blink/renderer/core/dom/element.h"
  68 #include "third_party/blink/renderer/core/dom/focus_params.h"
  69 #include "third_party/blink/renderer/core/dom/layout_tree_builder_traversal.h"
  70 #include "third_party/blink/renderer/core/editing/editing_utilities.h"
  71 #include "third_party/blink/renderer/core/editing/ephemeral_range.h"
  72 #include "third_party/blink/renderer/core/editing/frame_selection.h"
  73 #include "third_party/blink/renderer/core/editing/ime/edit_context.h"
  74 #include "third_party/blink/renderer/core/editing/ime/input_method_controller.h"
  75 #include "third_party/blink/renderer/core/editing/ime/stylus_writing_gesture.h"
  76 #include "third_party/blink/renderer/core/editing/selection_template.h"
  77 #include "third_party/blink/renderer/core/events/current_input_event.h"
  78 #include "third_party/blink/renderer/core/events/pointer_event_factory.h"
  79 #include "third_party/blink/renderer/core/events/web_input_event_conversion.h"
  80 #include "third_party/blink/renderer/core/events/wheel_event.h"
  81 #include "third_party/blink/renderer/core/exported/web_dev_tools_agent_impl.h"
  82 #include "third_party/blink/renderer/core/exported/web_plugin_container_impl.h"
  83 #include "third_party/blink/renderer/core/exported/web_settings_impl.h"
  84 #include "third_party/blink/renderer/core/exported/web_view_impl.h"
  85 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
  86 #include "third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h"
  87 #include "third_party/blink/renderer/core/frame/local_frame_view.h"
  88 #include "third_party/blink/renderer/core/frame/remote_frame_client.h"
  89 #include "third_party/blink/renderer/core/frame/screen.h"
  90 #include "third_party/blink/renderer/core/frame/screen_metrics_emulator.h"
  91 #include "third_party/blink/renderer/core/frame/settings.h"
  92 #include "third_party/blink/renderer/core/frame/visual_viewport.h"
  93 #include "third_party/blink/renderer/core/frame/web_feature.h"
  94 #include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
  95 #include "third_party/blink/renderer/core/html/fenced_frame/document_fenced_frames.h"
  96 #include "third_party/blink/renderer/core/html/fenced_frame/html_fenced_frame_element.h"
  97 #include "third_party/blink/renderer/core/html/forms/text_control_element.h"
  98 #include "third_party/blink/renderer/core/html/html_frame_owner_element.h"
  99 #include "third_party/blink/renderer/core/html/html_plugin_element.h"
 100 #include "third_party/blink/renderer/core/html/portal/document_portals.h"
 101 #include "third_party/blink/renderer/core/html/portal/portal_contents.h"
 102 #include "third_party/blink/renderer/core/input/context_menu_allowed_scope.h"
 103 #include "third_party/blink/renderer/core/input/event_handler.h"
 104 #include "third_party/blink/renderer/core/input/touch_action_util.h"
 105 #include "third_party/blink/renderer/core/layout/hit_test_location.h"
 106 #include "third_party/blink/renderer/core/layout/hit_test_request.h"
 107 #include "third_party/blink/renderer/core/layout/layout_box.h"
 108 #include "third_party/blink/renderer/core/layout/layout_embedded_content.h"
 109 #include "third_party/blink/renderer/core/layout/layout_object.h"
 110 #include "third_party/blink/renderer/core/layout/layout_shift_tracker.h"
 111 #include "third_party/blink/renderer/core/layout/layout_text.h"
 112 #include "third_party/blink/renderer/core/loader/document_loader.h"
 113 #include "third_party/blink/renderer/core/loader/interactive_detector.h"
 114 #include "third_party/blink/renderer/core/page/context_menu_controller.h"
 115 #include "third_party/blink/renderer/core/page/drag_actions.h"
 116 #include "third_party/blink/renderer/core/page/drag_data.h"
 117 #include "third_party/blink/renderer/core/page/focus_controller.h"
 118 #include "third_party/blink/renderer/core/page/link_highlight.h"
 119 #include "third_party/blink/renderer/core/page/page.h"
 120 #include "third_party/blink/renderer/core/page/page_animator.h"
 121 #include "third_party/blink/renderer/core/page/pointer_lock_controller.h"
 122 #include "third_party/blink/renderer/core/page/scrolling/fragment_anchor.h"
 123 #include "third_party/blink/renderer/core/page/validation_message_client.h"
 124 #include "third_party/blink/renderer/core/page/viewport_description.h"
 125 #include "third_party/blink/renderer/core/paint/timing/first_meaningful_paint_detector.h"
 126 #include "third_party/blink/renderer/core/paint/timing/paint_timing_detector.h"
 127 #include "third_party/blink/renderer/core/probe/core_probes.h"
 128 #include "third_party/blink/renderer/core/scroll/scroll_into_view_util.h"
 129 #include "third_party/blink/renderer/core/scroll/scrollbar_theme.h"
 130 #include "third_party/blink/renderer/core/timing/dom_window_performance.h"
 131 #include "third_party/blink/renderer/core/timing/window_performance.h"
 132 #include "third_party/blink/renderer/core/view_transition/view_transition.h"
 133 #include "third_party/blink/renderer/core/view_transition/view_transition_utils.h"
 134 #include "third_party/blink/renderer/platform/graphics/animation_worklet_mutator_dispatcher_impl.h"
 135 #include "third_party/blink/renderer/platform/graphics/compositor_mutator_client.h"
 136 #include "third_party/blink/renderer/platform/graphics/paint_worklet_paint_dispatcher.h"
 137 #include "third_party/blink/renderer/platform/heap/cross_thread_handle.h"
 138 #include "third_party/blink/renderer/platform/heap/persistent.h"
 139 #include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
 140 #include "third_party/blink/renderer/platform/keyboard_codes.h"
 141 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 142 #include "third_party/blink/renderer/platform/scheduler/public/non_main_thread.h"
 143 #include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
 144 #include "third_party/blink/renderer/platform/widget/input/main_thread_event_queue.h"
 145 #include "third_party/blink/renderer/platform/widget/input/widget_input_handler_manager.h"
 146 #include "third_party/blink/renderer/platform/widget/widget_base.h"
 147 #include "third_party/blink/renderer/platform/wtf/cross_thread_copier_base.h"
 148 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
 149 #include "third_party/blink/renderer/platform/wtf/functional.h"
 150 #include "ui/base/dragdrop/mojom/drag_drop_types.mojom-blink.h"
 151 #include "ui/base/ui_base_types.h"
 152 #include "ui/gfx/geometry/point_conversions.h"
 153
 154 #if BUILDFLAG(IS_MAC)
 155 #include "third_party/blink/renderer/core/editing/substring_util.h"
 156 #include "third_party/blink/renderer/platform/fonts/mac/attributed_string_type_converter.h"
 157 #include "ui/base/mojom/attributed_string.mojom-blink.h"
 158 #include "ui/gfx/geometry/point.h"
 159 #endif
 160
 161 #if BUILDFLAG(IS_EFL)
 162 #include "skia/ext/image_operations.h"
 163 #include "third_party/blink/renderer/core/html/forms/html_input_element.h"
 164 #include "third_party/blink/renderer/core/input_type_names.h"
 165 #endif
 166
 167 namespace WTF {
 168
 169 template <>
 170 struct CrossThreadCopier<blink::WebFrameWidgetImpl::PromiseCallbacks>
 171     : public CrossThreadCopierByValuePassThrough<
 172           blink::WebFrameWidgetImpl::PromiseCallbacks> {
 173   STATIC_ONLY(CrossThreadCopier);
 174 };
 175
 176 }  // namespace WTF
 177
 178 namespace blink {
 179
 180 namespace {
 181
 182 using ::ui::mojom::blink::DragOperation;
 183
 184 void ForEachLocalFrameControlledByWidget(
 185     LocalFrame* frame,
 186     base::FunctionRef<void(WebLocalFrameImpl*)> callback) {
 187   callback(WebLocalFrameImpl::FromFrame(frame));
 188   for (Frame* child = frame->FirstChild(); child;
 189        child = child->NextSibling()) {
 190     if (auto* local_child = DynamicTo<LocalFrame>(child)) {
 191       ForEachLocalFrameControlledByWidget(local_child, callback);
 192     }
 193   }
 194 }
 195
 196 // Iterate the remote children that will be controlled by the widget. Skip over
 197 // any RemoteFrames have have another LocalFrame root as their parent.
 198 void ForEachRemoteFrameChildrenControlledByWidget(
 199     Frame* frame,
 200     base::FunctionRef<void(RemoteFrame*)> callback) {
 201   for (Frame* child = frame->Tree().FirstChild(); child;
 202        child = child->Tree().NextSibling()) {
 203     if (auto* remote_frame = DynamicTo<RemoteFrame>(child)) {
 204       callback(remote_frame);
 205       ForEachRemoteFrameChildrenControlledByWidget(remote_frame, callback);
 206     } else if (auto* local_frame = DynamicTo<LocalFrame>(child)) {
 207       // If iteration arrives at a local root then don't descend as it will be
 208       // controlled by another widget.
 209       if (!local_frame->IsLocalRoot()) {
 210         ForEachRemoteFrameChildrenControlledByWidget(local_frame, callback);
 211       }
 212     }
 213   }
 214
 215   if (auto* local_frame = DynamicTo<LocalFrame>(frame)) {
 216     if (Document* document = local_frame->GetDocument()) {
 217       // Iterate on any portals owned by a local frame.
 218       if (auto* portals = DocumentPortals::Get(*document)) {
 219         for (PortalContents* portal : portals->GetPortals()) {
 220           if (RemoteFrame* remote_frame = portal->GetFrame())
 221             callback(remote_frame);
 222         }
 223       }
 224       // Iterate on any fenced frames owned by a local frame.
 225       if (auto* fenced_frames = DocumentFencedFrames::Get(*document)) {
 226         for (HTMLFencedFrameElement* fenced_frame :
 227              fenced_frames->GetFencedFrames()) {
 228           callback(To<RemoteFrame>(fenced_frame->ContentFrame()));
 229         }
 230       }
 231     }
 232   }
 233 }
 234
 235 viz::FrameSinkId GetRemoteFrameSinkId(const HitTestResult& result) {
 236   Node* node = result.InnerNode();
 237   auto* frame_owner = DynamicTo<HTMLFrameOwnerElement>(node);
 238   if (!frame_owner || !frame_owner->ContentFrame() ||
 239       !frame_owner->ContentFrame()->IsRemoteFrame())
 240     return viz::FrameSinkId();
 241
 242   RemoteFrame* remote_frame = To<RemoteFrame>(frame_owner->ContentFrame());
 243   if (remote_frame->IsIgnoredForHitTest())
 244     return viz::FrameSinkId();
 245   LayoutObject* object = node->GetLayoutObject();
 246   DCHECK(object);
 247   if (!object->IsBox())
 248     return viz::FrameSinkId();
 249
 250   PhysicalOffset local_point(ToRoundedPoint(result.LocalPoint()));
 251   if (!To<LayoutBox>(object)->ComputedCSSContentBoxRect().Contains(local_point))
 252     return viz::FrameSinkId();
 253
 254   return remote_frame->GetFrameSinkId();
 255 }
 256
 257 bool IsElementNotNullAndEditable(Element* element) {
 258   if (!element)
 259     return false;
 260
 261   if (IsEditable(*element))
 262     return true;
 263
 264   auto* text_control = ToTextControlOrNull(element);
 265   if (text_control && !text_control->IsDisabledOrReadOnly())
 266     return true;
 267
 268   if (EqualIgnoringASCIICase(element->FastGetAttribute(html_names::kRoleAttr),
 269                              "textbox")) {
 270     return true;
 271   }
 272
 273   return false;
 274 }
 275
 276 bool& InputDisabledPerBrowsingContextGroup(
 277     const base::UnguessableToken& token) {
 278   using BrowsingContextGroupMap = std::map<base::UnguessableToken, bool>;
 279   DEFINE_STATIC_LOCAL(BrowsingContextGroupMap, values, ());
 280   return values[token];
 281 }
 282
 283 }  // namespace
 284
 285 // WebFrameWidget ------------------------------------------------------------
 286
 287 bool WebFrameWidgetImpl::ignore_input_events_ = false;
 288
 289 // static
 290 void WebFrameWidgetImpl::SetIgnoreInputEvents(
 291     const base::UnguessableToken& browsing_context_group_token,
 292     bool value) {
 293   if (base::FeatureList::IsEnabled(
 294           features::kPausePagesPerBrowsingContextGroup)) {
 295     CHECK_NE(InputDisabledPerBrowsingContextGroup(browsing_context_group_token),
 296              value);
 297     InputDisabledPerBrowsingContextGroup(browsing_context_group_token) = value;
 298   } else {
 299     CHECK_NE(ignore_input_events_, value);
 300     ignore_input_events_ = value;
 301   }
 302 }
 303
 304 // static
 305 bool WebFrameWidgetImpl::IgnoreInputEvents(
 306     const base::UnguessableToken& browsing_context_group_token) {
 307   if (base::FeatureList::IsEnabled(
 308           features::kPausePagesPerBrowsingContextGroup)) {
 309     return InputDisabledPerBrowsingContextGroup(browsing_context_group_token);
 310   } else {
 311     return ignore_input_events_;
 312   }
 313 }
 314
 315 WebFrameWidgetImpl::WebFrameWidgetImpl(
 316     base::PassKey<WebLocalFrame>,
 317     CrossVariantMojoAssociatedRemote<mojom::blink::FrameWidgetHostInterfaceBase>
 318         frame_widget_host,
 319     CrossVariantMojoAssociatedReceiver<mojom::blink::FrameWidgetInterfaceBase>
 320         frame_widget,
 321     CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase>
 322         widget_host,
 323     CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase>
 324         widget,
 325     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
 326     const viz::FrameSinkId& frame_sink_id,
 327     bool hidden,
 328     bool never_composited,
 329     bool is_for_child_local_root,
 330     bool is_for_nested_main_frame,
 331     bool is_for_scalable_page)
 332     : widget_base_(std::make_unique<WidgetBase>(
 333           /*widget_base_client=*/this,
 334           std::move(widget_host),
 335           std::move(widget),
 336           task_runner,
 337           hidden,
 338           never_composited,
 339           /*is_embedded=*/is_for_child_local_root || is_for_nested_main_frame,
 340           is_for_scalable_page)),
 341       frame_sink_id_(frame_sink_id),
 342       is_for_child_local_root_(is_for_child_local_root),
 343       is_for_scalable_page_(is_for_scalable_page) {
 344   DCHECK(task_runner);
 345   if (is_for_nested_main_frame)
 346     main_data().is_for_nested_main_frame = is_for_nested_main_frame;
 347   frame_widget_host_.Bind(std::move(frame_widget_host), task_runner);
 348   receiver_.Bind(std::move(frame_widget), task_runner);
 349 }
 350
 351 WebFrameWidgetImpl::~WebFrameWidgetImpl() {
 352   // Ensure that Close is called and we aren't releasing |widget_base_| in the
 353   // destructor.
 354   // TODO(crbug.com/1139104): This CHECK can be changed to a DCHECK once
 355   // the issue is solved.
 356   CHECK(!widget_base_);
 357 }
 358
 359 void WebFrameWidgetImpl::BindLocalRoot(WebLocalFrame& local_root) {
 360   local_root_ = To<WebLocalFrameImpl>(local_root);
 361   CHECK(local_root_ && local_root_->GetFrame());
 362   if (RuntimeEnabledFeatures::LongAnimationFrameMonitoringEnabled(
 363           local_root_->GetFrame()->DomWindow()) &&
 364       !IsHidden()) {
 365     animation_frame_timing_monitor_ =
 366         MakeGarbageCollected<AnimationFrameTimingMonitor>(
 367             *this, local_root_->GetFrame()->GetProbeSink());
 368   }
 369 }
 370
 371 bool WebFrameWidgetImpl::ForTopMostMainFrame() const {
 372   return ForMainFrame() && !main_data().is_for_nested_main_frame;
 373 }
 374
 375 void WebFrameWidgetImpl::SetIsNestedMainFrameWidget(bool is_nested) {
 376   main_data().is_for_nested_main_frame = is_nested;
 377 }
 378
 379 void WebFrameWidgetImpl::Close() {
 380   // TODO(bokan): This seems wrong since the page may have other still-active
 381   // frame widgets. See also: https://crbug.com/1344531.
 382   GetPage()->WillStopCompositing();
 383
 384   if (ForMainFrame()) {
 385     // Closing the WebFrameWidgetImpl happens in response to the local main
 386     // frame being detached from the Page/WebViewImpl.
 387     View()->SetMainFrameViewWidget(nullptr);
 388   }
 389
 390   if (animation_frame_timing_monitor_) {
 391     animation_frame_timing_monitor_->Shutdown();
 392     animation_frame_timing_monitor_.Clear();
 393   }
 394
 395   mutator_dispatcher_ = nullptr;
 396   local_root_ = nullptr;
 397   widget_base_->Shutdown();
 398   widget_base_.reset();
 399   // These WeakPtrs must be invalidated for WidgetInputHandlerManager at the
 400   // same time as the WidgetBase is.
 401   input_handler_weak_ptr_factory_.InvalidateWeakPtrs();
 402   receiver_.reset();
 403   input_target_receiver_.reset();
 404 }
 405
 406 WebLocalFrame* WebFrameWidgetImpl::LocalRoot() const {
 407   return local_root_.Get();
 408 }
 409
 410 bool WebFrameWidgetImpl::RequestedMainFramePending() {
 411   return View() && View()->does_composite() && LayerTreeHost() &&
 412          LayerTreeHost()->RequestedMainFramePending();
 413 }
 414
 415 ukm::UkmRecorder* WebFrameWidgetImpl::MainFrameUkmRecorder() {
 416   DCHECK(local_root_);
 417   if (!local_root_->IsOutermostMainFrame()) {
 418     return nullptr;
 419   }
 420
 421   if (!local_root_->GetFrame() || !local_root_->GetFrame()->DomWindow()) {
 422     return nullptr;
 423   }
 424
 425   return local_root_->GetFrame()->DomWindow()->UkmRecorder();
 426 }
 427 ukm::SourceId WebFrameWidgetImpl::MainFrameUkmSourceId() {
 428   DCHECK(local_root_);
 429   if (!local_root_->IsOutermostMainFrame()) {
 430     return ukm::kInvalidSourceId;
 431   }
 432
 433   if (!local_root_->GetFrame() || !local_root_->GetFrame()->DomWindow()) {
 434     return ukm::kInvalidSourceId;
 435   }
 436
 437   return local_root_->GetFrame()->DomWindow()->UkmSourceID();
 438 }
 439
 440 bool WebFrameWidgetImpl::IsMainFrameFullyLoaded() const {
 441   DCHECK(local_root_);
 442   if (!local_root_->IsOutermostMainFrame()) {
 443     return false;
 444   }
 445
 446   return local_root_->GetFrame() &&
 447          local_root_->GetFrame()->Loader().GetDocumentLoader() &&
 448          !local_root_->GetFrame()
 449               ->Loader()
 450               .GetDocumentLoader()
 451               ->GetTiming()
 452               .LoadEventEnd()
 453               .is_null();
 454 }
 455
 456 gfx::Rect WebFrameWidgetImpl::ComputeBlockBound(
 457     const gfx::Point& point_in_root_frame,
 458     bool ignore_clipping) const {
 459   HitTestLocation location(local_root_->GetFrameView()->ConvertFromRootFrame(
 460       PhysicalOffset(point_in_root_frame)));
 461   HitTestRequest::HitTestRequestType hit_type =
 462       HitTestRequest::kReadOnly | HitTestRequest::kActive |
 463       (ignore_clipping ? HitTestRequest::kIgnoreClipping : 0);
 464   HitTestResult result =
 465       local_root_->GetFrame()->GetEventHandler().HitTestResultAtLocation(
 466           location, hit_type);
 467   result.SetToShadowHostIfInUAShadowRoot();
 468
 469   Node* node = result.InnerNodeOrImageMapImage();
 470   if (!node)
 471     return gfx::Rect();
 472
 473   // Find the block type node based on the hit node.
 474   // FIXME: This wants to walk flat tree with
 475   // LayoutTreeBuilderTraversal::parent().
 476   while (node &&
 477          (!node->GetLayoutObject() || node->GetLayoutObject()->IsInline()))
 478     node = LayoutTreeBuilderTraversal::Parent(*node);
 479
 480   // Return the bounding box in the root frame's coordinate space.
 481   if (node) {
 482     gfx::Rect absolute_rect =
 483         node->GetLayoutObject()->AbsoluteBoundingBoxRect();
 484     LocalFrame* frame = node->GetDocument().GetFrame();
 485     return frame->View()->ConvertToRootFrame(absolute_rect);
 486   }
 487   return gfx::Rect();
 488 }
 489
 490 void WebFrameWidgetImpl::DragTargetDragEnter(
 491     const WebDragData& web_drag_data,
 492     const gfx::PointF& point_in_viewport,
 493     const gfx::PointF& screen_point,
 494     DragOperationsMask operations_allowed,
 495     uint32_t key_modifiers,
 496     DragTargetDragEnterCallback callback) {
 497   auto* target = local_root_->GetFrame()->DocumentAtPoint(
 498       PhysicalOffset::FromPointFRound(ViewportToRootFrame(point_in_viewport)));
 499
 500   // Any execution context should do the work since no file should ever be
 501   // created during drag events.
 502   current_drag_data_ = DataObject::Create(
 503       target ? target->GetExecutionContext() : nullptr, web_drag_data);
 504   operations_allowed_ = operations_allowed;
 505
 506   DragTargetDragEnterOrOver(point_in_viewport, screen_point, kDragEnter,
 507                             key_modifiers);
 508
 509   std::move(callback).Run(drag_operation_.operation,
 510                           drag_operation_.document_is_handling_drag);
 511 }
 512
 513 void WebFrameWidgetImpl::DragTargetDragOver(
 514     const gfx::PointF& point_in_viewport,
 515     const gfx::PointF& screen_point,
 516     DragOperationsMask operations_allowed,
 517     uint32_t key_modifiers,
 518     DragTargetDragOverCallback callback) {
 519   operations_allowed_ = operations_allowed;
 520
 521   DragTargetDragEnterOrOver(point_in_viewport, screen_point, kDragOver,
 522                             key_modifiers);
 523
 524   std::move(callback).Run(drag_operation_.operation,
 525                           drag_operation_.document_is_handling_drag);
 526 }
 527
 528 void WebFrameWidgetImpl::DragTargetDragLeave(
 529     const gfx::PointF& point_in_viewport,
 530     const gfx::PointF& screen_point) {
 531   base::ScopedClosureRunner runner(
 532       WTF::BindOnce(&WebFrameWidgetImpl::CancelDrag, WrapWeakPersistent(this)));
 533   if (ShouldIgnoreInputEvents() || !current_drag_data_) {
 534     return;
 535   }
 536
 537   gfx::PointF point_in_root_frame(ViewportToRootFrame(point_in_viewport));
 538   DragData drag_data(current_drag_data_.Get(), point_in_root_frame,
 539                      screen_point, operations_allowed_,
 540                      /*force_default_action=*/false);
 541
 542   GetPage()->GetDragController().DragExited(&drag_data,
 543                                             *local_root_->GetFrame());
 544
 545   // FIXME: why is the drag scroll timer not stopped here?
 546 }
 547
 548 void WebFrameWidgetImpl::DragTargetDrop(const WebDragData& web_drag_data,
 549                                         const gfx::PointF& point_in_viewport,
 550                                         const gfx::PointF& screen_point,
 551                                         uint32_t key_modifiers,
 552                                         base::OnceClosure callback) {
 553   base::ScopedClosureRunner callback_runner(std::move(callback));
 554   base::ScopedClosureRunner runner(
 555       WTF::BindOnce(&WebFrameWidgetImpl::CancelDrag, WrapWeakPersistent(this)));
 556
 557   if (ShouldIgnoreInputEvents() || !current_drag_data_) {
 558     return;
 559   }
 560
 561   auto* target = local_root_->GetFrame()->DocumentAtPoint(
 562       PhysicalOffset::FromPointFRound(ViewportToRootFrame(point_in_viewport)));
 563
 564   current_drag_data_ = DataObject::Create(
 565       target ? target->GetExecutionContext() : nullptr, web_drag_data);
 566
 567   // If this webview transitions from the "drop accepting" state to the "not
 568   // accepting" state, then our IPC message reply indicating that may be in-
 569   // flight, or else delayed by javascript processing in this webview.  If a
 570   // drop happens before our IPC reply has reached the browser process, then
 571   // the browser forwards the drop to this webview.  So only allow a drop to
 572   // proceed if our webview drag operation state is not DragOperation::kNone.
 573
 574   if (drag_operation_.operation == DragOperation::kNone) {
 575     // IPC RACE CONDITION: do not allow this drop.
 576     DragTargetDragLeave(point_in_viewport, screen_point);
 577     return;
 578   }
 579
 580   current_drag_data_->SetModifiers(key_modifiers);
 581   DragData drag_data(current_drag_data_.Get(),
 582                      ViewportToRootFrame(point_in_viewport), screen_point,
 583                      operations_allowed_, web_drag_data.ForceDefaultAction());
 584   GetPage()->GetDragController().PerformDrag(&drag_data,
 585                                              *local_root_->GetFrame());
 586 }
 587
 588 void WebFrameWidgetImpl::DragSourceEndedAt(const gfx::PointF& point_in_viewport,
 589                                            const gfx::PointF& screen_point,
 590                                            DragOperation operation,
 591                                            base::OnceClosure callback) {
 592   base::ScopedClosureRunner callback_runner(std::move(callback));
 593   base::ScopedClosureRunner runner(
 594       WTF::BindOnce(&WebFrameWidgetImpl::DragSourceSystemDragEnded,
 595                     WrapWeakPersistent(this)));
 596
 597   if (ShouldIgnoreInputEvents()) {
 598     return;
 599   }
 600
 601   WebMouseEvent fake_mouse_move(
 602       WebInputEvent::Type::kMouseMove,
 603       GetPage()->GetVisualViewport().ViewportToRootFrame(point_in_viewport),
 604       screen_point, WebPointerProperties::Button::kLeft, 0,
 605       WebInputEvent::kNoModifiers, base::TimeTicks::Now());
 606   fake_mouse_move.SetFrameScale(1);
 607   local_root_->GetFrame()->GetEventHandler().DragSourceEndedAt(fake_mouse_move,
 608                                                                operation);
 609 }
 610
 611 void WebFrameWidgetImpl::DragSourceSystemDragEnded() {
 612   CancelDrag();
 613
 614   // It's possible for this to be false if the source stopped dragging at a
 615   // previous page.
 616   if (!doing_drag_and_drop_) {
 617     return;
 618   }
 619   GetPage()->GetDragController().DragEnded();
 620   doing_drag_and_drop_ = false;
 621 }
 622
 623 gfx::Rect WebFrameWidgetImpl::GetAbsoluteCaretBounds() {
 624   LocalFrame* local_frame = GetPage()->GetFocusController().FocusedFrame();
 625   if (local_frame) {
 626     auto& selection = local_frame->Selection();
 627     if (selection.GetSelectionInDOMTree().IsCaret())
 628       return selection.AbsoluteCaretBounds();
 629   }
 630   return gfx::Rect();
 631 }
 632
 633 void WebFrameWidgetImpl::OnStartStylusWriting(
 634     OnStartStylusWritingCallback callback) {
 635   // Focus the stylus writable element for current touch sequence as we have
 636   // detected writing has started.
 637   LocalFrame* frame = LocalRootImpl()->GetFrame();
 638   if (!frame) {
 639     std::move(callback).Run(absl::nullopt, absl::nullopt);
 640     return;
 641   }
 642
 643   Element* stylus_writable_element =
 644       frame->GetEventHandler().CurrentTouchDownElement();
 645   if (!stylus_writable_element) {
 646     std::move(callback).Run(absl::nullopt, absl::nullopt);
 647     return;
 648   }
 649
 650   if (auto* text_control = EnclosingTextControl(stylus_writable_element)) {
 651     text_control->Focus(FocusParams(FocusTrigger::kUserGesture));
 652   } else if (auto* html_element =
 653                  DynamicTo<HTMLElement>(stylus_writable_element)) {
 654     html_element->Focus(FocusParams(FocusTrigger::kUserGesture));
 655   }
 656   Element* focused_element = FocusedElement();
 657   // Since the element can change after it gets focused, we just verify if
 658   // the focused element is editable to continue writing.
 659   if (IsElementNotNullAndEditable(focused_element)) {
 660     std::move(callback).Run(
 661         focused_element->BoundsInWidget(),
 662         frame->View()->FrameToViewport(GetAbsoluteCaretBounds()));
 663     return;
 664   }
 665
 666   std::move(callback).Run(absl::nullopt, absl::nullopt);
 667 }
 668
 669 void WebFrameWidgetImpl::HandleStylusWritingGestureAction(
 670     mojom::blink::StylusWritingGestureDataPtr gesture_data,
 671     HandleStylusWritingGestureActionCallback callback) {
 672   LocalFrame* focused_frame = FocusedLocalFrameInWidget();
 673   if (!focused_frame) {
 674     std::move(callback).Run(mojom::blink::HandwritingGestureResult::kFailed);
 675     return;
 676   }
 677   mojom::blink::HandwritingGestureResult result =
 678       StylusWritingGesture::ApplyGesture(focused_frame,
 679                                          std::move(gesture_data));
 680   std::move(callback).Run(result);
 681 }
 682
 683 void WebFrameWidgetImpl::SetBackgroundOpaque(bool opaque) {
 684   View()->SetBaseBackgroundColorOverrideTransparent(!opaque);
 685 }
 686
 687 void WebFrameWidgetImpl::SetTextDirection(base::i18n::TextDirection direction) {
 688   LocalFrame* focusedFrame = FocusedLocalFrameInWidget();
 689   if (focusedFrame)
 690     focusedFrame->SetTextDirection(direction);
 691 }
 692
 693 void WebFrameWidgetImpl::SetInheritedEffectiveTouchActionForSubFrame(
 694     TouchAction touch_action) {
 695   DCHECK(ForSubframe());
 696   LocalRootImpl()->GetFrame()->SetInheritedEffectiveTouchAction(touch_action);
 697 }
 698
 699 void WebFrameWidgetImpl::UpdateRenderThrottlingStatusForSubFrame(
 700     bool is_throttled,
 701     bool subtree_throttled,
 702     bool display_locked) {
 703   DCHECK(ForSubframe());
 704   // TODO(szager,vmpstr): The parent render process currently rolls up
 705   // display_locked into the value of subtree throttled here; display_locked
 706   // should be maintained as a separate bit and transmitted between render
 707   // processes.
 708   LocalRootImpl()->GetFrameView()->UpdateRenderThrottlingStatus(
 709       is_throttled, subtree_throttled, display_locked, /*recurse=*/true);
 710 }
 711
 712 #if BUILDFLAG(IS_MAC)
 713 void WebFrameWidgetImpl::GetStringAtPoint(const gfx::Point& point_in_local_root,
 714                                           GetStringAtPointCallback callback) {
 715   gfx::Point baseline_point;
 716   ui::mojom::blink::AttributedStringPtr attributed_string = nullptr;
 717   base::apple::ScopedCFTypeRef<CFAttributedStringRef> string =
 718       SubstringUtil::AttributedWordAtPoint(this, point_in_local_root,
 719                                            baseline_point);
 720   if (string) {
 721     attributed_string = ui::mojom::blink::AttributedString::From(string.get());
 722   }
 723
 724   std::move(callback).Run(std::move(attributed_string), baseline_point);
 725 }
 726 #endif
 727
 728 void WebFrameWidgetImpl::BindWidgetCompositor(
 729     mojo::PendingReceiver<mojom::blink::WidgetCompositor> receiver) {
 730   widget_base_->BindWidgetCompositor(std::move(receiver));
 731 }
 732
 733 void WebFrameWidgetImpl::BindInputTargetClient(
 734     mojo::PendingReceiver<viz::mojom::blink::InputTargetClient> receiver) {
 735   DCHECK(!input_target_receiver_.is_bound());
 736   input_target_receiver_.Bind(
 737       std::move(receiver),
 738       local_root_->GetTaskRunner(TaskType::kInternalInputBlocking));
 739 }
 740
 741 void WebFrameWidgetImpl::FrameSinkIdAt(const gfx::PointF& point,
 742                                        const uint64_t trace_id,
 743                                        FrameSinkIdAtCallback callback) {
 744   TRACE_EVENT_WITH_FLOW1("viz,benchmark", "Event.Pipeline",
 745                          TRACE_ID_GLOBAL(trace_id),
 746                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
 747                          "step", "FrameSinkIdAt");
 748
 749   gfx::PointF local_point;
 750   viz::FrameSinkId id = GetFrameSinkIdAtPoint(point, &local_point);
 751   std::move(callback).Run(id, local_point);
 752 }
 753
 754 viz::FrameSinkId WebFrameWidgetImpl::GetFrameSinkIdAtPoint(
 755     const gfx::PointF& point_in_dips,
 756     gfx::PointF* local_point_in_dips) {
 757   HitTestResult result =
 758       CoreHitTestResultAt(widget_base_->DIPsToBlinkSpace(point_in_dips));
 759
 760   Node* result_node = result.InnerNode();
 761   *local_point_in_dips = gfx::PointF(point_in_dips);
 762
 763   // TODO(crbug.com/797828): When the node is null the caller may
 764   // need to do extra checks. Like maybe update the layout and then
 765   // call the hit-testing API. Either way it might be better to have
 766   // a DCHECK for the node rather than a null check here.
 767   if (!result_node) {
 768     return frame_sink_id_;
 769   }
 770
 771   viz::FrameSinkId remote_frame_sink_id = GetRemoteFrameSinkId(result);
 772   if (remote_frame_sink_id.is_valid()) {
 773     gfx::PointF local_point(result.LocalPoint());
 774     LayoutObject* object = result_node->GetLayoutObject();
 775     if (auto* box = DynamicTo<LayoutBox>(object))
 776       local_point -= gfx::Vector2dF(box->PhysicalContentBoxOffset());
 777
 778     *local_point_in_dips = widget_base_->BlinkSpaceToDIPs(local_point);
 779     return remote_frame_sink_id;
 780   }
 781
 782   // Return the FrameSinkId for the current widget if the point did not hit
 783   // test to a remote frame, or the point is outside of the remote frame's
 784   // content box, or the remote frame doesn't have a valid FrameSinkId yet.
 785   return frame_sink_id_;
 786 }
 787
 788 gfx::RectF WebFrameWidgetImpl::BlinkSpaceToDIPs(const gfx::RectF& rect) {
 789   return widget_base_->BlinkSpaceToDIPs(rect);
 790 }
 791
 792 gfx::Rect WebFrameWidgetImpl::BlinkSpaceToEnclosedDIPs(const gfx::Rect& rect) {
 793   return widget_base_->BlinkSpaceToEnclosedDIPs(rect);
 794 }
 795
 796 gfx::Size WebFrameWidgetImpl::BlinkSpaceToFlooredDIPs(const gfx::Size& size) {
 797   return widget_base_->BlinkSpaceToFlooredDIPs(size);
 798 }
 799
 800 gfx::RectF WebFrameWidgetImpl::DIPsToBlinkSpace(const gfx::RectF& rect) {
 801   return widget_base_->DIPsToBlinkSpace(rect);
 802 }
 803
 804 gfx::PointF WebFrameWidgetImpl::DIPsToBlinkSpace(const gfx::PointF& point) {
 805   return widget_base_->DIPsToBlinkSpace(point);
 806 }
 807
 808 gfx::Point WebFrameWidgetImpl::DIPsToRoundedBlinkSpace(
 809     const gfx::Point& point) {
 810   return widget_base_->DIPsToRoundedBlinkSpace(point);
 811 }
 812
 813 float WebFrameWidgetImpl::DIPsToBlinkSpace(float scalar) {
 814   return widget_base_->DIPsToBlinkSpace(scalar);
 815 }
 816
 817 gfx::Size WebFrameWidgetImpl::DIPsToCeiledBlinkSpace(const gfx::Size& size) {
 818   return widget_base_->DIPsToCeiledBlinkSpace(size);
 819 }
 820
 821 void WebFrameWidgetImpl::SetActive(bool active) {
 822   View()->SetIsActive(active);
 823 }
 824
 825 WebInputEventResult WebFrameWidgetImpl::HandleKeyEvent(
 826     const WebKeyboardEvent& event) {
 827   DCHECK((event.GetType() == WebInputEvent::Type::kRawKeyDown) ||
 828          (event.GetType() == WebInputEvent::Type::kKeyDown) ||
 829          (event.GetType() == WebInputEvent::Type::kKeyUp));
 830
 831   // Please refer to the comments explaining the m_suppressNextKeypressEvent
 832   // member.
 833   // The m_suppressNextKeypressEvent is set if the KeyDown is handled by
 834   // Webkit. A keyDown event is typically associated with a keyPress(char)
 835   // event and a keyUp event. We reset this flag here as this is a new keyDown
 836   // event.
 837   suppress_next_keypress_event_ = false;
 838
 839   // If there is a popup open, it should be the one processing the event,
 840   // not the page.
 841   scoped_refptr<WebPagePopupImpl> page_popup = View()->GetPagePopup();
 842   if (page_popup) {
 843     page_popup->HandleKeyEvent(event);
 844     if (event.GetType() == WebInputEvent::Type::kRawKeyDown) {
 845       suppress_next_keypress_event_ = true;
 846     }
 847     return WebInputEventResult::kHandledSystem;
 848   }
 849
 850   auto* frame = DynamicTo<LocalFrame>(FocusedCoreFrame());
 851   if (!frame)
 852     return WebInputEventResult::kNotHandled;
 853
 854   WebInputEventResult result = frame->GetEventHandler().KeyEvent(event);
 855   // EventHandler may have detached the frame.
 856   if (!LocalRootImpl())
 857     return result;
 858
 859   if (result != WebInputEventResult::kNotHandled) {
 860     if (WebInputEvent::Type::kRawKeyDown == event.GetType()) {
 861       // Suppress the next keypress event unless the focused node is a plugin
 862       // node.  (Flash needs these keypress events to handle non-US keyboards.)
 863       Element* element = FocusedElement();
 864       if (element && element->GetLayoutObject() &&
 865           element->GetLayoutObject()->IsEmbeddedObject()) {
 866         if (event.windows_key_code == VKEY_TAB) {
 867           // If the plugin supports keyboard focus then we should not send a tab
 868           // keypress event.
 869           WebPluginContainerImpl* plugin_view =
 870               To<LayoutEmbeddedContent>(element->GetLayoutObject())->Plugin();
 871           if (plugin_view && plugin_view->SupportsKeyboardFocus()) {
 872             suppress_next_keypress_event_ = true;
 873           }
 874         }
 875       } else {
 876         suppress_next_keypress_event_ = true;
 877       }
 878     }
 879     return result;
 880   }
 881
 882 #if !BUILDFLAG(IS_MAC)
 883   const WebInputEvent::Type kContextMenuKeyTriggeringEventType =
 884 #if BUILDFLAG(IS_WIN)
 885       WebInputEvent::Type::kKeyUp;
 886 #else
 887       WebInputEvent::Type::kRawKeyDown;
 888 #endif
 889   const WebInputEvent::Type kShiftF10TriggeringEventType =
 890       WebInputEvent::Type::kRawKeyDown;
 891
 892   bool is_unmodified_menu_key =
 893       !(event.GetModifiers() & WebInputEvent::kInputModifiers) &&
 894       event.windows_key_code == VKEY_APPS;
 895   bool is_shift_f10 = (event.GetModifiers() & WebInputEvent::kInputModifiers) ==
 896                           WebInputEvent::kShiftKey &&
 897                       event.windows_key_code == VKEY_F10;
 898   if ((is_unmodified_menu_key &&
 899        event.GetType() == kContextMenuKeyTriggeringEventType) ||
 900       (is_shift_f10 && event.GetType() == kShiftF10TriggeringEventType)) {
 901     View()->SendContextMenuEvent();
 902     return WebInputEventResult::kHandledSystem;
 903   }
 904 #endif  // !BUILDFLAG(IS_MAC)
 905
 906   return WebInputEventResult::kNotHandled;
 907 }
 908
 909 void WebFrameWidgetImpl::HandleMouseDown(LocalFrame& local_root,
 910                                          const WebMouseEvent& event) {
 911   WebViewImpl* view_impl = View();
 912   // If there is a popup open, close it as the user is clicking on the page
 913   // (outside of the popup). We also save it so we can prevent a click on an
 914   // element from immediately reopening the same popup.
 915   scoped_refptr<WebPagePopupImpl> page_popup;
 916   if (event.button == WebMouseEvent::Button::kLeft) {
 917     page_popup = view_impl->GetPagePopup();
 918     view_impl->CancelPagePopup();
 919   }
 920
 921   // Take capture on a mouse down on a plugin so we can send it mouse events.
 922   // If the hit node is a plugin but a scrollbar is over it don't start mouse
 923   // capture because it will interfere with the scrollbar receiving events.
 924   PhysicalOffset point(LayoutUnit(event.PositionInWidget().x()),
 925                        LayoutUnit(event.PositionInWidget().y()));
 926   if (event.button == WebMouseEvent::Button::kLeft) {
 927     HitTestLocation location(
 928         LocalRootImpl()->GetFrameView()->ConvertFromRootFrame(point));
 929     HitTestResult result(
 930         LocalRootImpl()->GetFrame()->GetEventHandler().HitTestResultAtLocation(
 931             location));
 932     result.SetToShadowHostIfInUAShadowRoot();
 933     Node* hit_node = result.InnerNode();
 934     auto* html_element = DynamicTo<HTMLElement>(hit_node);
 935     if (!result.GetScrollbar() && hit_node && hit_node->GetLayoutObject() &&
 936         hit_node->GetLayoutObject()->IsEmbeddedObject() && html_element &&
 937         html_element->IsPluginElement()) {
 938       mouse_capture_element_ = To<HTMLPlugInElement>(hit_node);
 939       SetMouseCapture(true);
 940       TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("input", "capturing mouse",
 941                                         TRACE_ID_LOCAL(this));
 942     }
 943   }
 944
 945   WidgetEventHandler::HandleMouseDown(local_root, event);
 946   // WidgetEventHandler may have detached the frame.
 947   if (!LocalRootImpl())
 948     return;
 949
 950   if (view_impl->GetPagePopup() && page_popup &&
 951       view_impl->GetPagePopup()->HasSamePopupClient(page_popup.get())) {
 952     // That click triggered a page popup that is the same as the one we just
 953     // closed.  It needs to be closed.
 954     view_impl->CancelPagePopup();
 955   }
 956
 957   // Dispatch the contextmenu event regardless of if the click was swallowed.
 958   if (!GetPage()->GetSettings().GetShowContextMenuOnMouseUp()) {
 959 #if BUILDFLAG(IS_MAC)
 960     if (event.button == WebMouseEvent::Button::kRight ||
 961         (event.button == WebMouseEvent::Button::kLeft &&
 962          event.GetModifiers() & WebMouseEvent::kControlKey))
 963       MouseContextMenu(event);
 964 #else
 965     if (event.button == WebMouseEvent::Button::kRight)
 966       MouseContextMenu(event);
 967 #endif
 968   }
 969 }
 970
 971 void WebFrameWidgetImpl::HandleMouseLeave(LocalFrame& local_root,
 972                                           const WebMouseEvent& event) {
 973   View()->SetMouseOverURL(WebURL());
 974   WidgetEventHandler::HandleMouseLeave(local_root, event);
 975   // WidgetEventHandler may have detached the frame.
 976 }
 977
 978 void WebFrameWidgetImpl::MouseContextMenu(const WebMouseEvent& event) {
 979   GetPage()->GetContextMenuController().ClearContextMenu();
 980
 981   WebMouseEvent transformed_event =
 982       TransformWebMouseEvent(LocalRootImpl()->GetFrameView(), event);
 983   transformed_event.menu_source_type = kMenuSourceMouse;
 984   transformed_event.id = PointerEventFactory::kMouseId;
 985
 986   // Find the right target frame. See issue 1186900.
 987   HitTestResult result =
 988       HitTestResultForRootFramePos(transformed_event.PositionInRootFrame());
 989   Frame* target_frame;
 990   if (result.InnerNodeOrImageMapImage())
 991     target_frame = result.InnerNodeOrImageMapImage()->GetDocument().GetFrame();
 992   else
 993     target_frame = GetPage()->GetFocusController().FocusedOrMainFrame();
 994
 995   // This will need to be changed to a nullptr check when focus control
 996   // is refactored, at which point focusedOrMainFrame will never return a
 997   // RemoteFrame.
 998   // See https://crbug.com/341918.
 999   LocalFrame* target_local_frame = DynamicTo<LocalFrame>(target_frame);
1000   if (!target_local_frame)
1001     return;
1002
1003   {
1004     ContextMenuAllowedScope scope;
1005     target_local_frame->GetEventHandler().SendContextMenuEvent(
1006         transformed_event);
1007   }
1008   // Actually showing the context menu is handled by the ContextMenuClient
1009   // implementation...
1010 }
1011
1012 WebInputEventResult WebFrameWidgetImpl::HandleMouseUp(
1013     LocalFrame& local_root,
1014     const WebMouseEvent& event) {
1015   WebInputEventResult result =
1016       WidgetEventHandler::HandleMouseUp(local_root, event);
1017   // WidgetEventHandler may have detached the frame.
1018   if (!LocalRootImpl())
1019     return result;
1020
1021   if (GetPage()->GetSettings().GetShowContextMenuOnMouseUp()) {
1022     // Dispatch the contextmenu event regardless of if the click was swallowed.
1023     // On Mac/Linux, we handle it on mouse down, not up.
1024     if (event.button == WebMouseEvent::Button::kRight)
1025       MouseContextMenu(event);
1026   }
1027   return result;
1028 }
1029
1030 WebInputEventResult WebFrameWidgetImpl::HandleGestureEvent(
1031     const WebGestureEvent& event) {
1032   WebInputEventResult event_result = WebInputEventResult::kNotHandled;
1033
1034   // Fling events are not sent to the renderer.
1035   CHECK(event.GetType() != WebInputEvent::Type::kGestureFlingStart);
1036   CHECK(event.GetType() != WebInputEvent::Type::kGestureFlingCancel);
1037
1038   WebViewImpl* web_view = View();
1039
1040   LocalFrame* frame = LocalRootImpl()->GetFrame();
1041   WebGestureEvent scaled_event = TransformWebGestureEvent(frame->View(), event);
1042
1043   // Special handling for double tap and scroll events as we don't want to
1044   // hit test for them.
1045   switch (event.GetType()) {
1046     case WebInputEvent::Type::kGestureDoubleTap:
1047       if (web_view->SettingsImpl()->DoubleTapToZoomEnabled() &&
1048           web_view->MinimumPageScaleFactor() !=
1049               web_view->MaximumPageScaleFactor()) {
1050         gfx::Point pos_in_local_frame_root =
1051             gfx::ToFlooredPoint(scaled_event.PositionInRootFrame());
1052         auto block_bounds = ComputeBlockBound(pos_in_local_frame_root, false);
1053
1054         if (ForMainFrame()) {
1055           web_view->AnimateDoubleTapZoom(pos_in_local_frame_root, block_bounds);
1056         } else {
1057           // This sends the tap point and bounds to the main frame renderer via
1058           // the browser, where their coordinates will be transformed into the
1059           // main frame's coordinate space.
1060           GetAssociatedFrameWidgetHost()->AnimateDoubleTapZoomInMainFrame(
1061               pos_in_local_frame_root, block_bounds);
1062         }
1063       }
1064       event_result = WebInputEventResult::kHandledSystem;
1065       DidHandleGestureEvent(event);
1066       return event_result;
1067     case WebInputEvent::Type::kGestureScrollBegin:
1068     case WebInputEvent::Type::kGestureScrollEnd:
1069     case WebInputEvent::Type::kGestureScrollUpdate:
1070       // If we are getting any scroll toss close any page popup that is open.
1071       web_view->CancelPagePopup();
1072
1073       // Scrolling-related gesture events invoke EventHandler recursively for
1074       // each frame down the chain, doing a single-frame hit-test per frame.
1075       // This matches handleWheelEvent.  Perhaps we could simplify things by
1076       // rewriting scroll handling to work inner frame out, and then unify with
1077       // other gesture events.
1078       event_result =
1079           frame->GetEventHandler().HandleGestureScrollEvent(scaled_event);
1080       DidHandleGestureEvent(event);
1081       return event_result;
1082     default:
1083       break;
1084   }
1085
1086   // Hit test across all frames and do touch adjustment as necessary for the
1087   // event type.
1088   GestureEventWithHitTestResults targeted_event =
1089       frame->GetEventHandler().TargetGestureEvent(scaled_event);
1090
1091   // Link highlight animations are only for the main frame.
1092   // TODO(bokan): This isn't intentional, see https://crbug.com/1344531.
1093   if (ForMainFrame()) {
1094     // Handle link highlighting outside the main switch to avoid getting lost in
1095     // the complicated set of cases handled below.
1096     switch (scaled_event.GetType()) {
1097       case WebInputEvent::Type::kGestureShowPress:
1098         // Queue a highlight animation, then hand off to regular handler.
1099         web_view->EnableTapHighlightAtPoint(targeted_event);
1100         break;
1101       case WebInputEvent::Type::kGestureShortPress:
1102       case WebInputEvent::Type::kGestureLongPress:
1103       case WebInputEvent::Type::kGestureTapCancel:
1104       case WebInputEvent::Type::kGestureTap:
1105         GetPage()->GetLinkHighlight().UpdateOpacityAndRequestAnimation();
1106         break;
1107       default:
1108         break;
1109     }
1110   }
1111
1112   switch (scaled_event.GetType()) {
1113     case WebInputEvent::Type::kGestureTap: {
1114 #if BUILDFLAG(IS_EFL)
1115       if (web_view->SettingsImpl()->LinkEffectEnabled()) {
1116         HitTestResult result = targeted_event.GetHitTestResult();
1117         result.SetToShadowHostIfInUAShadowRoot();
1118         if (result.CanPlayLinkEffect()) {
1119           auto focused_frame = FocusedWebLocalFrameInWidget();
1120           if (focused_frame) {
1121             focused_frame->Client()->PlayLinkEffect();
1122           }
1123         }
1124       }
1125 #endif
1126       {
1127         ContextMenuAllowedScope scope;
1128         event_result =
1129             frame->GetEventHandler().HandleGestureEvent(targeted_event);
1130       }
1131
1132       if (web_view->GetPagePopup() && last_hidden_page_popup_ &&
1133           web_view->GetPagePopup()->HasSamePopupClient(
1134               last_hidden_page_popup_.get())) {
1135         // The tap triggered a page popup that is the same as the one we just
1136         // closed. It needs to be closed.
1137         web_view->CancelPagePopup();
1138       }
1139       // Don't have this value persist outside of a single tap gesture, plus
1140       // we're done with it now.
1141       last_hidden_page_popup_ = nullptr;
1142       break;
1143     }
1144     case WebInputEvent::Type::kGestureTwoFingerTap:
1145     case WebInputEvent::Type::kGestureLongPress:
1146     case WebInputEvent::Type::kGestureLongTap:
1147       if (scaled_event.GetType() == WebInputEvent::Type::kGestureLongTap) {
1148         if (LocalFrame* inner_frame =
1149                 targeted_event.GetHitTestResult().InnerNodeFrame()) {
1150           if (!inner_frame->GetEventHandler().LongTapShouldInvokeContextMenu())
1151             break;
1152         } else if (!frame->GetEventHandler().LongTapShouldInvokeContextMenu()) {
1153           break;
1154         }
1155       }
1156
1157       GetPage()->GetContextMenuController().ClearContextMenu();
1158       {
1159         ContextMenuAllowedScope scope;
1160         event_result =
1161             frame->GetEventHandler().HandleGestureEvent(targeted_event);
1162       }
1163
1164       break;
1165     case WebInputEvent::Type::kGestureTapDown:
1166       // Touch pinch zoom and scroll on the page (outside of a popup) must hide
1167       // the popup. In case of a touch scroll or pinch zoom, this function is
1168       // called with GestureTapDown rather than a GSB/GSU/GSE or GPB/GPU/GPE.
1169       // When we close a popup because of a GestureTapDown, we also save it so
1170       // we can prevent the following GestureTap from immediately reopening the
1171       // same popup.
1172       // This value should not persist outside of a gesture, so is cleared by
1173       // GestureTap (where it is used) and by GestureCancel.
1174       last_hidden_page_popup_ = web_view->GetPagePopup();
1175       web_view->CancelPagePopup();
1176       event_result =
1177           frame->GetEventHandler().HandleGestureEvent(targeted_event);
1178       break;
1179     case WebInputEvent::Type::kGestureTapCancel:
1180       // Don't have this value persist outside of a single tap gesture.
1181       last_hidden_page_popup_ = nullptr;
1182       event_result =
1183           frame->GetEventHandler().HandleGestureEvent(targeted_event);
1184       break;
1185     case WebInputEvent::Type::kGestureShowPress:
1186     case WebInputEvent::Type::kGestureTapUnconfirmed:
1187     case WebInputEvent::Type::kGestureShortPress:
1188       event_result =
1189           frame->GetEventHandler().HandleGestureEvent(targeted_event);
1190       break;
1191     default:
1192       NOTREACHED();
1193   }
1194   DidHandleGestureEvent(event);
1195   return event_result;
1196 }
1197
1198 WebInputEventResult WebFrameWidgetImpl::HandleMouseWheel(
1199     LocalFrame& frame,
1200     const WebMouseWheelEvent& event) {
1201   View()->CancelPagePopup();
1202   return WidgetEventHandler::HandleMouseWheel(frame, event);
1203   // WidgetEventHandler may have detached the frame.
1204 }
1205
1206 WebInputEventResult WebFrameWidgetImpl::HandleCharEvent(
1207     const WebKeyboardEvent& event) {
1208   DCHECK_EQ(event.GetType(), WebInputEvent::Type::kChar);
1209
1210   // Please refer to the comments explaining the m_suppressNextKeypressEvent
1211   // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
1212   // handled by Webkit. A keyDown event is typically associated with a
1213   // keyPress(char) event and a keyUp event. We reset this flag here as it
1214   // only applies to the current keyPress event.
1215   bool suppress = suppress_next_keypress_event_;
1216   suppress_next_keypress_event_ = false;
1217
1218   // If there is a popup open, it should be the one processing the event,
1219   // not the page.
1220   scoped_refptr<WebPagePopupImpl> page_popup = View()->GetPagePopup();
1221   if (page_popup)
1222     return page_popup->HandleKeyEvent(event);
1223
1224   LocalFrame* frame = To<LocalFrame>(FocusedCoreFrame());
1225   if (!frame) {
1226     return suppress ? WebInputEventResult::kHandledSuppressed
1227                     : WebInputEventResult::kNotHandled;
1228   }
1229
1230   EventHandler& handler = frame->GetEventHandler();
1231
1232   if (!event.IsCharacterKey())
1233     return WebInputEventResult::kHandledSuppressed;
1234
1235   // Accesskeys are triggered by char events and can't be suppressed.
1236   // It is unclear whether a keypress should be dispatched as well
1237   // crbug.com/563507
1238   if (handler.HandleAccessKey(event))
1239     return WebInputEventResult::kHandledSystem;
1240
1241   // Safari 3.1 does not pass off windows system key messages (WM_SYSCHAR) to
1242   // the eventHandler::keyEvent. We mimic this behavior on all platforms since
1243   // for now we are converting other platform's key events to windows key
1244   // events.
1245   if (event.is_system_key)
1246     return WebInputEventResult::kNotHandled;
1247
1248   if (suppress)
1249     return WebInputEventResult::kHandledSuppressed;
1250
1251   WebInputEventResult result = handler.KeyEvent(event);
1252   if (result != WebInputEventResult::kNotHandled)
1253     return result;
1254
1255   return WebInputEventResult::kNotHandled;
1256 }
1257
1258 void WebFrameWidgetImpl::CancelDrag() {
1259   drag_operation_ = DragController::Operation();
1260   current_drag_data_ = nullptr;
1261 }
1262
1263 void WebFrameWidgetImpl::StartDragging(LocalFrame* source_frame,
1264                                        const WebDragData& drag_data,
1265                                        DragOperationsMask operations_allowed,
1266                                        const SkBitmap& drag_image,
1267                                        const gfx::Vector2d& cursor_offset,
1268                                        const gfx::Rect& drag_obj_rect) {
1269   doing_drag_and_drop_ = true;
1270   if (drag_and_drop_disabled_) {
1271     DragSourceSystemDragEnded();
1272     return;
1273   }
1274
1275   gfx::Vector2d offset_in_dips =
1276       widget_base_->BlinkSpaceToFlooredDIPs(gfx::Point() + cursor_offset)
1277           .OffsetFromOrigin();
1278   gfx::Rect drag_obj_rect_in_dips =
1279       gfx::Rect(widget_base_->BlinkSpaceToFlooredDIPs(drag_obj_rect.origin()),
1280                 widget_base_->BlinkSpaceToFlooredDIPs(drag_obj_rect.size()));
1281   source_frame->GetLocalFrameHostRemote().StartDragging(
1282       drag_data, operations_allowed, drag_image, offset_in_dips,
1283       drag_obj_rect_in_dips, possible_drag_event_info_.Clone());
1284 }
1285
1286 void WebFrameWidgetImpl::DragTargetDragEnterOrOver(
1287     const gfx::PointF& point_in_viewport,
1288     const gfx::PointF& screen_point,
1289     DragAction drag_action,
1290     uint32_t key_modifiers) {
1291   if (ShouldIgnoreInputEvents() || !current_drag_data_) {
1292     CancelDrag();
1293     return;
1294   }
1295
1296   gfx::PointF point_in_root_frame = ViewportToRootFrame(point_in_viewport);
1297
1298   current_drag_data_->SetModifiers(key_modifiers);
1299   DragData drag_data(current_drag_data_.Get(), point_in_root_frame,
1300                      screen_point, operations_allowed_,
1301                      /*force_default_action=*/false);
1302
1303   drag_operation_ = GetPage()->GetDragController().DragEnteredOrUpdated(
1304       &drag_data, *local_root_->GetFrame());
1305
1306   // Mask the drag operation against the drag source's allowed
1307   // operations.
1308   if (!(static_cast<int>(drag_operation_.operation) &
1309         drag_data.DraggingSourceOperationMask())) {
1310     drag_operation_ = DragController::Operation();
1311   }
1312 }
1313
1314 void WebFrameWidgetImpl::SendOverscrollEventFromImplSide(
1315     const gfx::Vector2dF& overscroll_delta,
1316     cc::ElementId scroll_latched_element_id) {
1317   if (!RuntimeEnabledFeatures::OverscrollCustomizationEnabled())
1318     return;
1319
1320   Node* target_node = View()->FindNodeFromScrollableCompositorElementId(
1321       scroll_latched_element_id);
1322   if (target_node) {
1323     target_node->GetDocument().EnqueueOverscrollEventForNode(
1324         target_node, overscroll_delta.x(), overscroll_delta.y());
1325   }
1326 }
1327
1328 void WebFrameWidgetImpl::SendScrollEndEventFromImplSide(
1329     bool affects_outer_viewport,
1330     cc::ElementId scroll_latched_element_id) {
1331   if (!RuntimeEnabledFeatures::ScrollEndEventsEnabled())
1332     return;
1333
1334   Node* target_node = View()->FindNodeFromScrollableCompositorElementId(
1335       scroll_latched_element_id);
1336   bool target_is_root_scroller = false;
1337   if (View()->MainFrameImpl()) {
1338     Node* document_node = View()->MainFrameImpl()->GetDocument();
1339     if (target_node == document_node) {
1340       target_is_root_scroller = true;
1341     }
1342   }
1343   if (target_node) {
1344     // Scrolls consumed entirely by the VisualViewport and not the
1345     // LayoutViewport should not trigger scrollends on the document. The
1346     // VisualViewport currently handles scroll but not scrollends. If that
1347     // changes, we should consider firing scrollend at the visualviewport
1348     // instead of simply bailing.
1349     if (affects_outer_viewport || !target_is_root_scroller) {
1350       target_node->GetDocument().EnqueueScrollEndEventForNode(target_node);
1351     }
1352   }
1353 }
1354
1355 void WebFrameWidgetImpl::UpdateCompositorScrollState(
1356     const cc::CompositorCommitData& commit_data) {
1357   if (WebDevToolsAgentImpl* devtools = LocalRootImpl()->DevToolsAgentImpl())
1358     devtools->SetPageIsScrolling(commit_data.is_scroll_active);
1359
1360   RecordManipulationTypeCounts(commit_data.manipulation_info);
1361
1362   if (commit_data.scroll_latched_element_id == cc::ElementId())
1363     return;
1364
1365   if (!commit_data.overscroll_delta.IsZero()) {
1366     SendOverscrollEventFromImplSide(commit_data.overscroll_delta,
1367                                     commit_data.scroll_latched_element_id);
1368   }
1369
1370   // TODO(bokan): If a scroll ended and a new one began in the same Blink frame
1371   // (e.g. during a long running main thread task), this will erroneously
1372   // dispatch the scroll end to the latter (still-scrolling) element.
1373   // https://crbug.com/1116780.
1374   if (commit_data.scroll_end_data.scroll_gesture_did_end) {
1375     SendScrollEndEventFromImplSide(
1376         commit_data.scroll_end_data.gesture_affects_outer_viewport_scroll,
1377         commit_data.scroll_latched_element_id);
1378   }
1379 }
1380
1381 WebInputMethodController*
1382 WebFrameWidgetImpl::GetActiveWebInputMethodController() const {
1383   WebLocalFrameImpl* local_frame =
1384       WebLocalFrameImpl::FromFrame(FocusedLocalFrameInWidget());
1385   return local_frame ? local_frame->GetInputMethodController() : nullptr;
1386 }
1387
1388 void WebFrameWidgetImpl::DisableDragAndDrop() {
1389   drag_and_drop_disabled_ = true;
1390 }
1391
1392 gfx::PointF WebFrameWidgetImpl::ViewportToRootFrame(
1393     const gfx::PointF& point_in_viewport) const {
1394   return GetPage()->GetVisualViewport().ViewportToRootFrame(point_in_viewport);
1395 }
1396
1397 WebViewImpl* WebFrameWidgetImpl::View() const {
1398   return local_root_->ViewImpl();
1399 }
1400
1401 Page* WebFrameWidgetImpl::GetPage() const {
1402   return View()->GetPage();
1403 }
1404
1405 mojom::blink::FrameWidgetHost*
1406 WebFrameWidgetImpl::GetAssociatedFrameWidgetHost() const {
1407   return frame_widget_host_.get();
1408 }
1409
1410 void WebFrameWidgetImpl::RequestDecode(
1411     const PaintImage& image,
1412     base::OnceCallback<void(bool)> callback) {
1413   widget_base_->LayerTreeHost()->QueueImageDecode(image, std::move(callback));
1414 }
1415
1416 void WebFrameWidgetImpl::Trace(Visitor* visitor) const {
1417   visitor->Trace(local_root_);
1418   visitor->Trace(current_drag_data_);
1419   visitor->Trace(frame_widget_host_);
1420   visitor->Trace(receiver_);
1421   visitor->Trace(input_target_receiver_);
1422   visitor->Trace(mouse_capture_element_);
1423   visitor->Trace(device_emulator_);
1424   visitor->Trace(animation_frame_timing_monitor_);
1425 }
1426
1427 #if BUILDFLAG(IS_TIZEN_TV)
1428 void WebFrameWidgetImpl::EdgeScrollBy(const gfx::Point& offset, const gfx::Point& mouse_position) {
1429   bool handled = false;
1430   WebViewImpl* webview = View();
1431   if (webview)
1432     handled = webview->EdgeScrollBy(
1433             blink::ScrollOffset(offset.x(), offset.y()),
1434             gfx::Point(mouse_position.x(), mouse_position.y()));
1435   widget_base_->DidEdgeScrollBy(offset, handled);
1436 }
1437
1438 void WebFrameWidgetImpl::SetTranslatedURL(const WTF::String& url) {
1439   WebViewImpl* webview = View();
1440   if (!webview)
1441     return;
1442   webview->SetTranslatedURL(blink::WebString::FromUTF8(url.Ascii()));
1443 }
1444
1445 void WebFrameWidgetImpl::SetParentalRatingResult(const WTF::String& url,
1446                                                  bool is_pass) {
1447   WebViewImpl* webview = View();
1448   if (!webview){
1449     LOG(ERROR) << "no webview.";
1450     return;
1451   }
1452   webview->SetParentalRatingResult(blink::WebString::FromUTF8(url.Ascii()),
1453                                    is_pass);
1454 }
1455 #endif
1456
1457 void WebFrameWidgetImpl::SetNeedsRecalculateRasterScales() {
1458   if (!View()->does_composite())
1459     return;
1460   widget_base_->LayerTreeHost()->SetNeedsRecalculateRasterScales();
1461 }
1462
1463 void WebFrameWidgetImpl::SetBackgroundColor(SkColor color) {
1464   if (!View()->does_composite())
1465     return;
1466   // TODO(crbug/1308932): Remove FromColor and make all SkColor4f.
1467   widget_base_->LayerTreeHost()->set_background_color(
1468       SkColor4f::FromColor(color));
1469 }
1470
1471 void WebFrameWidgetImpl::SetOverscrollBehavior(
1472     const cc::OverscrollBehavior& overscroll_behavior) {
1473   if (!View()->does_composite())
1474     return;
1475   widget_base_->LayerTreeHost()->SetOverscrollBehavior(overscroll_behavior);
1476 }
1477
1478 void WebFrameWidgetImpl::SetPrefersReducedMotion(bool prefers_reduced_motion) {
1479   if (!View()->does_composite())
1480     return;
1481   widget_base_->LayerTreeHost()->SetPrefersReducedMotion(
1482       prefers_reduced_motion);
1483 }
1484
1485 void WebFrameWidgetImpl::StartPageScaleAnimation(const gfx::Point& destination,
1486                                                  bool use_anchor,
1487                                                  float new_page_scale,
1488                                                  base::TimeDelta duration) {
1489   widget_base_->LayerTreeHost()->StartPageScaleAnimation(
1490       destination, use_anchor, new_page_scale, duration);
1491 }
1492
1493 void WebFrameWidgetImpl::RequestBeginMainFrameNotExpected(bool request) {
1494   if (!View()->does_composite())
1495     return;
1496   widget_base_->LayerTreeHost()->RequestBeginMainFrameNotExpected(request);
1497 }
1498
1499 void WebFrameWidgetImpl::DidCommitAndDrawCompositorFrame() {
1500   ForEachLocalFrameControlledByWidget(
1501       local_root_->GetFrame(), [](WebLocalFrameImpl* local_frame) {
1502         local_frame->Client()->DidCommitAndDrawCompositorFrame();
1503       });
1504 }
1505
1506 void WebFrameWidgetImpl::DidObserveFirstScrollDelay(
1507     base::TimeDelta first_scroll_delay,
1508     base::TimeTicks first_scroll_timestamp) {
1509   if (!local_root_ || !(local_root_->GetFrame()) ||
1510       !(local_root_->GetFrame()->GetDocument())) {
1511     return;
1512   }
1513   InteractiveDetector* interactive_detector =
1514       InteractiveDetector::From(*(local_root_->GetFrame()->GetDocument()));
1515   if (interactive_detector) {
1516     interactive_detector->DidObserveFirstScrollDelay(first_scroll_delay,
1517                                                      first_scroll_timestamp);
1518   }
1519 }
1520
1521 void WebFrameWidgetImpl::WillBeginMainFrame() {
1522   if (animation_frame_timing_monitor_) {
1523     animation_frame_timing_monitor_->WillBeginMainFrame();
1524   }
1525 }
1526
1527 bool WebFrameWidgetImpl::ShouldIgnoreInputEvents() {
1528   CHECK(GetPage());
1529   return IgnoreInputEvents(GetPage()->BrowsingContextGroupToken());
1530 }
1531
1532 std::unique_ptr<cc::LayerTreeFrameSink>
1533 WebFrameWidgetImpl::AllocateNewLayerTreeFrameSink() {
1534   return nullptr;
1535 }
1536
1537 void WebFrameWidgetImpl::ReportLongAnimationFrameTiming(
1538     AnimationFrameTimingInfo* timing_info) {
1539   WebSecurityOrigin root_origin = local_root_->GetSecurityOrigin();
1540   ForEachLocalFrameControlledByWidget(
1541       local_root_->GetFrame(), [&](WebLocalFrameImpl* local_frame) {
1542         if (local_frame == local_root_ ||
1543             !local_frame->GetSecurityOrigin().IsSameOriginWith(root_origin)) {
1544           DOMWindowPerformance::performance(
1545               *local_frame->GetFrame()->DomWindow())
1546               ->ReportLongAnimationFrameTiming(timing_info);
1547         }
1548       });
1549 }
1550
1551 void WebFrameWidgetImpl::ReportLongTaskTiming(base::TimeTicks start_time,
1552                                               base::TimeTicks end_time,
1553                                               ExecutionContext* task_context) {
1554   CHECK(local_root_);
1555   CHECK(local_root_->GetFrame());
1556   ForEachLocalFrameControlledByWidget(
1557       local_root_->GetFrame(), [&](WebLocalFrameImpl* local_frame) {
1558         CHECK(local_frame->GetFrame());
1559         CHECK(local_frame->GetFrame()->DomWindow());
1560         // Note: |task_context| could be the execution context of any same-agent
1561         // frame.
1562         DOMWindowPerformance::performance(*local_frame->GetFrame()->DomWindow())
1563             ->ReportLongTask(start_time, end_time, task_context,
1564                              /*has_multiple_contexts=*/false);
1565       });
1566 }
1567
1568 bool WebFrameWidgetImpl::ShouldReportLongAnimationFrameTiming() const {
1569   return widget_base_ && !IsHidden();
1570 }
1571 void WebFrameWidgetImpl::OnTaskCompletedForFrame(
1572     base::TimeTicks start_time,
1573     base::TimeTicks end_time,
1574     base::TimeTicks desired_execution_time,
1575     LocalFrame* frame) {
1576   if (animation_frame_timing_monitor_) {
1577     animation_frame_timing_monitor_->OnTaskCompleted(
1578         start_time, end_time, desired_execution_time, frame);
1579   }
1580 }
1581
1582 void WebFrameWidgetImpl::DidBeginMainFrame() {
1583   LocalFrame* root_frame = LocalRootImpl()->GetFrame();
1584   DCHECK(root_frame);
1585
1586   if (LocalFrameView* frame_view = root_frame->View())
1587     frame_view->RunPostLifecycleSteps();
1588
1589   if (animation_frame_timing_monitor_) {
1590     animation_frame_timing_monitor_->DidBeginMainFrame();
1591   }
1592
1593   if (Page* page = root_frame->GetPage())
1594     page->Animator().PostAnimate();
1595 }
1596
1597 void WebFrameWidgetImpl::UpdateLifecycle(WebLifecycleUpdate requested_update,
1598                                          DocumentUpdateReason reason) {
1599   TRACE_EVENT0("blink", "WebFrameWidgetImpl::UpdateLifecycle");
1600   if (!LocalRootImpl())
1601     return;
1602
1603   if (requested_update == WebLifecycleUpdate::kAll &&
1604       animation_frame_timing_monitor_) {
1605     animation_frame_timing_monitor_->WillPerformStyleAndLayoutCalculation();
1606   }
1607
1608   GetPage()->UpdateLifecycle(*LocalRootImpl()->GetFrame(), requested_update,
1609                              reason);
1610   if (requested_update != WebLifecycleUpdate::kAll)
1611     return;
1612
1613   View()->UpdatePagePopup();
1614
1615   // Meaningful layout events and background colors only apply to main frames.
1616   if (ForMainFrame()) {
1617     MainFrameData& data = main_data();
1618
1619     // There is no background color for non-composited WebViews (eg
1620     // printing).
1621     if (View()->does_composite()) {
1622       SkColor background_color = View()->BackgroundColor();
1623       SetBackgroundColor(background_color);
1624       if (background_color != data.last_background_color) {
1625         LocalRootImpl()->GetFrame()->DidChangeBackgroundColor(
1626             SkColor4f::FromColor(background_color), false /* color_adjust */);
1627         data.last_background_color = background_color;
1628       }
1629     }
1630
1631     if (LocalFrameView* view = LocalRootImpl()->GetFrameView()) {
1632       LocalFrame* frame = LocalRootImpl()->GetFrame();
1633
1634       if (data.should_dispatch_first_visually_non_empty_layout &&
1635           view->IsVisuallyNonEmpty()) {
1636         data.should_dispatch_first_visually_non_empty_layout = false;
1637         // TODO(esprehn): Move users of this callback to something
1638         // better, the heuristic for "visually non-empty" is bad.
1639         DidMeaningfulLayout(WebMeaningfulLayout::kVisuallyNonEmpty);
1640       }
1641
1642       if (data.should_dispatch_first_layout_after_finished_parsing &&
1643           frame->GetDocument()->HasFinishedParsing()) {
1644         data.should_dispatch_first_layout_after_finished_parsing = false;
1645         DidMeaningfulLayout(WebMeaningfulLayout::kFinishedParsing);
1646       }
1647
1648       if (data.should_dispatch_first_layout_after_finished_loading &&
1649           frame->GetDocument()->IsLoadCompleted()) {
1650         data.should_dispatch_first_layout_after_finished_loading = false;
1651         DidMeaningfulLayout(WebMeaningfulLayout::kFinishedLoading);
1652       }
1653     }
1654   }
1655 }
1656
1657 void WebFrameWidgetImpl::DidCompletePageScaleAnimation() {
1658   // Page scale animations only happen on the main frame.
1659   DCHECK(ForMainFrame());
1660   if (auto* focused_frame = View()->FocusedFrame()) {
1661     if (focused_frame->AutofillClient())
1662       focused_frame->AutofillClient()->DidCompleteFocusChangeInFrame();
1663   }
1664
1665   if (page_scale_animation_for_testing_callback_)
1666     std::move(page_scale_animation_for_testing_callback_).Run();
1667 }
1668
1669 void WebFrameWidgetImpl::ScheduleAnimation() {
1670   if (!View()->does_composite()) {
1671     non_composited_client_->ScheduleNonCompositedAnimation();
1672     return;
1673   }
1674
1675   if (widget_base_->WillBeDestroyed()) {
1676     return;
1677   }
1678
1679   widget_base_->LayerTreeHost()->SetNeedsAnimate();
1680 }
1681
1682 void WebFrameWidgetImpl::FocusChanged(mojom::blink::FocusState focus_state) {
1683   // TODO(crbug.com/689777): FocusChange events are only sent to the MainFrame
1684   // these maybe should goto the local root so that the rest of input messages
1685   // sent to those are preserved in order.
1686   DCHECK(ForMainFrame());
1687   View()->SetIsActive(focus_state == mojom::blink::FocusState::kFocused ||
1688                       focus_state ==
1689                           mojom::blink::FocusState::kNotFocusedAndActive);
1690   View()->SetPageFocus(focus_state == mojom::blink::FocusState::kFocused);
1691 }
1692
1693 bool WebFrameWidgetImpl::ShouldAckSyntheticInputImmediately() {
1694   // TODO(bokan): The RequestPresentation API appears not to function in VR. As
1695   // a short term workaround for https://crbug.com/940063, ACK input
1696   // immediately rather than using RequestPresentation.
1697   if (GetPage()->GetSettings().GetImmersiveModeEnabled())
1698     return true;
1699   return false;
1700 }
1701
1702 void WebFrameWidgetImpl::UpdateVisualProperties(
1703     const VisualProperties& visual_properties) {
1704   SetZoomLevel(visual_properties.zoom_level);
1705
1706   // TODO(danakj): In order to synchronize updates between local roots, the
1707   // display mode should be propagated to RenderFrameProxies and down through
1708   // their RenderWidgetHosts to child WebFrameWidgetImpl via the
1709   // VisualProperties waterfall, instead of coming to each WebFrameWidgetImpl
1710   // independently.
1711   // https://developer.mozilla.org/en-US/docs/Web/CSS/@media/display-mode
1712   SetDisplayMode(visual_properties.display_mode);
1713   SetWindowShowState(visual_properties.window_show_state);
1714   SetResizable(visual_properties.resizable);
1715
1716   if (ForMainFrame()) {
1717     SetAutoResizeMode(
1718         visual_properties.auto_resize_enabled,
1719         visual_properties.min_size_for_auto_resize,
1720         visual_properties.max_size_for_auto_resize,
1721         visual_properties.screen_infos.current().device_scale_factor);
1722   }
1723
1724   bool capture_sequence_number_changed =
1725       visual_properties.capture_sequence_number !=
1726       last_capture_sequence_number_;
1727   if (capture_sequence_number_changed) {
1728     last_capture_sequence_number_ = visual_properties.capture_sequence_number;
1729
1730     // Send the capture sequence number to RemoteFrames that are below the
1731     // local root for this widget.
1732     ForEachRemoteFrameControlledByWidget(
1733         [capture_sequence_number = visual_properties.capture_sequence_number](
1734             RemoteFrame* remote_frame) {
1735           remote_frame->UpdateCaptureSequenceNumber(capture_sequence_number);
1736         });
1737   }
1738
1739   if (!View()->AutoResizeMode()) {
1740     // This needs to run before ApplyVisualPropertiesSizing below,
1741     // which updates the current set of screen_infos from visual properties.
1742     if (DidChangeFullscreenState(visual_properties)) {
1743       is_fullscreen_granted_ = visual_properties.is_fullscreen_granted;
1744       if (is_fullscreen_granted_)
1745         View()->DidEnterFullscreen();
1746       else
1747         View()->DidExitFullscreen();
1748     }
1749   }
1750
1751   gfx::Size old_visible_viewport_size_in_dips =
1752       widget_base_->VisibleViewportSizeInDIPs();
1753   ApplyVisualPropertiesSizing(visual_properties);
1754
1755   if (old_visible_viewport_size_in_dips !=
1756       widget_base_->VisibleViewportSizeInDIPs()) {
1757     ForEachLocalFrameControlledByWidget(
1758         local_root_->GetFrame(),
1759         &WebLocalFrameImpl::ResetHasScrolledFocusedEditableIntoView);
1760
1761     // Propagate changes down to child local root RenderWidgets and
1762     // BrowserPlugins in other frame trees/processes.
1763     ForEachRemoteFrameControlledByWidget(
1764         [visible_viewport_size = widget_base_->VisibleViewportSizeInDIPs()](
1765             RemoteFrame* remote_frame) {
1766           remote_frame->DidChangeVisibleViewportSize(visible_viewport_size);
1767         });
1768   }
1769
1770   // All non-top-level Widgets (child local-root frames, Portals, GuestViews,
1771   // etc.) propagate and consume the page scale factor as "external", meaning
1772   // that it comes from the top level widget's page scale.
1773   if (!ForTopMostMainFrame()) {
1774     // The main frame controls the page scale factor, from blink. For other
1775     // frame widgets, the page scale from pinch zoom and compositing scale is
1776     // received from its parent as part of the visual properties here. While
1777     // blink doesn't need to know this page scale factor outside the main frame,
1778     // the compositor does in order to produce its output at the correct scale.
1779     float combined_scale_factor = visual_properties.page_scale_factor *
1780                                   visual_properties.compositing_scale_factor;
1781     widget_base_->LayerTreeHost()->SetExternalPageScaleFactor(
1782         combined_scale_factor, visual_properties.is_pinch_gesture_active);
1783
1784     NotifyPageScaleFactorChanged(visual_properties.page_scale_factor,
1785                                  visual_properties.is_pinch_gesture_active);
1786
1787     NotifyCompositingScaleFactorChanged(
1788         visual_properties.compositing_scale_factor);
1789   } else {
1790     // Ensure the external scale factor in top-level widgets is reset as it may
1791     // be leftover from when a widget was nested and was promoted to top level
1792     // (e.g. portal activation).
1793     widget_base_->LayerTreeHost()->SetExternalPageScaleFactor(
1794         1.f,
1795         /*is_pinch_gesture_active=*/false);
1796   }
1797
1798   EventHandler& event_handler = local_root_->GetFrame()->GetEventHandler();
1799   if (event_handler.cursor_accessibility_scale_factor() !=
1800       visual_properties.cursor_accessibility_scale_factor) {
1801     ForEachLocalFrameControlledByWidget(
1802         local_root_->GetFrame(), [&](WebLocalFrameImpl* local_frame) {
1803           local_frame->GetFrame()
1804               ->GetEventHandler()
1805               .set_cursor_accessibility_scale_factor(
1806                   visual_properties.cursor_accessibility_scale_factor);
1807         });
1808     // Propagate changes down to any child RemoteFrames.
1809     ForEachRemoteFrameControlledByWidget(
1810         [scale_factor = visual_properties.cursor_accessibility_scale_factor](
1811             RemoteFrame* remote_frame) {
1812           remote_frame->CursorAccessibilityScaleFactorChanged(scale_factor);
1813         });
1814   }
1815
1816   // TODO(crbug.com/939118): This code path where scroll_focused_node_into_view
1817   // is set is used only for WebView, crbug 939118 tracks fixing webviews to
1818   // not use scroll_focused_node_into_view.
1819   if (visual_properties.scroll_focused_node_into_view)
1820     ScrollFocusedEditableElementIntoView();
1821 }
1822
1823 void WebFrameWidgetImpl::ApplyVisualPropertiesSizing(
1824     const VisualProperties& visual_properties) {
1825   gfx::Rect new_compositor_viewport_pixel_rect =
1826       visual_properties.compositor_viewport_pixel_rect;
1827   if (ForMainFrame()) {
1828     if (size_ !=
1829         widget_base_->DIPsToCeiledBlinkSpace(visual_properties.new_size)) {
1830       // Only hide popups when the size changes. Eg https://crbug.com/761908.
1831       View()->CancelPagePopup();
1832     }
1833
1834     if (auto* device_emulator = DeviceEmulator()) {
1835       device_emulator->UpdateVisualProperties(visual_properties);
1836       return;
1837     }
1838
1839     if (AutoResizeMode()) {
1840       new_compositor_viewport_pixel_rect = gfx::Rect(gfx::ScaleToCeiledSize(
1841           widget_base_->BlinkSpaceToFlooredDIPs(size_.value_or(gfx::Size())),
1842           visual_properties.screen_infos.current().device_scale_factor));
1843     }
1844   }
1845
1846   SetWindowSegments(visual_properties.root_widget_window_segments);
1847
1848   widget_base_->UpdateSurfaceAndScreenInfo(
1849       visual_properties.local_surface_id.value_or(viz::LocalSurfaceId()),
1850       new_compositor_viewport_pixel_rect, visual_properties.screen_infos);
1851
1852   // Store this even when auto-resizing, it is the size of the full viewport
1853   // used for clipping, and this value is propagated down the Widget
1854   // hierarchy via the VisualProperties waterfall.
1855   widget_base_->SetVisibleViewportSizeInDIPs(
1856       visual_properties.visible_viewport_size);
1857
1858   virtual_keyboard_resize_height_physical_px_ =
1859       visual_properties.virtual_keyboard_resize_height_physical_px;
1860   DCHECK(!virtual_keyboard_resize_height_physical_px_ || ForTopMostMainFrame());
1861
1862   if (ForMainFrame()) {
1863     if (!AutoResizeMode()) {
1864       size_ = widget_base_->DIPsToCeiledBlinkSpace(visual_properties.new_size);
1865
1866       View()->ResizeWithBrowserControls(
1867           size_.value(),
1868           widget_base_->DIPsToCeiledBlinkSpace(
1869               widget_base_->VisibleViewportSizeInDIPs()),
1870           visual_properties.browser_controls_params);
1871     }
1872
1873 #if !BUILDFLAG(IS_ANDROID)
1874     LocalRootImpl()->GetFrame()->UpdateWindowControlsOverlay(
1875         visual_properties.window_controls_overlay_rect);
1876 #endif
1877
1878   } else {
1879     // Widgets in a WebView's frame tree without a local main frame
1880     // set the size of the WebView to be the |visible_viewport_size|, in order
1881     // to limit compositing in (out of process) child frames to what is visible.
1882     //
1883     // Note that child frames in the same process/WebView frame tree as the
1884     // main frame do not do this in order to not clobber the source of truth in
1885     // the main frame.
1886     if (!View()->MainFrameImpl()) {
1887       View()->Resize(widget_base_->DIPsToCeiledBlinkSpace(
1888           widget_base_->VisibleViewportSizeInDIPs()));
1889     }
1890
1891     Resize(widget_base_->DIPsToCeiledBlinkSpace(visual_properties.new_size));
1892   }
1893 }
1894
1895 bool WebFrameWidgetImpl::DidChangeFullscreenState(
1896     const VisualProperties& visual_properties) const {
1897   if (visual_properties.is_fullscreen_granted != is_fullscreen_granted_)
1898     return true;
1899   // If changing fullscreen from one display to another, the fullscreen
1900   // granted state will not change, but we still need to resolve promises
1901   // by considering this a change.
1902   return visual_properties.is_fullscreen_granted &&
1903          widget_base_->screen_infos().current().display_id !=
1904              visual_properties.screen_infos.current().display_id;
1905 }
1906
1907 int WebFrameWidgetImpl::GetLayerTreeId() {
1908   if (!View()->does_composite())
1909     return 0;
1910   return widget_base_->LayerTreeHost()->GetId();
1911 }
1912
1913 const cc::LayerTreeSettings* WebFrameWidgetImpl::GetLayerTreeSettings() {
1914   if (!View()->does_composite()) {
1915     return nullptr;
1916   }
1917   return &widget_base_->LayerTreeHost()->GetSettings();
1918 }
1919
1920 void WebFrameWidgetImpl::UpdateBrowserControlsState(
1921     cc::BrowserControlsState constraints,
1922     cc::BrowserControlsState current,
1923     bool animate) {
1924   DCHECK(View()->does_composite());
1925   widget_base_->LayerTreeHost()->UpdateBrowserControlsState(constraints,
1926                                                             current, animate);
1927 }
1928
1929 void WebFrameWidgetImpl::SetHaveScrollEventHandlers(bool has_handlers) {
1930   widget_base_->LayerTreeHost()->SetHaveScrollEventHandlers(has_handlers);
1931 }
1932
1933 void WebFrameWidgetImpl::SetEventListenerProperties(
1934     cc::EventListenerClass listener_class,
1935     cc::EventListenerProperties listener_properties) {
1936   widget_base_->LayerTreeHost()->SetEventListenerProperties(
1937       listener_class, listener_properties);
1938
1939   if (listener_class == cc::EventListenerClass::kTouchStartOrMove ||
1940       listener_class == cc::EventListenerClass::kTouchEndOrCancel) {
1941     bool has_touch_handlers =
1942         EventListenerProperties(cc::EventListenerClass::kTouchStartOrMove) !=
1943             cc::EventListenerProperties::kNone ||
1944         EventListenerProperties(cc::EventListenerClass::kTouchEndOrCancel) !=
1945             cc::EventListenerProperties::kNone;
1946     if (!has_touch_handlers_ || *has_touch_handlers_ != has_touch_handlers) {
1947       has_touch_handlers_ = has_touch_handlers;
1948
1949       widget_base_->WidgetScheduler()->SetHasTouchHandler(has_touch_handlers);
1950       // Set touch event consumers based on whether there are touch event
1951       // handlers or the page has hit testable scrollbars.
1952       auto touch_event_consumers = mojom::blink::TouchEventConsumers::New(
1953           has_touch_handlers, GetPage()->GetScrollbarTheme().AllowsHitTest());
1954       frame_widget_host_->SetHasTouchEventConsumers(
1955           std::move(touch_event_consumers));
1956     }
1957   } else if (listener_class == cc::EventListenerClass::kPointerRawUpdate) {
1958     SetHasPointerRawUpdateEventHandlers(listener_properties !=
1959                                         cc::EventListenerProperties::kNone);
1960   }
1961 }
1962
1963 cc::EventListenerProperties WebFrameWidgetImpl::EventListenerProperties(
1964     cc::EventListenerClass listener_class) const {
1965   return widget_base_->LayerTreeHost()->event_listener_properties(
1966       listener_class);
1967 }
1968
1969 mojom::blink::DisplayMode WebFrameWidgetImpl::DisplayMode() const {
1970   return display_mode_;
1971 }
1972
1973 ui::WindowShowState WebFrameWidgetImpl::WindowShowState() const {
1974   return window_show_state_;
1975 }
1976
1977 bool WebFrameWidgetImpl::Resizable() const {
1978   return resizable_;
1979 }
1980
1981 const WebVector<gfx::Rect>& WebFrameWidgetImpl::WindowSegments() const {
1982   return window_segments_;
1983 }
1984
1985 bool WebFrameWidgetImpl::StartDeferringCommits(base::TimeDelta timeout,
1986                                                cc::PaintHoldingReason reason) {
1987   if (!View()->does_composite())
1988     return false;
1989   return widget_base_->LayerTreeHost()->StartDeferringCommits(timeout, reason);
1990 }
1991
1992 void WebFrameWidgetImpl::StopDeferringCommits(
1993     cc::PaintHoldingCommitTrigger triggger) {
1994   if (!View()->does_composite())
1995     return;
1996   widget_base_->LayerTreeHost()->StopDeferringCommits(triggger);
1997 }
1998
1999 std::unique_ptr<cc::ScopedPauseRendering> WebFrameWidgetImpl::PauseRendering() {
2000   if (!View()->does_composite())
2001     return nullptr;
2002   return widget_base_->LayerTreeHost()->PauseRendering();
2003 }
2004
2005 absl::optional<int> WebFrameWidgetImpl::GetMaxRenderBufferBounds() const {
2006   if (!View()->does_composite()) {
2007     return absl::nullopt;
2008   }
2009   return widget_base_->GetMaxRenderBufferBounds();
2010 }
2011
2012 std::unique_ptr<cc::ScopedDeferMainFrameUpdate>
2013 WebFrameWidgetImpl::DeferMainFrameUpdate() {
2014   return widget_base_->LayerTreeHost()->DeferMainFrameUpdate();
2015 }
2016
2017 void WebFrameWidgetImpl::SetBrowserControlsShownRatio(float top_ratio,
2018                                                       float bottom_ratio) {
2019   widget_base_->LayerTreeHost()->SetBrowserControlsShownRatio(top_ratio,
2020                                                               bottom_ratio);
2021 }
2022
2023 void WebFrameWidgetImpl::SetBrowserControlsParams(
2024     cc::BrowserControlsParams params) {
2025   widget_base_->LayerTreeHost()->SetBrowserControlsParams(params);
2026 }
2027
2028 void WebFrameWidgetImpl::SynchronouslyCompositeForTesting(
2029     base::TimeTicks frame_time) {
2030   widget_base_->LayerTreeHost()->CompositeForTest(frame_time, false,
2031                                                   base::OnceClosure());
2032 }
2033
2034 void WebFrameWidgetImpl::SetDeviceColorSpaceForTesting(
2035     const gfx::ColorSpace& color_space) {
2036   DCHECK(ForMainFrame());
2037   // We are changing the device color space from the renderer, so allocate a
2038   // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
2039   widget_base_->LayerTreeHost()->RequestNewLocalSurfaceId();
2040
2041   display::ScreenInfos screen_infos = widget_base_->screen_infos();
2042   for (display::ScreenInfo& screen_info : screen_infos.screen_infos)
2043     screen_info.display_color_spaces = gfx::DisplayColorSpaces(color_space);
2044   widget_base_->UpdateScreenInfo(screen_infos);
2045 }
2046
2047 // TODO(665924): Remove direct dispatches of mouse events from
2048 // PointerLockController, instead passing them through EventHandler.
2049 void WebFrameWidgetImpl::PointerLockMouseEvent(
2050     const WebCoalescedInputEvent& coalesced_event) {
2051   const WebInputEvent& input_event = coalesced_event.Event();
2052   const WebMouseEvent& mouse_event =
2053       static_cast<const WebMouseEvent&>(input_event);
2054   WebMouseEvent transformed_event =
2055       TransformWebMouseEvent(local_root_->GetFrameView(), mouse_event);
2056
2057   AtomicString event_type;
2058   switch (input_event.GetType()) {
2059     case WebInputEvent::Type::kMouseDown:
2060       event_type = event_type_names::kMousedown;
2061       if (!GetPage() || !GetPage()->GetPointerLockController().GetElement())
2062         break;
2063       LocalFrame::NotifyUserActivation(
2064           GetPage()
2065               ->GetPointerLockController()
2066               .GetElement()
2067               ->GetDocument()
2068               .GetFrame(),
2069           mojom::blink::UserActivationNotificationType::kInteraction);
2070       break;
2071     case WebInputEvent::Type::kMouseUp:
2072       event_type = event_type_names::kMouseup;
2073       break;
2074     case WebInputEvent::Type::kMouseMove:
2075       event_type = event_type_names::kMousemove;
2076       break;
2077     case WebInputEvent::Type::kMouseEnter:
2078     case WebInputEvent::Type::kMouseLeave:
2079     case WebInputEvent::Type::kContextMenu:
2080       // These should not be normally dispatched but may be due to timing
2081       // because pointer lost messaging happens on separate mojo channel.
2082       return;
2083     default:
2084       NOTREACHED() << input_event.GetType();
2085   }
2086
2087   if (GetPage()) {
2088     GetPage()->GetPointerLockController().DispatchLockedMouseEvent(
2089         transformed_event,
2090         TransformWebMouseEventVector(
2091             local_root_->GetFrameView(),
2092             coalesced_event.GetCoalescedEventsPointers()),
2093         TransformWebMouseEventVector(
2094             local_root_->GetFrameView(),
2095             coalesced_event.GetPredictedEventsPointers()),
2096         event_type);
2097   }
2098 }
2099 bool WebFrameWidgetImpl::IsPointerLocked() {
2100   if (GetPage()) {
2101     return GetPage()->GetPointerLockController().IsPointerLocked();
2102   }
2103   return false;
2104 }
2105
2106 void WebFrameWidgetImpl::ShowContextMenu(
2107     ui::mojom::blink::MenuSourceType source_type,
2108     const gfx::Point& location) {
2109   host_context_menu_location_ = location;
2110
2111   if (!GetPage())
2112     return;
2113   GetPage()->GetContextMenuController().ClearContextMenu();
2114   {
2115     ContextMenuAllowedScope scope;
2116     if (LocalFrame* focused_frame =
2117             GetPage()->GetFocusController().FocusedFrame()) {
2118       focused_frame->GetEventHandler().ShowNonLocatedContextMenu(
2119           nullptr, static_cast<blink::WebMenuSourceType>(source_type));
2120     }
2121   }
2122   host_context_menu_location_.reset();
2123 }
2124
2125 void WebFrameWidgetImpl::SetViewportIntersection(
2126     mojom::blink::ViewportIntersectionStatePtr intersection_state,
2127     const absl::optional<VisualProperties>& visual_properties) {
2128   // Remote viewports are only applicable to local frames with remote ancestors.
2129   // TODO(https://crbug.com/1148960): Should this deal with portals?
2130   DCHECK(ForSubframe() || !LocalRootImpl()->GetFrame()->IsOutermostMainFrame());
2131
2132   if (visual_properties.has_value())
2133     UpdateVisualProperties(visual_properties.value());
2134   ApplyViewportIntersection(std::move(intersection_state));
2135 }
2136
2137 void WebFrameWidgetImpl::ApplyViewportIntersectionForTesting(
2138     mojom::blink::ViewportIntersectionStatePtr intersection_state) {
2139   ApplyViewportIntersection(std::move(intersection_state));
2140 }
2141
2142 void WebFrameWidgetImpl::ApplyViewportIntersection(
2143     mojom::blink::ViewportIntersectionStatePtr intersection_state) {
2144   if (ForSubframe()) {
2145     // This information is propagated to LTH to define the region for filling
2146     // the on-screen text content.
2147     // TODO(khushalsagar) : This needs to also be done for main frames which are
2148     // embedded pages (see Frame::IsOutermostMainFrame()).
2149     child_data().compositor_visible_rect =
2150         intersection_state->compositor_visible_rect;
2151     widget_base_->LayerTreeHost()->SetVisualDeviceViewportIntersectionRect(
2152         intersection_state->compositor_visible_rect);
2153   }
2154   LocalRootImpl()->GetFrame()->SetViewportIntersectionFromParent(
2155       *intersection_state);
2156 }
2157
2158 void WebFrameWidgetImpl::EnableDeviceEmulation(
2159     const DeviceEmulationParams& parameters) {
2160   // Device Emaulation is only supported for the main frame.
2161   DCHECK(ForMainFrame());
2162   if (!device_emulator_) {
2163     gfx::Size size_in_dips = widget_base_->BlinkSpaceToFlooredDIPs(Size());
2164
2165     device_emulator_ = MakeGarbageCollected<ScreenMetricsEmulator>(
2166         this, widget_base_->screen_infos(), size_in_dips,
2167         widget_base_->VisibleViewportSizeInDIPs(),
2168         widget_base_->WidgetScreenRect(), widget_base_->WindowScreenRect());
2169   }
2170   device_emulator_->ChangeEmulationParams(parameters);
2171 }
2172
2173 void WebFrameWidgetImpl::DisableDeviceEmulation() {
2174   if (!device_emulator_)
2175     return;
2176   device_emulator_->DisableAndApply();
2177   device_emulator_ = nullptr;
2178 }
2179
2180 void WebFrameWidgetImpl::SetIsInertForSubFrame(bool inert) {
2181   DCHECK(ForSubframe());
2182   LocalRootImpl()->GetFrame()->SetIsInert(inert);
2183 }
2184
2185 absl::optional<gfx::Point>
2186 WebFrameWidgetImpl::GetAndResetContextMenuLocation() {
2187   return std::move(host_context_menu_location_);
2188 }
2189
2190 void WebFrameWidgetImpl::SetZoomLevel(double zoom_level) {
2191   // Override the zoom level with the testing one if necessary.
2192   if (zoom_level_for_testing_ != -INFINITY)
2193     zoom_level = zoom_level_for_testing_;
2194
2195   // Set the layout shift exclusion window for the zoom level change.
2196   if (View()->ZoomLevel() != zoom_level)
2197     NotifyZoomLevelChanged(LocalRootImpl()->GetFrame());
2198
2199   View()->SetZoomLevel(zoom_level);
2200
2201   // Part of the UpdateVisualProperties dance we send the zoom level to
2202   // RemoteFrames that are below the local root for this widget.
2203   ForEachRemoteFrameControlledByWidget([zoom_level](RemoteFrame* remote_frame) {
2204     remote_frame->ZoomLevelChanged(zoom_level);
2205   });
2206 }
2207
2208 void WebFrameWidgetImpl::SetAutoResizeMode(bool auto_resize,
2209                                            const gfx::Size& min_window_size,
2210                                            const gfx::Size& max_window_size,
2211                                            float device_scale_factor) {
2212   // Auto resize only applies to main frames.
2213   DCHECK(ForMainFrame());
2214
2215   if (auto_resize) {
2216     View()->EnableAutoResizeMode(
2217         gfx::ScaleToCeiledSize(min_window_size, device_scale_factor),
2218         gfx::ScaleToCeiledSize(max_window_size, device_scale_factor));
2219   } else if (AutoResizeMode()) {
2220     View()->DisableAutoResizeMode();
2221   }
2222 }
2223
2224 void WebFrameWidgetImpl::DidAutoResize(const gfx::Size& size) {
2225   DCHECK(ForMainFrame());
2226   gfx::Size size_in_dips = widget_base_->BlinkSpaceToFlooredDIPs(size);
2227   size_ = size;
2228
2229   // TODO(ccameron): Note that this destroys any information differentiating
2230   // |size| from the compositor's viewport size.
2231   gfx::Rect size_with_dsf = gfx::Rect(gfx::ScaleToCeiledSize(
2232       gfx::Rect(size_in_dips).size(),
2233       widget_base_->GetScreenInfo().device_scale_factor));
2234   widget_base_->LayerTreeHost()->RequestNewLocalSurfaceId();
2235   widget_base_->UpdateCompositorViewportRect(size_with_dsf);
2236 }
2237
2238 LocalFrame* WebFrameWidgetImpl::FocusedLocalFrameInWidget() const {
2239   if (!local_root_) {
2240     // WebFrameWidget is created in the call to CreateFrame. The corresponding
2241     // RenderWidget, however, might not swap in right away (InstallNewDocument()
2242     // will lead to it swapping in). During this interval local_root_ is nullptr
2243     // (see https://crbug.com/792345).
2244     return nullptr;
2245   }
2246
2247   LocalFrame* frame = GetPage()->GetFocusController().FocusedFrame();
2248   return (frame && frame->LocalFrameRoot() == local_root_->GetFrame())
2249              ? frame
2250              : nullptr;
2251 }
2252
2253 WebLocalFrameImpl* WebFrameWidgetImpl::FocusedWebLocalFrameInWidget() const {
2254   return WebLocalFrameImpl::FromFrame(FocusedLocalFrameInWidget());
2255 }
2256
2257 bool WebFrameWidgetImpl::ScrollFocusedEditableElementIntoView() {
2258   Element* element = FocusedElement();
2259   if (!element)
2260     return false;
2261
2262   EditContext* edit_context = element->GetDocument()
2263                                   .GetFrame()
2264                                   ->GetInputMethodController()
2265                                   .GetActiveEditContext();
2266
2267   if (!WebElement(element).IsEditable() && !edit_context)
2268     return false;
2269
2270   element->GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kSelection);
2271
2272   if (!element->GetLayoutObject())
2273     return false;
2274
2275   // The page scale animation started by ZoomAndScrollToFocusedEditableRect
2276   // will scroll only the visual and layout viewports. Call ScrollRectToVisible
2277   // first to ensure the editable is visible within the document (i.e. scroll
2278   // it into view in any subscrollers). By setting `for_focused_editable`,
2279   // ScrollRectToVisible will stop bubbling when it reaches the layout viewport
2280   // so that can be animated by the PageScaleAnimation.
2281   mojom::blink::ScrollIntoViewParamsPtr params =
2282       ScrollAlignment::CreateScrollIntoViewParams(
2283           ScrollAlignment::CenterIfNeeded(), ScrollAlignment::CenterIfNeeded(),
2284           mojom::blink::ScrollType::kProgrammatic,
2285           /*make_visible_in_visual_viewport=*/false,
2286           mojom::blink::ScrollBehavior::kInstant);
2287   params->for_focused_editable = mojom::blink::FocusedEditableParams::New();
2288
2289   // When deciding whether to zoom in on a focused text box, we should
2290   // decide not to zoom in if the user won't be able to zoom out. e.g if the
2291   // textbox is within a touch-action: none container the user can't zoom
2292   // back out.
2293   TouchAction action = touch_action_util::ComputeEffectiveTouchAction(*element);
2294   params->for_focused_editable->can_zoom =
2295       static_cast<int>(action) & static_cast<int>(TouchAction::kPinchZoom);
2296
2297   PhysicalRect absolute_element_bounds;
2298   PhysicalRect absolute_caret_bounds;
2299
2300   if (edit_context) {
2301     gfx::Rect control_bounds_in_physical_pixels;
2302     gfx::Rect selection_bounds_in_physical_pixels;
2303     edit_context->GetLayoutBounds(&control_bounds_in_physical_pixels,
2304                                   &selection_bounds_in_physical_pixels);
2305
2306     absolute_element_bounds = PhysicalRect(control_bounds_in_physical_pixels);
2307     absolute_caret_bounds = PhysicalRect(selection_bounds_in_physical_pixels);
2308   } else {
2309     absolute_element_bounds =
2310         PhysicalRect(element->GetLayoutObject()->AbsoluteBoundingBoxRect());
2311     absolute_caret_bounds = PhysicalRect(
2312         element->GetDocument().GetFrame()->Selection().ComputeRectToScroll(
2313             kRevealExtent));
2314   }
2315
2316   gfx::Vector2dF editable_offset_from_caret(absolute_element_bounds.offset -
2317                                             absolute_caret_bounds.offset);
2318   gfx::SizeF editable_size(absolute_element_bounds.size);
2319
2320   if (editable_size.IsEmpty()) {
2321     return false;
2322   }
2323
2324   params->for_focused_editable->relative_location = editable_offset_from_caret;
2325   params->for_focused_editable->size = editable_size;
2326
2327   scroll_into_view_util::ScrollRectToVisible(
2328       *element->GetLayoutObject(), absolute_caret_bounds, std::move(params));
2329
2330   return true;
2331 }
2332
2333 void WebFrameWidgetImpl::ResetMeaningfulLayoutStateForMainFrame() {
2334   MainFrameData& data = main_data();
2335   data.should_dispatch_first_visually_non_empty_layout = true;
2336   data.should_dispatch_first_layout_after_finished_parsing = true;
2337   data.should_dispatch_first_layout_after_finished_loading = true;
2338   data.last_background_color.reset();
2339
2340 #if BUILDFLAG(IS_EFL)
2341   if (widget_base_ && widget_base_->LayerTreeHost())
2342     widget_base_->LayerTreeHost()->ResetMeaningfulLayoutStateForMainFrame();
2343 #endif
2344 }
2345
2346 void WebFrameWidgetImpl::InitializeCompositing(
2347     const display::ScreenInfos& screen_infos,
2348     const cc::LayerTreeSettings* settings) {
2349   InitializeCompositingInternal(screen_infos, settings, nullptr);
2350 }
2351
2352 void WebFrameWidgetImpl::InitializeCompositingFromPreviousWidget(
2353     const display::ScreenInfos& screen_infos,
2354     const cc::LayerTreeSettings* settings,
2355     WebFrameWidget& previous_widget) {
2356   InitializeCompositingInternal(screen_infos, settings, &previous_widget);
2357 }
2358
2359 void WebFrameWidgetImpl::InitializeCompositingInternal(
2360     const display::ScreenInfos& screen_infos,
2361     const cc::LayerTreeSettings* settings,
2362     WebFrameWidget* previous_widget) {
2363   DCHECK(View()->does_composite());
2364   DCHECK(!non_composited_client_);  // Assure only one initialize is called.
2365   widget_base_->InitializeCompositing(
2366       *GetPage()->GetPageScheduler(), screen_infos, settings,
2367       input_handler_weak_ptr_factory_.GetWeakPtr(),
2368       previous_widget ? static_cast<WebFrameWidgetImpl*>(previous_widget)
2369                             ->widget_base_.get()
2370                       : nullptr);
2371
2372   probe::DidInitializeFrameWidget(local_root_->GetFrame());
2373
2374   // TODO(bokan): This seems wrong. Page may host multiple FrameWidgets so this
2375   // will call DidInitializeCompositing once per FrameWidget. It probably makes
2376   // sense to move LinkHighlight from Page to WidgetBase so initialization is
2377   // per-widget. See also: https://crbug.com/1344531.
2378   GetPage()->DidInitializeCompositing(*AnimationHost());
2379 }
2380
2381 void WebFrameWidgetImpl::InitializeNonCompositing(
2382     WebNonCompositedWidgetClient* client) {
2383   DCHECK(!non_composited_client_);
2384   DCHECK(client);
2385   DCHECK(!View()->does_composite());
2386   widget_base_->InitializeNonCompositing();
2387   non_composited_client_ = client;
2388 }
2389
2390 void WebFrameWidgetImpl::SetCompositorVisible(bool visible) {
2391   widget_base_->SetCompositorVisible(visible);
2392 }
2393
2394 gfx::Size WebFrameWidgetImpl::Size() {
2395   return size_.value_or(gfx::Size());
2396 }
2397
2398 void WebFrameWidgetImpl::Resize(const gfx::Size& new_size) {
2399   if (size_ && *size_ == new_size)
2400     return;
2401
2402   if (ForMainFrame()) {
2403     size_ = new_size;
2404     View()->Resize(new_size);
2405     return;
2406   }
2407
2408   if (child_data().did_suspend_parsing) {
2409     child_data().did_suspend_parsing = false;
2410     LocalRootImpl()->GetFrame()->Loader().GetDocumentLoader()->ResumeParser();
2411   }
2412
2413   LocalFrameView* view = LocalRootImpl()->GetFrameView();
2414   DCHECK(view);
2415
2416   size_ = new_size;
2417
2418   view->SetLayoutSize(*size_);
2419   view->Resize(*size_);
2420 }
2421
2422 void WebFrameWidgetImpl::OnCommitRequested() {
2423   // This can be called during shutdown, in which case local_root_ will be
2424   // nullptr.
2425   if (!LocalRootImpl() || !LocalRootImpl()->GetFrame()) {
2426     return;
2427   }
2428   if (auto* view = LocalRootImpl()->GetFrame()->View())
2429     view->OnCommitRequested();
2430 }
2431
2432 void WebFrameWidgetImpl::BeginMainFrame(base::TimeTicks last_frame_time) {
2433   TRACE_EVENT1("blink", "WebFrameWidgetImpl::BeginMainFrame", "frameTime",
2434                last_frame_time);
2435   DCHECK(!last_frame_time.is_null());
2436   CHECK(LocalRootImpl());
2437
2438   // The last_frame_time is created in the compositor thread, it's the time when
2439   // the compositor is ready for a new frame and starts preparing it. For the
2440   // purpose of animation frame timing, this is the desired time to start
2441   // rendering, equivalent to the time when a work task is posted.
2442   if (animation_frame_timing_monitor_) {
2443     animation_frame_timing_monitor_->SetDesiredRenderStartTime(last_frame_time);
2444   }
2445
2446   // Dirty bit on MouseEventManager is not cleared in OOPIFs after scroll
2447   // or layout changes. Ensure the hover state is recomputed if necessary.
2448   LocalRootImpl()
2449       ->GetFrame()
2450       ->GetEventHandler()
2451       .RecomputeMouseHoverStateIfNeeded();
2452
2453   absl::optional<LocalFrameUkmAggregator::ScopedUkmHierarchicalTimer> ukm_timer;
2454   if (WidgetBase::ShouldRecordBeginMainFrameMetrics()) {
2455     ukm_timer.emplace(
2456         LocalRootImpl()->GetFrame()->View()->GetUkmAggregator()->GetScopedTimer(
2457             LocalFrameUkmAggregator::kAnimate));
2458   }
2459
2460   GetPage()->Animate(last_frame_time);
2461   // Animate can cause the local frame to detach.
2462   if (!LocalRootImpl())
2463     return;
2464
2465   GetPage()->GetValidationMessageClient().LayoutOverlay();
2466 }
2467
2468 void WebFrameWidgetImpl::BeginCommitCompositorFrame() {
2469   if (commit_compositor_frame_start_time_.has_value()) {
2470     next_commit_compositor_frame_start_time_.emplace(base::TimeTicks::Now());
2471   } else {
2472     commit_compositor_frame_start_time_.emplace(base::TimeTicks::Now());
2473   }
2474   GetPage()->GetChromeClient().WillCommitCompositorFrame();
2475   probe::LayerTreePainted(LocalRootImpl()->GetFrame());
2476   if (ForTopMostMainFrame()) {
2477     Document* doc = local_root_->GetFrame()->GetDocument();
2478     if (doc->GetSettings()->GetViewportMetaEnabled() &&
2479         !LayerTreeHost()->IsMobileOptimized()) {
2480       UseCounter::Count(doc, WebFeature::kTapDelayEnabled);
2481     }
2482   }
2483   if (ForMainFrame()) {
2484     View()->DidCommitCompositorFrameForLocalMainFrame();
2485     View()->UpdatePreferredSize();
2486     if (!View()->MainFrameImpl()) {
2487       // Trying to track down why the view's idea of the main frame varies
2488       // from LocalRootImpl's.
2489       // TODO(https://crbug.com/1139104): Remove this.
2490       std::string reason = View()->GetNullFrameReasonForBug1139104();
2491       DCHECK(false) << reason;
2492       SCOPED_CRASH_KEY_STRING32("Crbug1139104", "NullFrameReason", reason);
2493       base::debug::DumpWithoutCrashing();
2494     }
2495   }
2496 }
2497
2498 void WebFrameWidgetImpl::EndCommitCompositorFrame(
2499     base::TimeTicks commit_start_time,
2500     base::TimeTicks commit_finish_time) {
2501   DCHECK(commit_compositor_frame_start_time_.has_value());
2502   LocalRootImpl()
2503       ->GetFrame()
2504       ->View()
2505       ->GetUkmAggregator()
2506       ->RecordImplCompositorSample(commit_compositor_frame_start_time_.value(),
2507                                    commit_start_time, commit_finish_time);
2508   commit_compositor_frame_start_time_ =
2509       next_commit_compositor_frame_start_time_;
2510   next_commit_compositor_frame_start_time_.reset();
2511 }
2512
2513 void WebFrameWidgetImpl::ApplyViewportChanges(
2514     const ApplyViewportChangesArgs& args) {
2515   // Viewport changes only change the outermost main frame. Technically a
2516   // portal has a viewport but it cannot produce changes from the compositor
2517   // until activated so this should be correct for portals too.
2518   if (!LocalRootImpl()->GetFrame()->IsOutermostMainFrame())
2519     return;
2520
2521   WebViewImpl* web_view = View();
2522   // TODO(https://crbug.com/1160652): Figure out if View is null.
2523   CHECK(widget_base_);
2524   CHECK(web_view);
2525   web_view->ApplyViewportChanges(args);
2526 }
2527
2528 void WebFrameWidgetImpl::RecordManipulationTypeCounts(
2529     cc::ManipulationInfo info) {
2530   // Manipulation counts are only recorded for the main frame.
2531   if (!ForMainFrame())
2532     return;
2533
2534   if ((info & cc::kManipulationInfoWheel) == cc::kManipulationInfoWheel) {
2535     UseCounter::Count(LocalRootImpl()->GetDocument(),
2536                       WebFeature::kScrollByWheel);
2537   }
2538   if ((info & cc::kManipulationInfoTouch) == cc::kManipulationInfoTouch) {
2539     UseCounter::Count(LocalRootImpl()->GetDocument(),
2540                       WebFeature::kScrollByTouch);
2541   }
2542   if ((info & cc::kManipulationInfoPinchZoom) ==
2543       cc::kManipulationInfoPinchZoom) {
2544     UseCounter::Count(LocalRootImpl()->GetDocument(), WebFeature::kPinchZoom);
2545   }
2546   if ((info & cc::kManipulationInfoPrecisionTouchPad) ==
2547       cc::kManipulationInfoPrecisionTouchPad) {
2548     UseCounter::Count(LocalRootImpl()->GetDocument(),
2549                       WebFeature::kScrollByPrecisionTouchPad);
2550   }
2551 }
2552
2553 void WebFrameWidgetImpl::RecordDispatchRafAlignedInputTime(
2554     base::TimeTicks raf_aligned_input_start_time) {
2555   if (LocalRootImpl()) {
2556     LocalRootImpl()->GetFrame()->View()->GetUkmAggregator()->RecordTimerSample(
2557         LocalFrameUkmAggregator::kHandleInputEvents,
2558         raf_aligned_input_start_time, base::TimeTicks::Now());
2559   }
2560 }
2561
2562 void WebFrameWidgetImpl::SetSuppressFrameRequestsWorkaroundFor704763Only(
2563     bool suppress_frame_requests) {
2564   GetPage()->Animator().SetSuppressFrameRequestsWorkaroundFor704763Only(
2565       suppress_frame_requests);
2566 }
2567
2568 void WebFrameWidgetImpl::CountDroppedPointerDownForEventTiming(unsigned count) {
2569   if (!local_root_ || !(local_root_->GetFrame()) ||
2570       !(local_root_->GetFrame()->DomWindow())) {
2571     return;
2572   }
2573   WindowPerformance* performance = DOMWindowPerformance::performance(
2574       *(local_root_->GetFrame()->DomWindow()));
2575
2576   performance->eventCounts()->AddMultipleEvents(event_type_names::kPointerdown,
2577                                                 count);
2578   // We only count dropped touchstart that can trigger pointerdown.
2579   performance->eventCounts()->AddMultipleEvents(event_type_names::kTouchstart,
2580                                                 count);
2581   // TouchEnd will not be dropped. But in touch event model only touch starts
2582   // can set the target and after that the touch event always goes to that
2583   // target. So if a touchstart has been dropped, the following touchend will
2584   // not be dispatched. Meanwhile, the pointerup can be captured in the
2585   // pointer_event_manager.
2586   performance->eventCounts()->AddMultipleEvents(event_type_names::kTouchend,
2587                                                 count);
2588 }
2589
2590 std::unique_ptr<cc::BeginMainFrameMetrics>
2591 WebFrameWidgetImpl::GetBeginMainFrameMetrics() {
2592   if (!LocalRootImpl())
2593     return nullptr;
2594
2595   return LocalRootImpl()
2596       ->GetFrame()
2597       ->View()
2598       ->GetUkmAggregator()
2599       ->GetBeginMainFrameMetrics();
2600 }
2601
2602 std::unique_ptr<cc::WebVitalMetrics> WebFrameWidgetImpl::GetWebVitalMetrics() {
2603   if (!LocalRootImpl())
2604     return nullptr;
2605
2606   // This class should be called at most once per commit.
2607   WebPerformanceMetricsForReporting perf =
2608       LocalRootImpl()->PerformanceMetricsForReporting();
2609   auto metrics = std::make_unique<cc::WebVitalMetrics>();
2610   if (perf.FirstInputDelay().has_value()) {
2611     metrics->first_input_delay = perf.FirstInputDelay().value();
2612     metrics->has_fid = true;
2613   }
2614
2615   base::TimeTicks start = perf.NavigationStartAsMonotonicTime();
2616   base::TimeTicks largest_contentful_paint =
2617       perf.LargestContentfulDetailsForMetrics().paint_time;
2618   if (largest_contentful_paint >= start) {
2619     metrics->largest_contentful_paint = largest_contentful_paint - start;
2620     metrics->has_lcp = true;
2621   }
2622
2623   double layout_shift = LocalRootImpl()
2624                             ->GetFrame()
2625                             ->View()
2626                             ->GetLayoutShiftTracker()
2627                             .WeightedScore();
2628   if (layout_shift > 0.f) {
2629     metrics->layout_shift = layout_shift;
2630     metrics->has_cls = true;
2631   }
2632
2633   if (!metrics->HasValue())
2634     return nullptr;
2635
2636   return metrics;
2637 }
2638
2639 void WebFrameWidgetImpl::BeginUpdateLayers() {
2640   if (LocalRootImpl())
2641     update_layers_start_time_.emplace(base::TimeTicks::Now());
2642 }
2643
2644 void WebFrameWidgetImpl::EndUpdateLayers() {
2645   if (LocalRootImpl()) {
2646     DCHECK(update_layers_start_time_);
2647     LocalRootImpl()->GetFrame()->View()->GetUkmAggregator()->RecordTimerSample(
2648         LocalFrameUkmAggregator::kUpdateLayers,
2649         update_layers_start_time_.value(), base::TimeTicks::Now());
2650     probe::LayerTreeDidChange(LocalRootImpl()->GetFrame());
2651   }
2652   update_layers_start_time_.reset();
2653 }
2654
2655 void WebFrameWidgetImpl::RecordStartOfFrameMetrics() {
2656   if (!LocalRootImpl())
2657     return;
2658
2659   LocalRootImpl()->GetFrame()->View()->GetUkmAggregator()->BeginMainFrame();
2660 }
2661
2662 void WebFrameWidgetImpl::RecordEndOfFrameMetrics(
2663     base::TimeTicks frame_begin_time,
2664     cc::ActiveFrameSequenceTrackers trackers) {
2665   if (!LocalRootImpl())
2666     return;
2667   Document* document = LocalRootImpl()->GetFrame()->GetDocument();
2668   DCHECK(document);
2669   LocalRootImpl()
2670       ->GetFrame()
2671       ->View()
2672       ->GetUkmAggregator()
2673       ->RecordEndOfFrameMetrics(frame_begin_time, base::TimeTicks::Now(),
2674                                 trackers, document->UkmSourceID(),
2675                                 document->UkmRecorder());
2676 }
2677
2678 void WebFrameWidgetImpl::WillHandleGestureEvent(const WebGestureEvent& event,
2679                                                 bool* suppress) {
2680   possible_drag_event_info_.source = ui::mojom::blink::DragEventSource::kTouch;
2681   possible_drag_event_info_.location =
2682       gfx::ToFlooredPoint(event.PositionInScreen());
2683
2684   bool handle_as_cursor_control = false;
2685   switch (event.GetType()) {
2686     case WebInputEvent::Type::kGestureScrollBegin: {
2687       if (event.data.scroll_begin.cursor_control) {
2688         swipe_to_move_cursor_activated_ = true;
2689         handle_as_cursor_control = true;
2690       }
2691       break;
2692     }
2693     case WebInputEvent::Type::kGestureScrollUpdate: {
2694       if (swipe_to_move_cursor_activated_)
2695         handle_as_cursor_control = true;
2696       break;
2697     }
2698     case WebInputEvent::Type::kGestureScrollEnd: {
2699       if (swipe_to_move_cursor_activated_) {
2700         swipe_to_move_cursor_activated_ = false;
2701         handle_as_cursor_control = true;
2702       }
2703       break;
2704     }
2705     default:
2706       break;
2707   }
2708   // TODO(crbug.com/1140106): Place cursor for scroll begin other than just move
2709   // cursor.
2710   if (handle_as_cursor_control) {
2711     WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
2712     if (focused_frame) {
2713       gfx::Point base(event.PositionInWidget().x(),
2714                       event.PositionInWidget().y());
2715       focused_frame->MoveCaretSelection(base);
2716     }
2717     *suppress = true;
2718   }
2719 }
2720
2721 void WebFrameWidgetImpl::WillHandleMouseEvent(const WebMouseEvent& event) {
2722   possible_drag_event_info_.source = ui::mojom::blink::DragEventSource::kMouse;
2723   possible_drag_event_info_.location =
2724       gfx::Point(event.PositionInScreen().x(), event.PositionInScreen().y());
2725 }
2726
2727 void WebFrameWidgetImpl::ObserveGestureEventAndResult(
2728     const WebGestureEvent& gesture_event,
2729     const gfx::Vector2dF& unused_delta,
2730     const cc::OverscrollBehavior& overscroll_behavior,
2731     bool event_processed) {
2732   if (!widget_base_->LayerTreeHost()->GetSettings().enable_elastic_overscroll)
2733     return;
2734
2735   cc::InputHandlerScrollResult scroll_result;
2736   scroll_result.did_scroll = event_processed;
2737   scroll_result.did_overscroll_root = !unused_delta.IsZero();
2738   scroll_result.unused_scroll_delta = unused_delta;
2739   scroll_result.overscroll_behavior = overscroll_behavior;
2740
2741   widget_base_->widget_input_handler_manager()->ObserveGestureEventOnMainThread(
2742       gesture_event, scroll_result);
2743 }
2744
2745 void WebFrameWidgetImpl::DidHandleKeyEvent() {
2746   ClearEditCommands();
2747 }
2748
2749 WebTextInputType WebFrameWidgetImpl::GetTextInputType() {
2750   if (ShouldDispatchImeEventsToPlugin()) {
2751     return GetFocusedPluginContainer()->GetPluginTextInputType();
2752   }
2753
2754   WebInputMethodController* controller = GetActiveWebInputMethodController();
2755   if (!controller)
2756     return WebTextInputType::kWebTextInputTypeNone;
2757   return controller->TextInputType();
2758 }
2759
2760 void WebFrameWidgetImpl::SetCursorVisibilityState(bool is_visible) {
2761   GetPage()->SetIsCursorVisible(is_visible);
2762 }
2763
2764 void WebFrameWidgetImpl::ApplyViewportChangesForTesting(
2765     const ApplyViewportChangesArgs& args) {
2766   widget_base_->ApplyViewportChanges(args);
2767 }
2768
2769 void WebFrameWidgetImpl::SetDisplayMode(mojom::blink::DisplayMode mode) {
2770   if (mode != display_mode_) {
2771     display_mode_ = mode;
2772     LocalFrame* frame = LocalRootImpl()->GetFrame();
2773     frame->MediaQueryAffectingValueChangedForLocalSubtree(
2774         MediaValueChange::kOther);
2775   }
2776 }
2777
2778 void WebFrameWidgetImpl::SetWindowShowState(ui::WindowShowState state) {
2779   if (state == window_show_state_) {
2780     return;
2781   }
2782
2783   window_show_state_ = state;
2784   LocalFrame* frame = LocalRootImpl()->GetFrame();
2785   frame->MediaQueryAffectingValueChangedForLocalSubtree(
2786       MediaValueChange::kOther);
2787 }
2788
2789 void WebFrameWidgetImpl::SetResizable(bool resizable) {
2790   if (resizable_ == resizable) {
2791     return;
2792   }
2793
2794   resizable_ = resizable;
2795   LocalFrame* frame = LocalRootImpl()->GetFrame();
2796   frame->MediaQueryAffectingValueChangedForLocalSubtree(
2797       MediaValueChange::kOther);
2798 }
2799
2800 void WebFrameWidgetImpl::SetWindowSegments(
2801     const std::vector<gfx::Rect>& window_segments_param) {
2802   WebVector<gfx::Rect> window_segments(window_segments_param);
2803   if (!window_segments_.Equals(window_segments)) {
2804     window_segments_ = window_segments;
2805     LocalFrame* frame = LocalRootImpl()->GetFrame();
2806     frame->WindowSegmentsChanged(window_segments_);
2807
2808     ForEachRemoteFrameControlledByWidget(
2809         [&window_segments = window_segments_param](RemoteFrame* remote_frame) {
2810           remote_frame->DidChangeRootWindowSegments(window_segments);
2811         });
2812   }
2813 }
2814
2815 void WebFrameWidgetImpl::SetCursor(const ui::Cursor& cursor) {
2816   widget_base_->SetCursor(cursor);
2817 }
2818
2819 bool WebFrameWidgetImpl::HandlingInputEvent() {
2820   return widget_base_->input_handler().handling_input_event();
2821 }
2822
2823 void WebFrameWidgetImpl::SetHandlingInputEvent(bool handling) {
2824   widget_base_->input_handler().set_handling_input_event(handling);
2825 }
2826
2827 void WebFrameWidgetImpl::ProcessInputEventSynchronouslyForTesting(
2828     const WebCoalescedInputEvent& event,
2829     WidgetBaseInputHandler::HandledEventCallback callback) {
2830   widget_base_->input_handler().HandleInputEvent(event, nullptr,
2831                                                  std::move(callback));
2832 }
2833
2834 void WebFrameWidgetImpl::ProcessInputEventSynchronouslyForTesting(
2835     const WebCoalescedInputEvent& event) {
2836   ProcessInputEventSynchronouslyForTesting(event, base::DoNothing());
2837 }
2838
2839 WebInputEventResult WebFrameWidgetImpl::DispatchBufferedTouchEvents() {
2840   CHECK(LocalRootImpl());
2841
2842   if (WebDevToolsAgentImpl* devtools = LocalRootImpl()->DevToolsAgentImpl())
2843     devtools->DispatchBufferedTouchEvents();
2844
2845   return LocalRootImpl()
2846       ->GetFrame()
2847       ->GetEventHandler()
2848       .DispatchBufferedTouchEvents();
2849 }
2850
2851 WebInputEventResult WebFrameWidgetImpl::HandleInputEvent(
2852     const WebCoalescedInputEvent& coalesced_event) {
2853   const WebInputEvent& input_event = coalesced_event.Event();
2854   TRACE_EVENT1("input,rail", "WebFrameWidgetImpl::HandleInputEvent", "type",
2855                WebInputEvent::GetName(input_event.GetType()));
2856   DCHECK(!WebInputEvent::IsTouchEventType(input_event.GetType()));
2857   CHECK(LocalRootImpl());
2858
2859   // Clients shouldn't be dispatching events to a provisional frame but this
2860   // can happen. Ensure that event handling can assume we're in a committed
2861   // frame.
2862   if (IsProvisional())
2863     return WebInputEventResult::kHandledSuppressed;
2864
2865   // If a drag-and-drop operation is in progress, ignore input events except
2866   // PointerCancel and GestureLongPress.
2867   if (doing_drag_and_drop_ &&
2868       input_event.GetType() != WebInputEvent::Type::kPointerCancel &&
2869       input_event.GetType() != WebInputEvent::Type::kGestureLongPress) {
2870     return WebInputEventResult::kHandledSuppressed;
2871   }
2872
2873   // Don't handle events once we've started shutting down or when the page is in
2874   // bfcache.
2875   if (!GetPage() ||
2876       GetPage()->GetPageLifecycleState()->is_in_back_forward_cache) {
2877     return WebInputEventResult::kNotHandled;
2878   }
2879
2880   if (WebDevToolsAgentImpl* devtools = LocalRootImpl()->DevToolsAgentImpl()) {
2881     auto result = devtools->HandleInputEvent(input_event);
2882     if (result != WebInputEventResult::kNotHandled)
2883       return result;
2884   }
2885
2886   // Report the event to be NOT processed by WebKit, so that the browser can
2887   // handle it appropriately.
2888   if (ShouldIgnoreInputEvents()) {
2889     return WebInputEventResult::kNotHandled;
2890   }
2891
2892   base::AutoReset<const WebInputEvent*> current_event_change(
2893       &CurrentInputEvent::current_input_event_, &input_event);
2894   UIEventWithKeyState::ClearNewTabModifierSetFromIsolatedWorld();
2895
2896   if (GetPage()->GetPointerLockController().IsPointerLocked() &&
2897       WebInputEvent::IsMouseEventType(input_event.GetType())) {
2898     PointerLockMouseEvent(coalesced_event);
2899     return WebInputEventResult::kHandledSystem;
2900   }
2901
2902   /// These metrics are only captured for the main frame.
2903   if (ForMainFrame()) {
2904     Document& main_frame_document = *LocalRootImpl()->GetFrame()->GetDocument();
2905
2906     if (input_event.GetType() != WebInputEvent::Type::kMouseMove) {
2907       FirstMeaningfulPaintDetector::From(main_frame_document)
2908           .NotifyInputEvent();
2909     }
2910
2911     if (input_event.GetType() != WebInputEvent::Type::kMouseMove &&
2912         input_event.GetType() != WebInputEvent::Type::kMouseEnter &&
2913         input_event.GetType() != WebInputEvent::Type::kMouseLeave) {
2914       InteractiveDetector* interactive_detector(
2915           InteractiveDetector::From(main_frame_document));
2916       if (interactive_detector) {
2917         interactive_detector->OnInvalidatingInputEvent(input_event.TimeStamp());
2918       }
2919     }
2920   }
2921
2922   NotifyInputObservers(coalesced_event);
2923
2924   // Notify the focus frame of the input. Note that the other frames are not
2925   // notified as input is only handled by the focused frame.
2926   Frame* frame = FocusedCoreFrame();
2927   if (auto* local_frame = DynamicTo<LocalFrame>(frame)) {
2928     if (auto* content_capture_manager =
2929             local_frame->LocalFrameRoot().GetOrResetContentCaptureManager()) {
2930       content_capture_manager->NotifyInputEvent(input_event.GetType(),
2931                                                 *local_frame);
2932     }
2933   }
2934
2935   // Skip the pointerrawupdate for mouse capture case.
2936   if (mouse_capture_element_ &&
2937       input_event.GetType() == WebInputEvent::Type::kPointerRawUpdate)
2938     return WebInputEventResult::kHandledSystem;
2939
2940   if (mouse_capture_element_ &&
2941       WebInputEvent::IsMouseEventType(input_event.GetType()))
2942     return HandleCapturedMouseEvent(coalesced_event);
2943
2944   // FIXME: This should take in the intended frame, not the local frame
2945   // root.
2946   return WidgetEventHandler::HandleInputEvent(coalesced_event,
2947                                               LocalRootImpl()->GetFrame());
2948 }
2949
2950 WebInputEventResult WebFrameWidgetImpl::HandleCapturedMouseEvent(
2951     const WebCoalescedInputEvent& coalesced_event) {
2952   const WebInputEvent& input_event = coalesced_event.Event();
2953   TRACE_EVENT1("input", "captured mouse event", "type", input_event.GetType());
2954   // Save |mouse_capture_element_| since |MouseCaptureLost()| will clear it.
2955   HTMLPlugInElement* element = mouse_capture_element_;
2956
2957   // Not all platforms call mouseCaptureLost() directly.
2958   if (input_event.GetType() == WebInputEvent::Type::kMouseUp) {
2959     SetMouseCapture(false);
2960     MouseCaptureLost();
2961   }
2962
2963   AtomicString event_type;
2964   switch (input_event.GetType()) {
2965     case WebInputEvent::Type::kMouseEnter:
2966       event_type = event_type_names::kMouseover;
2967       break;
2968     case WebInputEvent::Type::kMouseMove:
2969       event_type = event_type_names::kMousemove;
2970       break;
2971     case WebInputEvent::Type::kPointerRawUpdate:
2972       // There will be no mouse event for rawupdate events.
2973       event_type = event_type_names::kPointerrawupdate;
2974       break;
2975     case WebInputEvent::Type::kMouseLeave:
2976       event_type = event_type_names::kMouseout;
2977       break;
2978     case WebInputEvent::Type::kMouseDown:
2979       event_type = event_type_names::kMousedown;
2980       LocalFrame::NotifyUserActivation(
2981           element->GetDocument().GetFrame(),
2982           mojom::blink::UserActivationNotificationType::kInteraction);
2983       break;
2984     case WebInputEvent::Type::kMouseUp:
2985       event_type = event_type_names::kMouseup;
2986       break;
2987     default:
2988       NOTREACHED();
2989   }
2990
2991   WebMouseEvent transformed_event =
2992       TransformWebMouseEvent(LocalRootImpl()->GetFrameView(),
2993                              static_cast<const WebMouseEvent&>(input_event));
2994   if (LocalFrame* frame = element->GetDocument().GetFrame()) {
2995     frame->GetEventHandler().HandleTargetedMouseEvent(
2996         element, transformed_event, event_type,
2997         TransformWebMouseEventVector(
2998             LocalRootImpl()->GetFrameView(),
2999             coalesced_event.GetCoalescedEventsPointers()),
3000         TransformWebMouseEventVector(
3001             LocalRootImpl()->GetFrameView(),
3002             coalesced_event.GetPredictedEventsPointers()));
3003   }
3004   return WebInputEventResult::kHandledSystem;
3005 }
3006
3007 void WebFrameWidgetImpl::UpdateTextInputState() {
3008   widget_base_->UpdateTextInputState();
3009 }
3010
3011 void WebFrameWidgetImpl::UpdateSelectionBounds() {
3012   widget_base_->UpdateSelectionBounds();
3013 }
3014
3015 void WebFrameWidgetImpl::ShowVirtualKeyboard() {
3016   widget_base_->ShowVirtualKeyboard();
3017 }
3018
3019 void WebFrameWidgetImpl::FlushInputProcessedCallback() {
3020   widget_base_->FlushInputProcessedCallback();
3021 }
3022
3023 void WebFrameWidgetImpl::CancelCompositionForPepper() {
3024   widget_base_->CancelCompositionForPepper();
3025 }
3026
3027 void WebFrameWidgetImpl::RequestMouseLock(
3028     bool has_transient_user_activation,
3029     bool request_unadjusted_movement,
3030     mojom::blink::WidgetInputHandlerHost::RequestMouseLockCallback callback) {
3031   mojom::blink::WidgetInputHandlerHost* host =
3032       widget_base_->widget_input_handler_manager()->GetWidgetInputHandlerHost();
3033
3034   // If we don't have a host just leave the callback uncalled. This simulates
3035   // the browser indefinitely postponing the mouse request which is valid.
3036   // Note that |callback| is not a mojo bound callback (until it is passed
3037   // into the mojo interface) and can be destructed without invoking the
3038   // callback. It does share the same signature as the mojo definition
3039   // for simplicity.
3040   if (host) {
3041     host->RequestMouseLock(has_transient_user_activation,
3042                            request_unadjusted_movement, std::move(callback));
3043   }
3044 }
3045
3046 void WebFrameWidgetImpl::MouseCaptureLost() {
3047   TRACE_EVENT_NESTABLE_ASYNC_END0("input", "capturing mouse",
3048                                   TRACE_ID_LOCAL(this));
3049   mouse_capture_element_ = nullptr;
3050 }
3051
3052 void WebFrameWidgetImpl::ApplyVisualProperties(
3053     const VisualProperties& visual_properties) {
3054   widget_base_->UpdateVisualProperties(visual_properties);
3055 }
3056
3057 bool WebFrameWidgetImpl::IsFullscreenGranted() {
3058   return is_fullscreen_granted_;
3059 }
3060
3061 bool WebFrameWidgetImpl::PinchGestureActiveInMainFrame() {
3062   return is_pinch_gesture_active_in_mainframe_;
3063 }
3064
3065 float WebFrameWidgetImpl::PageScaleInMainFrame() {
3066   return page_scale_factor_in_mainframe_;
3067 }
3068
3069 void WebFrameWidgetImpl::UpdateSurfaceAndScreenInfo(
3070     const viz::LocalSurfaceId& new_local_surface_id,
3071     const gfx::Rect& compositor_viewport_pixel_rect,
3072     const display::ScreenInfos& new_screen_infos) {
3073   widget_base_->UpdateSurfaceAndScreenInfo(
3074       new_local_surface_id, compositor_viewport_pixel_rect, new_screen_infos);
3075 }
3076
3077 void WebFrameWidgetImpl::UpdateScreenInfo(
3078     const display::ScreenInfos& new_screen_infos) {
3079   widget_base_->UpdateScreenInfo(new_screen_infos);
3080 }
3081
3082 void WebFrameWidgetImpl::UpdateSurfaceAndCompositorRect(
3083     const viz::LocalSurfaceId& new_local_surface_id,
3084     const gfx::Rect& compositor_viewport_pixel_rect) {
3085   widget_base_->UpdateSurfaceAndCompositorRect(new_local_surface_id,
3086                                                compositor_viewport_pixel_rect);
3087 }
3088
3089 void WebFrameWidgetImpl::UpdateCompositorViewportRect(
3090     const gfx::Rect& compositor_viewport_pixel_rect) {
3091   widget_base_->UpdateCompositorViewportRect(compositor_viewport_pixel_rect);
3092 }
3093
3094 const display::ScreenInfo& WebFrameWidgetImpl::GetScreenInfo() {
3095   return widget_base_->GetScreenInfo();
3096 }
3097
3098 const display::ScreenInfos& WebFrameWidgetImpl::GetScreenInfos() {
3099   return widget_base_->screen_infos();
3100 }
3101
3102 const display::ScreenInfo& WebFrameWidgetImpl::GetOriginalScreenInfo() {
3103   if (device_emulator_)
3104     return device_emulator_->GetOriginalScreenInfo();
3105   return widget_base_->GetScreenInfo();
3106 }
3107
3108 const display::ScreenInfos& WebFrameWidgetImpl::GetOriginalScreenInfos() {
3109   if (device_emulator_)
3110     return device_emulator_->original_screen_infos();
3111   return widget_base_->screen_infos();
3112 }
3113
3114 gfx::Rect WebFrameWidgetImpl::WindowRect() {
3115   return widget_base_->WindowRect();
3116 }
3117
3118 gfx::Rect WebFrameWidgetImpl::ViewRect() {
3119   return widget_base_->ViewRect();
3120 }
3121
3122 void WebFrameWidgetImpl::SetScreenRects(const gfx::Rect& widget_screen_rect,
3123                                         const gfx::Rect& window_screen_rect) {
3124   widget_base_->SetScreenRects(widget_screen_rect, window_screen_rect);
3125 }
3126
3127 gfx::Size WebFrameWidgetImpl::VisibleViewportSizeInDIPs() {
3128   return widget_base_->VisibleViewportSizeInDIPs();
3129 }
3130
3131 void WebFrameWidgetImpl::SetPendingWindowRect(
3132     const gfx::Rect& window_screen_rect) {
3133   widget_base_->SetPendingWindowRect(window_screen_rect);
3134 }
3135
3136 void WebFrameWidgetImpl::AckPendingWindowRect() {
3137   widget_base_->AckPendingWindowRect();
3138 }
3139
3140 bool WebFrameWidgetImpl::IsHidden() const {
3141   return widget_base_->is_hidden();
3142 }
3143
3144 WebString WebFrameWidgetImpl::GetLastToolTipTextForTesting() const {
3145   return GetPage()->GetChromeClient().GetLastToolTipTextForTesting();
3146 }
3147
3148 float WebFrameWidgetImpl::GetEmulatorScale() {
3149   if (device_emulator_)
3150     return device_emulator_->scale();
3151   return 1.0f;
3152 }
3153
3154 void WebFrameWidgetImpl::IntrinsicSizingInfoChanged(
3155     mojom::blink::IntrinsicSizingInfoPtr sizing_info) {
3156   DCHECK(ForSubframe());
3157   GetAssociatedFrameWidgetHost()->IntrinsicSizingInfoChanged(
3158       std::move(sizing_info));
3159 }
3160
3161 void WebFrameWidgetImpl::AutoscrollStart(const gfx::PointF& position) {
3162   GetAssociatedFrameWidgetHost()->AutoscrollStart(std::move(position));
3163 }
3164
3165 void WebFrameWidgetImpl::AutoscrollFling(const gfx::Vector2dF& velocity) {
3166   GetAssociatedFrameWidgetHost()->AutoscrollFling(std::move(velocity));
3167 }
3168
3169 void WebFrameWidgetImpl::AutoscrollEnd() {
3170   GetAssociatedFrameWidgetHost()->AutoscrollEnd();
3171 }
3172
3173 void WebFrameWidgetImpl::DidMeaningfulLayout(WebMeaningfulLayout layout_type) {
3174   if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty) {
3175     NotifyPresentationTime(WTF::BindOnce(
3176         &WebFrameWidgetImpl::PresentationCallbackForMeaningfulLayout,
3177         WrapWeakPersistent(this)));
3178   }
3179
3180 #if BUILDFLAG(IS_EFL)
3181   if (widget_base_ && widget_base_->LayerTreeHost()) {
3182     if (layout_type == blink::WebMeaningfulLayout::kVisuallyNonEmpty)
3183       widget_base_->LayerTreeHost()->SetDidFirstNonEmptyLayout();
3184     else if (layout_type == blink::WebMeaningfulLayout::kFinishedParsing)
3185       widget_base_->LayerTreeHost()->SetDidFinishDocumentParsing();
3186   }
3187 #endif
3188
3189   ForEachLocalFrameControlledByWidget(
3190       local_root_->GetFrame(), [layout_type](WebLocalFrameImpl* local_frame) {
3191         local_frame->Client()->DidMeaningfulLayout(layout_type);
3192       });
3193 }
3194
3195 void WebFrameWidgetImpl::PresentationCallbackForMeaningfulLayout(
3196     base::TimeTicks first_paint_time) {
3197   // |local_root_| may be null if the widget has shut down between when this
3198   // callback was requested and when it was resolved by the compositor.
3199   if (local_root_)
3200     local_root_->ViewImpl()->DidFirstVisuallyNonEmptyPaint();
3201
3202   if (widget_base_)
3203     widget_base_->DidFirstVisuallyNonEmptyPaint(first_paint_time);
3204
3205 #if BUILDFLAG(IS_EFL)
3206   if (widget_base_ && widget_base_->LayerTreeHost())
3207     widget_base_->LayerTreeHost()->SetDidTriggerFirstNonEmptyLayoutPaint();
3208 #endif
3209 }
3210
3211 void WebFrameWidgetImpl::RequestAnimationAfterDelay(
3212     const base::TimeDelta& delay) {
3213   widget_base_->RequestAnimationAfterDelay(delay);
3214 }
3215
3216 void WebFrameWidgetImpl::SetRootLayer(scoped_refptr<cc::Layer> layer) {
3217   if (!View()->does_composite()) {
3218     DCHECK(ForMainFrame());
3219     DCHECK(!layer);
3220     return;
3221   }
3222
3223   // Set up some initial state before we are setting the layer.
3224   if (ForSubframe() && layer) {
3225     // Child local roots will always have a transparent background color.
3226     widget_base_->LayerTreeHost()->set_background_color(SkColors::kTransparent);
3227     // Pass the limits even though this is for subframes, as the limits will
3228     // be needed in setting the raster scale.
3229     SetPageScaleStateAndLimits(1.f, false /* is_pinch_gesture_active */,
3230                                View()->MinimumPageScaleFactor(),
3231                                View()->MaximumPageScaleFactor());
3232   }
3233
3234   bool root_layer_exists = !!layer;
3235   if (widget_base_->WillBeDestroyed()) {
3236     CHECK(!layer);
3237   } else {
3238     widget_base_->LayerTreeHost()->SetRootLayer(std::move(layer));
3239   }
3240
3241   // Notify the WebView that we did set a layer.
3242   if (ForMainFrame()) {
3243     View()->DidChangeRootLayer(root_layer_exists);
3244   }
3245 }
3246
3247 base::WeakPtr<AnimationWorkletMutatorDispatcherImpl>
3248 WebFrameWidgetImpl::EnsureCompositorMutatorDispatcher(
3249     scoped_refptr<base::SingleThreadTaskRunner> mutator_task_runner) {
3250   if (!mutator_task_runner_) {
3251     mutator_task_runner_ = std::move(mutator_task_runner);
3252     widget_base_->LayerTreeHost()->SetLayerTreeMutator(
3253         AnimationWorkletMutatorDispatcherImpl::CreateCompositorThreadClient(
3254             mutator_dispatcher_, mutator_task_runner_));
3255   }
3256
3257   DCHECK(mutator_task_runner_);
3258   return mutator_dispatcher_;
3259 }
3260
3261 HitTestResult WebFrameWidgetImpl::CoreHitTestResultAt(
3262     const gfx::PointF& point_in_viewport) {
3263   LocalFrameView* view = LocalRootImpl()->GetFrameView();
3264   gfx::PointF point_in_root_frame(view->ViewportToFrame(point_in_viewport));
3265   return HitTestResultForRootFramePos(point_in_root_frame);
3266 }
3267
3268 cc::AnimationHost* WebFrameWidgetImpl::AnimationHost() const {
3269   return widget_base_->AnimationHost();
3270 }
3271
3272 cc::AnimationTimeline* WebFrameWidgetImpl::ScrollAnimationTimeline() const {
3273   return widget_base_->ScrollAnimationTimeline();
3274 }
3275
3276 base::WeakPtr<PaintWorkletPaintDispatcher>
3277 WebFrameWidgetImpl::EnsureCompositorPaintDispatcher(
3278     scoped_refptr<base::SingleThreadTaskRunner>* paint_task_runner) {
3279   // We check paint_task_runner_ not paint_dispatcher_ because the dispatcher is
3280   // a base::WeakPtr that should only be used on the compositor thread.
3281   if (!paint_task_runner_) {
3282     widget_base_->LayerTreeHost()->SetPaintWorkletLayerPainter(
3283         PaintWorkletPaintDispatcher::CreateCompositorThreadPainter(
3284             &paint_dispatcher_));
3285     paint_task_runner_ = Thread::CompositorThread()->GetTaskRunner();
3286   }
3287   DCHECK(paint_task_runner_);
3288   *paint_task_runner = paint_task_runner_;
3289   return paint_dispatcher_;
3290 }
3291
3292 void WebFrameWidgetImpl::SetDelegatedInkMetadata(
3293     std::unique_ptr<gfx::DelegatedInkMetadata> metadata) {
3294   widget_base_->LayerTreeHost()->SetDelegatedInkMetadata(std::move(metadata));
3295 }
3296
3297 // Enables measuring and reporting both presentation times and swap times in
3298 // swap promises.
3299 class ReportTimeSwapPromise : public cc::SwapPromise {
3300  public:
3301   ReportTimeSwapPromise(WebFrameWidgetImpl::PromiseCallbacks callbacks,
3302                         scoped_refptr<base::SingleThreadTaskRunner> task_runner,
3303                         WebFrameWidgetImpl* widget)
3304       : promise_callbacks_(std::move(callbacks)),
3305         task_runner_(std::move(task_runner)),
3306         widget_(MakeCrossThreadWeakHandle(widget)) {}
3307
3308   ReportTimeSwapPromise(const ReportTimeSwapPromise&) = delete;
3309   ReportTimeSwapPromise& operator=(const ReportTimeSwapPromise&) = delete;
3310
3311   ~ReportTimeSwapPromise() override = default;
3312
3313   void DidActivate() override {}
3314
3315   void WillSwap(viz::CompositorFrameMetadata* metadata) override {
3316     DCHECK_GT(metadata->frame_token, 0u);
3317     // The interval between the current swap and its presentation time is
3318     // reported in UMA (see corresponding code in DidSwap() below).
3319     frame_token_ = metadata->frame_token;
3320   }
3321
3322   void DidSwap() override {
3323     DCHECK_GT(frame_token_, 0u);
3324     PostCrossThreadTask(
3325         *task_runner_, FROM_HERE,
3326         CrossThreadBindOnce(&RunCallbackAfterSwap,
3327                             MakeUnwrappingCrossThreadWeakHandle(widget_),
3328                             base::TimeTicks::Now(),
3329                             std::move(promise_callbacks_), frame_token_));
3330   }
3331
3332   DidNotSwapAction DidNotSwap(DidNotSwapReason reason,
3333                               base::TimeTicks timestamp) override {
3334     if (reason != DidNotSwapReason::SWAP_FAILS &&
3335         reason != DidNotSwapReason::COMMIT_NO_UPDATE) {
3336       return DidNotSwapAction::KEEP_ACTIVE;
3337     }
3338
3339     DidNotSwapAction action = DidNotSwapAction::BREAK_PROMISE;
3340     WebFrameWidgetImpl::PromiseCallbacks promise_callbacks_on_failure = {
3341         .swap_time_callback = std::move(promise_callbacks_.swap_time_callback),
3342         .presentation_time_callback =
3343             std::move(promise_callbacks_.presentation_time_callback)};
3344
3345 #if BUILDFLAG(IS_APPLE)
3346     if (reason == DidNotSwapReason::COMMIT_FAILS &&
3347         promise_callbacks_.core_animation_error_code_callback) {
3348       action = DidNotSwapAction::KEEP_ACTIVE;
3349     } else {
3350       promise_callbacks_on_failure.core_animation_error_code_callback =
3351           std::move(promise_callbacks_.core_animation_error_code_callback);
3352     }
3353 #endif
3354
3355     if (!promise_callbacks_on_failure.IsEmpty()) {
3356       ReportSwapAndPresentationFailureOnTaskRunner(
3357           task_runner_, std::move(promise_callbacks_on_failure), timestamp);
3358     }
3359     return action;
3360   }
3361
3362   int64_t GetTraceId() const override { return 0; }
3363
3364  private:
3365   static void RunCallbackAfterSwap(
3366       WebFrameWidgetImpl* widget,
3367       base::TimeTicks swap_time,
3368       WebFrameWidgetImpl::PromiseCallbacks callbacks,
3369       int frame_token) {
3370     // If the widget was collected or the widget wasn't collected yet, but
3371     // it was closed don't schedule a presentation callback.
3372     if (widget && widget->widget_base_) {
3373       widget->widget_base_->AddPresentationCallback(
3374           frame_token,
3375           WTF::BindOnce(&RunCallbackAfterPresentation,
3376                         std::move(callbacks.presentation_time_callback),
3377                         swap_time));
3378       ReportTime(std::move(callbacks.swap_time_callback), swap_time);
3379
3380 #if BUILDFLAG(IS_APPLE)
3381       if (callbacks.core_animation_error_code_callback) {
3382         widget->widget_base_->AddCoreAnimationErrorCodeCallback(
3383             frame_token,
3384             std::move(callbacks.core_animation_error_code_callback));
3385       }
3386 #endif
3387     } else {
3388       ReportTime(std::move(callbacks.swap_time_callback), swap_time);
3389       ReportTime(std::move(callbacks.presentation_time_callback), swap_time);
3390 #if BUILDFLAG(IS_APPLE)
3391       ReportErrorCode(std::move(callbacks.core_animation_error_code_callback),
3392                       gfx::kCALayerUnknownNoWidget);
3393 #endif
3394     }
3395   }
3396
3397   static void RunCallbackAfterPresentation(
3398       base::OnceCallback<void(base::TimeTicks)> presentation_time_callback,
3399       base::TimeTicks swap_time,
3400       base::TimeTicks presentation_time) {
3401     DCHECK(!swap_time.is_null());
3402     bool presentation_time_is_valid =
3403         !presentation_time.is_null() && (presentation_time > swap_time);
3404     UMA_HISTOGRAM_BOOLEAN("PageLoad.Internal.Renderer.PresentationTime.Valid",
3405                           presentation_time_is_valid);
3406     ReportTime(std::move(presentation_time_callback),
3407                presentation_time_is_valid ? presentation_time : swap_time);
3408   }
3409
3410   static void ReportTime(base::OnceCallback<void(base::TimeTicks)> callback,
3411                          base::TimeTicks time) {
3412     if (callback)
3413       std::move(callback).Run(time);
3414   }
3415
3416 #if BUILDFLAG(IS_APPLE)
3417   static void ReportErrorCode(
3418       base::OnceCallback<void(gfx::CALayerResult)> callback,
3419       gfx::CALayerResult error_code) {
3420     if (callback)
3421       std::move(callback).Run(error_code);
3422   }
3423 #endif
3424
3425   static void ReportSwapAndPresentationFailureOnTaskRunner(
3426       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
3427       WebFrameWidgetImpl::PromiseCallbacks callbacks,
3428       base::TimeTicks failure_time) {
3429     if (!task_runner->BelongsToCurrentThread()) {
3430       PostCrossThreadTask(
3431           *task_runner, FROM_HERE,
3432           CrossThreadBindOnce(&ReportSwapAndPresentationFailureOnTaskRunner,
3433                               task_runner, std::move(callbacks), failure_time));
3434       return;
3435     }
3436
3437     ReportTime(std::move(callbacks.swap_time_callback), failure_time);
3438     ReportTime(std::move(callbacks.presentation_time_callback), failure_time);
3439 #if BUILDFLAG(IS_APPLE)
3440     ReportErrorCode(std::move(callbacks.core_animation_error_code_callback),
3441                     gfx::kCALayerUnknownDidNotSwap);
3442 #endif
3443   }
3444
3445   WebFrameWidgetImpl::PromiseCallbacks promise_callbacks_;
3446
3447   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
3448   CrossThreadWeakHandle<WebFrameWidgetImpl> widget_;
3449   uint32_t frame_token_ = 0;
3450 };
3451
3452 void WebFrameWidgetImpl::NotifySwapAndPresentationTimeForTesting(
3453     PromiseCallbacks callbacks) {
3454   NotifySwapAndPresentationTime(std::move(callbacks));
3455 }
3456
3457 void WebFrameWidgetImpl::NotifyPresentationTimeInBlink(
3458     base::OnceCallback<void(base::TimeTicks)> presentation_callback) {
3459   NotifySwapAndPresentationTime(
3460       {.presentation_time_callback = std::move(presentation_callback)});
3461 }
3462
3463 void WebFrameWidgetImpl::NotifyPresentationTime(
3464     base::OnceCallback<void(base::TimeTicks)> presentation_callback) {
3465   NotifySwapAndPresentationTime(
3466       {.presentation_time_callback = std::move(presentation_callback)});
3467 }
3468
3469 #if BUILDFLAG(IS_APPLE)
3470 void WebFrameWidgetImpl::NotifyCoreAnimationErrorCode(
3471     base::OnceCallback<void(gfx::CALayerResult)>
3472         core_animation_error_code_callback) {
3473   NotifySwapAndPresentationTime(
3474       {.core_animation_error_code_callback =
3475            std::move(core_animation_error_code_callback)});
3476 }
3477 #endif
3478
3479 void WebFrameWidgetImpl::NotifySwapAndPresentationTime(
3480     PromiseCallbacks callbacks) {
3481   if (!View()->does_composite())
3482     return;
3483
3484   widget_base_->LayerTreeHost()->QueueSwapPromise(
3485       std::make_unique<ReportTimeSwapPromise>(std::move(callbacks),
3486                                               widget_base_->LayerTreeHost()
3487                                                   ->GetTaskRunnerProvider()
3488                                                   ->MainThreadTaskRunner(),
3489                                               this));
3490 }
3491
3492 void WebFrameWidgetImpl::WaitForDebuggerWhenShown() {
3493   local_root_->WaitForDebuggerWhenShown();
3494 }
3495
3496 void WebFrameWidgetImpl::SetTextZoomFactor(float text_zoom_factor) {
3497   local_root_->GetFrame()->SetTextZoomFactor(text_zoom_factor);
3498 }
3499
3500 float WebFrameWidgetImpl::TextZoomFactor() {
3501   return local_root_->GetFrame()->TextZoomFactor();
3502 }
3503
3504 void WebFrameWidgetImpl::SetMainFrameOverlayColor(SkColor color) {
3505   DCHECK(!local_root_->Parent());
3506   local_root_->GetFrame()->SetMainFrameColorOverlay(color);
3507 }
3508
3509 void WebFrameWidgetImpl::AddEditCommandForNextKeyEvent(const WebString& name,
3510                                                        const WebString& value) {
3511   edit_commands_.push_back(mojom::blink::EditCommand::New(name, value));
3512 }
3513
3514 bool WebFrameWidgetImpl::HandleCurrentKeyboardEvent() {
3515   if (edit_commands_.empty()) {
3516     return false;
3517   }
3518   WebLocalFrame* frame = FocusedWebLocalFrameInWidget();
3519   if (!frame)
3520     frame = local_root_;
3521   bool did_execute_command = false;
3522   // Executing an edit command can run JS and we can end up reassigning
3523   // `edit_commands_` so move it to a stack variable before iterating on it.
3524   Vector<mojom::blink::EditCommandPtr> edit_commands =
3525       std::move(edit_commands_);
3526   for (const auto& command : edit_commands) {
3527     // In gtk and cocoa, it's possible to bind multiple edit commands to one
3528     // key (but it's the exception). Once one edit command is not executed, it
3529     // seems safest to not execute the rest.
3530     if (!frame->ExecuteCommand(command->name, command->value))
3531       break;
3532     did_execute_command = true;
3533   }
3534
3535   return did_execute_command;
3536 }
3537
3538 void WebFrameWidgetImpl::ClearEditCommands() {
3539   edit_commands_ = Vector<mojom::blink::EditCommandPtr>();
3540 }
3541
3542 WebTextInputInfo WebFrameWidgetImpl::TextInputInfo() {
3543   WebInputMethodController* controller = GetActiveWebInputMethodController();
3544   if (!controller)
3545     return WebTextInputInfo();
3546   return controller->TextInputInfo();
3547 }
3548
3549 ui::mojom::blink::VirtualKeyboardVisibilityRequest
3550 WebFrameWidgetImpl::GetLastVirtualKeyboardVisibilityRequest() {
3551   WebInputMethodController* controller = GetActiveWebInputMethodController();
3552   if (!controller)
3553     return ui::mojom::blink::VirtualKeyboardVisibilityRequest::NONE;
3554   return controller->GetLastVirtualKeyboardVisibilityRequest();
3555 }
3556
3557 bool WebFrameWidgetImpl::ShouldSuppressKeyboardForFocusedElement() {
3558   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
3559   if (!focused_frame)
3560     return false;
3561   return focused_frame->ShouldSuppressKeyboardForFocusedElement();
3562 }
3563
3564 void WebFrameWidgetImpl::GetEditContextBoundsInWindow(
3565     absl::optional<gfx::Rect>* edit_context_control_bounds,
3566     absl::optional<gfx::Rect>* edit_context_selection_bounds) {
3567   WebInputMethodController* controller = GetActiveWebInputMethodController();
3568   if (!controller)
3569     return;
3570   gfx::Rect control_bounds;
3571   gfx::Rect selection_bounds;
3572   controller->GetLayoutBounds(&control_bounds, &selection_bounds);
3573   *edit_context_control_bounds =
3574       widget_base_->BlinkSpaceToEnclosedDIPs(control_bounds);
3575   if (controller->IsEditContextActive()) {
3576     *edit_context_selection_bounds =
3577         widget_base_->BlinkSpaceToEnclosedDIPs(selection_bounds);
3578   }
3579 }
3580
3581 int32_t WebFrameWidgetImpl::ComputeWebTextInputNextPreviousFlags() {
3582   WebInputMethodController* controller = GetActiveWebInputMethodController();
3583   if (!controller)
3584     return 0;
3585   return controller->ComputeWebTextInputNextPreviousFlags();
3586 }
3587
3588 void WebFrameWidgetImpl::ResetVirtualKeyboardVisibilityRequest() {
3589   WebInputMethodController* controller = GetActiveWebInputMethodController();
3590   if (!controller)
3591     return;
3592   controller->SetVirtualKeyboardVisibilityRequest(
3593       ui::mojom::blink::VirtualKeyboardVisibilityRequest::NONE);
3594   ;
3595 }
3596
3597 bool WebFrameWidgetImpl::GetSelectionBoundsInWindow(
3598     gfx::Rect* focus,
3599     gfx::Rect* anchor,
3600     gfx::Rect* bounding_box,
3601     base::i18n::TextDirection* focus_dir,
3602     base::i18n::TextDirection* anchor_dir,
3603     bool* is_anchor_first) {
3604   if (ShouldDispatchImeEventsToPlugin()) {
3605     // TODO(kinaba) http://crbug.com/101101
3606     // Current Pepper IME API does not handle selection bounds. So we simply
3607     // use the caret position as an empty range for now. It will be updated
3608     // after Pepper API equips features related to surrounding text retrieval.
3609     gfx::Rect pepper_caret_in_dips = widget_base_->BlinkSpaceToEnclosedDIPs(
3610         GetFocusedPluginContainer()->GetPluginCaretBounds());
3611     if (pepper_caret_in_dips == *focus && pepper_caret_in_dips == *anchor)
3612       return false;
3613     *focus = pepper_caret_in_dips;
3614     *anchor = *focus;
3615     return true;
3616   }
3617   gfx::Rect focus_root_frame;
3618   gfx::Rect anchor_root_frame;
3619   gfx::Rect bounding_box_root_frame;
3620   CalculateSelectionBounds(focus_root_frame, anchor_root_frame,
3621                            &bounding_box_root_frame);
3622   gfx::Rect focus_rect_in_dips =
3623       widget_base_->BlinkSpaceToEnclosedDIPs(gfx::Rect(focus_root_frame));
3624   gfx::Rect anchor_rect_in_dips =
3625       widget_base_->BlinkSpaceToEnclosedDIPs(gfx::Rect(anchor_root_frame));
3626   gfx::Rect bounding_box_in_dips = widget_base_->BlinkSpaceToEnclosedDIPs(
3627       gfx::Rect(bounding_box_root_frame));
3628
3629   // if the bounds are the same return false.
3630   if (focus_rect_in_dips == *focus && anchor_rect_in_dips == *anchor)
3631     return false;
3632   *focus = focus_rect_in_dips;
3633   *anchor = anchor_rect_in_dips;
3634   *bounding_box = bounding_box_in_dips;
3635
3636   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
3637   if (!focused_frame)
3638     return true;
3639   focused_frame->SelectionTextDirection(*focus_dir, *anchor_dir);
3640   *is_anchor_first = focused_frame->IsSelectionAnchorFirst();
3641   return true;
3642 }
3643
3644 void WebFrameWidgetImpl::ClearTextInputState() {
3645   widget_base_->ClearTextInputState();
3646 }
3647
3648 bool WebFrameWidgetImpl::IsPasting() {
3649   return widget_base_->is_pasting();
3650 }
3651
3652 bool WebFrameWidgetImpl::HandlingSelectRange() {
3653   return widget_base_->handling_select_range();
3654 }
3655
3656 void WebFrameWidgetImpl::SetFocus(bool focus) {
3657   widget_base_->SetFocus(
3658       focus ? mojom::blink::FocusState::kFocused
3659             : View()->IsActive()
3660                   ? mojom::blink::FocusState::kNotFocusedAndActive
3661                   : mojom::blink::FocusState::kNotFocusedAndNotActive);
3662 }
3663
3664 bool WebFrameWidgetImpl::HasFocus() {
3665   return widget_base_->has_focus();
3666 }
3667
3668 void WebFrameWidgetImpl::UpdateTooltipUnderCursor(const String& tooltip_text,
3669                                                   TextDirection dir) {
3670   widget_base_->UpdateTooltipUnderCursor(tooltip_text, dir);
3671 }
3672
3673 void WebFrameWidgetImpl::UpdateTooltipFromKeyboard(const String& tooltip_text,
3674                                                    TextDirection dir,
3675                                                    const gfx::Rect& bounds) {
3676   widget_base_->UpdateTooltipFromKeyboard(tooltip_text, dir, bounds);
3677 }
3678
3679 void WebFrameWidgetImpl::ClearKeyboardTriggeredTooltip() {
3680   widget_base_->ClearKeyboardTriggeredTooltip();
3681 }
3682
3683 void WebFrameWidgetImpl::DidOverscroll(
3684     const gfx::Vector2dF& overscroll_delta,
3685     const gfx::Vector2dF& accumulated_overscroll,
3686     const gfx::PointF& position,
3687     const gfx::Vector2dF& velocity) {
3688 #if BUILDFLAG(IS_MAC)
3689   // On OSX the user can disable the elastic overscroll effect. If that's the
3690   // case, don't forward the overscroll notification.
3691   if (!widget_base_->LayerTreeHost()->GetSettings().enable_elastic_overscroll)
3692     return;
3693 #endif
3694
3695   cc::OverscrollBehavior overscroll_behavior =
3696       widget_base_->LayerTreeHost()->overscroll_behavior();
3697   if (!widget_base_->input_handler().DidOverscrollFromBlink(
3698           overscroll_delta, accumulated_overscroll, position, velocity,
3699           overscroll_behavior))
3700     return;
3701
3702   // If we're currently handling an event, stash the overscroll data such that
3703   // it can be bundled in the event ack.
3704   if (mojom::blink::WidgetInputHandlerHost* host =
3705           widget_base_->widget_input_handler_manager()
3706               ->GetWidgetInputHandlerHost()) {
3707     host->DidOverscroll(mojom::blink::DidOverscrollParams::New(
3708         accumulated_overscroll, overscroll_delta, velocity, position,
3709         overscroll_behavior));
3710   }
3711 }
3712
3713 void WebFrameWidgetImpl::InjectScrollbarGestureScroll(
3714     const gfx::Vector2dF& delta,
3715     ui::ScrollGranularity granularity,
3716     cc::ElementId scrollable_area_element_id,
3717     blink::WebInputEvent::Type injected_type) {
3718   // create a GestureScroll Event and post it to the compositor thread
3719   // TODO(crbug.com/1126098) use original input event's timestamp.
3720   // TODO(crbug.com/1082590) ensure continuity in scroll metrics collection
3721   base::TimeTicks now = base::TimeTicks::Now();
3722   std::unique_ptr<WebGestureEvent> gesture_event =
3723       WebGestureEvent::GenerateInjectedScrollbarGestureScroll(
3724           injected_type, now, gfx::PointF(0, 0), delta, granularity);
3725   if (injected_type == WebInputEvent::Type::kGestureScrollBegin) {
3726     gesture_event->data.scroll_begin.scrollable_area_element_id =
3727         scrollable_area_element_id.GetInternalValue();
3728     gesture_event->data.scroll_begin.main_thread_hit_tested_reasons =
3729         cc::MainThreadScrollingReason::kScrollbarScrolling;
3730   }
3731
3732   // Notifies TestWebFrameWidget of the injected event. Does nothing outside
3733   // of unit tests. This would happen in WidgetBase::QueueSyntheticEvent if
3734   // scroll unification were not enabled.
3735   WillQueueSyntheticEvent(
3736       WebCoalescedInputEvent(*gesture_event, ui::LatencyInfo()));
3737
3738   widget_base_->widget_input_handler_manager()
3739       ->DispatchScrollGestureToCompositor(std::move(gesture_event));
3740 }
3741
3742 void WebFrameWidgetImpl::DidChangeCursor(const ui::Cursor& cursor) {
3743   widget_base_->SetCursor(cursor);
3744 }
3745
3746 bool WebFrameWidgetImpl::SetComposition(
3747     const String& text,
3748     const Vector<ui::ImeTextSpan>& ime_text_spans,
3749     const gfx::Range& replacement_range,
3750     int selection_start,
3751     int selection_end) {
3752   WebInputMethodController* controller = GetActiveWebInputMethodController();
3753   if (!controller)
3754     return false;
3755
3756   return controller->SetComposition(
3757       text, ime_text_spans,
3758       replacement_range.IsValid()
3759           ? WebRange(base::checked_cast<int>(replacement_range.start()),
3760                      base::checked_cast<int>(replacement_range.length()))
3761           : WebRange(),
3762       selection_start, selection_end);
3763 }
3764
3765 void WebFrameWidgetImpl::CommitText(
3766     const String& text,
3767     const Vector<ui::ImeTextSpan>& ime_text_spans,
3768     const gfx::Range& replacement_range,
3769     int relative_cursor_pos) {
3770   WebInputMethodController* controller = GetActiveWebInputMethodController();
3771   if (!controller)
3772     return;
3773   controller->CommitText(
3774       text, ime_text_spans,
3775       replacement_range.IsValid()
3776           ? WebRange(base::checked_cast<int>(replacement_range.start()),
3777                      base::checked_cast<int>(replacement_range.length()))
3778           : WebRange(),
3779       relative_cursor_pos);
3780 }
3781
3782 void WebFrameWidgetImpl::FinishComposingText(bool keep_selection) {
3783   WebInputMethodController* controller = GetActiveWebInputMethodController();
3784   if (!controller)
3785     return;
3786   controller->FinishComposingText(
3787       keep_selection ? WebInputMethodController::kKeepSelection
3788                      : WebInputMethodController::kDoNotKeepSelection);
3789 }
3790
3791 bool WebFrameWidgetImpl::IsProvisional() {
3792   return LocalRoot()->IsProvisional();
3793 }
3794
3795 cc::ElementId WebFrameWidgetImpl::GetScrollableContainerIdAt(
3796     const gfx::PointF& point) {
3797   gfx::PointF hit_test_point = point;
3798   LocalFrameView* view = LocalRootImpl()->GetFrameView();
3799   hit_test_point.Scale(1 / view->InputEventsScaleFactor());
3800   return HitTestResultForRootFramePos(hit_test_point).GetScrollableContainer();
3801 }
3802
3803 bool WebFrameWidgetImpl::ShouldHandleImeEvents() {
3804   if (ForMainFrame()) {
3805     return HasFocus();
3806   } else {
3807     // TODO(ekaramad): main frame widget returns true only if it has focus.
3808     // We track page focus in all WebViews on the page but the WebFrameWidgets
3809     // corresponding to child local roots do not get the update. For now, this
3810     // method returns true when the WebFrameWidget is for a child local frame,
3811     // i.e., IME events will be processed regardless of page focus. We should
3812     // revisit this after page focus for OOPIFs has been fully resolved
3813     // (https://crbug.com/689777).
3814     return LocalRootImpl();
3815   }
3816 }
3817
3818 void WebFrameWidgetImpl::SetEditCommandsForNextKeyEvent(
3819     Vector<mojom::blink::EditCommandPtr> edit_commands) {
3820   edit_commands_ = std::move(edit_commands);
3821 }
3822
3823 void WebFrameWidgetImpl::FocusChangeComplete() {
3824   blink::WebLocalFrame* focused = LocalRoot()->View()->FocusedFrame();
3825
3826   if (focused && focused->AutofillClient())
3827     focused->AutofillClient()->DidCompleteFocusChangeInFrame();
3828 }
3829
3830 void WebFrameWidgetImpl::ShowVirtualKeyboardOnElementFocus() {
3831   widget_base_->ShowVirtualKeyboardOnElementFocus();
3832 }
3833
3834 #if BUILDFLAG(IS_EFL)
3835 void WebFrameWidgetImpl::DidUpdateTextOfFocusedElementByNonUserInput() {
3836   widget_base_->DidUpdateTextOfFocusedElementByNonUserInput();
3837 }
3838 #endif
3839 void WebFrameWidgetImpl::ProcessTouchAction(WebTouchAction touch_action) {
3840   widget_base_->ProcessTouchAction(touch_action);
3841 }
3842
3843 void WebFrameWidgetImpl::SetPanAction(mojom::blink::PanAction pan_action) {
3844   if (!widget_base_->widget_input_handler_manager())
3845     return;
3846   mojom::blink::WidgetInputHandlerHost* host =
3847       widget_base_->widget_input_handler_manager()->GetWidgetInputHandlerHost();
3848   if (!host)
3849     return;
3850   host->SetPanAction(pan_action);
3851 }
3852
3853 void WebFrameWidgetImpl::DidHandleGestureEvent(const WebGestureEvent& event) {
3854 #if BUILDFLAG(IS_ANDROID) || defined(USE_AURA) || BUILDFLAG(IS_IOS)
3855   if (event.GetType() == WebInputEvent::Type::kGestureTap) {
3856     widget_base_->ShowVirtualKeyboard();
3857   } else if (event.GetType() == WebInputEvent::Type::kGestureLongPress) {
3858     WebInputMethodController* controller = GetActiveWebInputMethodController();
3859     if (!controller || controller->TextInputInfo().value.IsEmpty())
3860       widget_base_->UpdateTextInputState();
3861     else
3862       widget_base_->ShowVirtualKeyboard();
3863   }
3864 #elif BUILDFLAG(IS_EFL)
3865   if (!HasFocus())
3866     return;
3867
3868   if ((event.GetType() == WebInputEvent::Type::kGestureTap) ||
3869       (event.GetType() == WebInputEvent::Type::kGestureLongPress)) {
3870     widget_base_->ShowVirtualKeyboard();
3871   }
3872 #endif
3873 }
3874
3875 void WebFrameWidgetImpl::SetHasPointerRawUpdateEventHandlers(
3876     bool has_handlers) {
3877   widget_base_->widget_input_handler_manager()
3878       ->input_event_queue()
3879       ->HasPointerRawUpdateEventHandlers(has_handlers);
3880 }
3881
3882 void WebFrameWidgetImpl::SetNeedsLowLatencyInput(bool needs_low_latency) {
3883   widget_base_->widget_input_handler_manager()
3884       ->input_event_queue()
3885       ->SetNeedsLowLatency(needs_low_latency);
3886 }
3887
3888 void WebFrameWidgetImpl::RequestUnbufferedInputEvents() {
3889   widget_base_->widget_input_handler_manager()
3890       ->input_event_queue()
3891       ->RequestUnbufferedInputEvents();
3892 }
3893
3894 void WebFrameWidgetImpl::SetNeedsUnbufferedInputForDebugger(bool unbuffered) {
3895   widget_base_->widget_input_handler_manager()
3896       ->input_event_queue()
3897       ->SetNeedsUnbufferedInputForDebugger(unbuffered);
3898 }
3899
3900 void WebFrameWidgetImpl::DidNavigate() {
3901   // The input handler wants to know about navigation so that it can
3902   // suppress input until the newly navigated page has a committed frame.
3903   // It also resets the state for UMA reporting of input arrival with respect
3904   // to document lifecycle.
3905   if (!widget_base_->widget_input_handler_manager())
3906     return;
3907   widget_base_->widget_input_handler_manager()->DidNavigate();
3908 }
3909
3910 void WebFrameWidgetImpl::FlushInputForTesting(base::OnceClosure done_callback) {
3911   widget_base_->widget_input_handler_manager()->FlushEventQueuesForTesting(
3912       std::move(done_callback));
3913 }
3914
3915 void WebFrameWidgetImpl::SetMouseCapture(bool capture) {
3916   if (mojom::blink::WidgetInputHandlerHost* host =
3917           widget_base_->widget_input_handler_manager()
3918               ->GetWidgetInputHandlerHost()) {
3919     host->SetMouseCapture(capture);
3920   }
3921 }
3922
3923 gfx::Range WebFrameWidgetImpl::CompositionRange() {
3924   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
3925   if (!focused_frame || ShouldDispatchImeEventsToPlugin())
3926     return gfx::Range::InvalidRange();
3927
3928   blink::WebInputMethodController* controller =
3929       focused_frame->GetInputMethodController();
3930   WebRange web_range = controller->CompositionRange();
3931   if (web_range.IsNull())
3932     return gfx::Range::InvalidRange();
3933   return gfx::Range(web_range.StartOffset(), web_range.EndOffset());
3934 }
3935
3936 void WebFrameWidgetImpl::GetCompositionCharacterBoundsInWindow(
3937     Vector<gfx::Rect>* bounds_in_dips) {
3938   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
3939   if (!focused_frame || ShouldDispatchImeEventsToPlugin())
3940     return;
3941   blink::WebInputMethodController* controller =
3942       focused_frame->GetInputMethodController();
3943   blink::WebVector<gfx::Rect> bounds_from_blink;
3944   if (!controller->GetCompositionCharacterBounds(bounds_from_blink))
3945     return;
3946
3947   for (auto& rect : bounds_from_blink) {
3948     bounds_in_dips->push_back(widget_base_->BlinkSpaceToEnclosedDIPs(rect));
3949   }
3950 }
3951
3952 namespace {
3953
3954 void GetLineBounds(Vector<gfx::QuadF>& line_quads,
3955                    TextControlInnerEditorElement* inner_editor) {
3956   for (const Node& node : NodeTraversal::DescendantsOf(*inner_editor)) {
3957     if (!node.GetLayoutObject() || !node.GetLayoutObject()->IsText()) {
3958       continue;
3959     }
3960     node.GetLayoutObject()->AbsoluteQuads(line_quads,
3961                                           kApplyRemoteMainFrameTransform);
3962   }
3963 }
3964
3965 }  // namespace
3966
3967 Vector<gfx::Rect> WebFrameWidgetImpl::CalculateVisibleLineBoundsOnScreen() {
3968   Vector<gfx::Rect> bounds_in_dips;
3969   Element* focused_element = FocusedElement();
3970   if (!focused_element) {
3971     return bounds_in_dips;
3972   }
3973   TextControlElement* text_control = ToTextControlOrNull(focused_element);
3974   if (!text_control || text_control->IsDisabledOrReadOnly() ||
3975       text_control->Value().empty() || !text_control->GetLayoutObject()) {
3976     return bounds_in_dips;
3977   }
3978
3979   Vector<gfx::QuadF> bounds_from_blink;
3980   GetLineBounds(bounds_from_blink, text_control->InnerEditorElement());
3981
3982   gfx::Rect screen = GetPage()->GetVisualViewport().VisibleContentRect();
3983   for (auto& quad : bounds_from_blink) {
3984     gfx::Rect bounding_box = gfx::ToRoundedRect(quad.BoundingBox());
3985     bounding_box.Intersect(screen);
3986     if (bounding_box.IsEmpty()) {
3987       continue;
3988     }
3989
3990     bounds_in_dips.push_back(
3991         focused_element->GetLayoutObject()->GetFrameView()->FrameToScreen(
3992             bounding_box));
3993   }
3994   return bounds_in_dips;
3995 }
3996
3997 Vector<gfx::Rect>& WebFrameWidgetImpl::GetVisibleLineBoundsOnScreen() {
3998   return input_visible_line_bounds_;
3999 }
4000
4001 void WebFrameWidgetImpl::UpdateLineBounds() {
4002   Vector<gfx::Rect> line_bounds = CalculateVisibleLineBoundsOnScreen();
4003   if (line_bounds == input_visible_line_bounds_) {
4004     return;
4005   }
4006   input_visible_line_bounds_.swap(line_bounds);
4007   if (mojom::blink::WidgetInputHandlerHost* host =
4008           widget_base_->widget_input_handler_manager()
4009               ->GetWidgetInputHandlerHost()) {
4010     host->ImeCompositionRangeChanged(gfx::Range::InvalidRange(), absl::nullopt,
4011                                      input_visible_line_bounds_);
4012   }
4013 }
4014
4015 void WebFrameWidgetImpl::AddImeTextSpansToExistingText(
4016     uint32_t start,
4017     uint32_t end,
4018     const Vector<ui::ImeTextSpan>& ime_text_spans) {
4019   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4020   if (!focused_frame)
4021     return;
4022   focused_frame->AddImeTextSpansToExistingText(ime_text_spans, start, end);
4023 }
4024
4025 Vector<ui::mojom::blink::ImeTextSpanInfoPtr>
4026 WebFrameWidgetImpl::GetImeTextSpansInfo(
4027     const WebVector<ui::ImeTextSpan>& ime_text_spans) {
4028   auto* focused_frame = FocusedWebLocalFrameInWidget();
4029   if (!focused_frame)
4030     return Vector<ui::mojom::blink::ImeTextSpanInfoPtr>();
4031
4032   Vector<ui::mojom::blink::ImeTextSpanInfoPtr> ime_text_spans_info;
4033
4034   for (const auto& ime_text_span : ime_text_spans) {
4035     gfx::Rect rect;
4036     auto length = base::checked_cast<wtf_size_t>(ime_text_span.end_offset -
4037                                                  ime_text_span.start_offset);
4038     focused_frame->FirstRectForCharacterRange(
4039         base::checked_cast<wtf_size_t>(ime_text_span.start_offset), length,
4040         rect);
4041
4042     ime_text_spans_info.push_back(ui::mojom::blink::ImeTextSpanInfo::New(
4043         ime_text_span, widget_base_->BlinkSpaceToEnclosedDIPs(rect)));
4044   }
4045   return ime_text_spans_info;
4046 }
4047
4048 void WebFrameWidgetImpl::ClearImeTextSpansByType(uint32_t start,
4049                                                  uint32_t end,
4050                                                  ui::ImeTextSpan::Type type) {
4051   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4052   if (!focused_frame)
4053     return;
4054   focused_frame->ClearImeTextSpansByType(type, start, end);
4055 }
4056
4057 void WebFrameWidgetImpl::SetCompositionFromExistingText(
4058     int32_t start,
4059     int32_t end,
4060     const Vector<ui::ImeTextSpan>& ime_text_spans) {
4061   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4062   if (!focused_frame)
4063     return;
4064   focused_frame->SetCompositionFromExistingText(start, end, ime_text_spans);
4065 }
4066
4067 void WebFrameWidgetImpl::ExtendSelectionAndDelete(int32_t before,
4068                                                   int32_t after) {
4069   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4070   if (!focused_frame)
4071     return;
4072   focused_frame->ExtendSelectionAndDelete(before, after);
4073 }
4074
4075 void WebFrameWidgetImpl::ExtendSelectionAndReplace(
4076     uint32_t before,
4077     uint32_t after,
4078     const String& replacement_text) {
4079   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4080   if (!focused_frame) {
4081     return;
4082   }
4083   focused_frame->ExtendSelectionAndReplace(base::checked_cast<int>(before),
4084                                            base::checked_cast<int>(after),
4085                                            replacement_text);
4086 }
4087
4088 void WebFrameWidgetImpl::DeleteSurroundingText(int32_t before, int32_t after) {
4089   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4090   if (!focused_frame)
4091     return;
4092   focused_frame->DeleteSurroundingText(before, after);
4093 }
4094
4095 void WebFrameWidgetImpl::DeleteSurroundingTextInCodePoints(int32_t before,
4096                                                            int32_t after) {
4097   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4098   if (!focused_frame)
4099     return;
4100   focused_frame->DeleteSurroundingTextInCodePoints(before, after);
4101 }
4102
4103 void WebFrameWidgetImpl::SetEditableSelectionOffsets(int32_t start,
4104                                                      int32_t end) {
4105   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4106   if (!focused_frame)
4107     return;
4108   focused_frame->SetEditableSelectionOffsets(start, end);
4109 }
4110
4111 void WebFrameWidgetImpl::ExecuteEditCommand(const String& command,
4112                                             const String& value) {
4113   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4114   if (!focused_frame)
4115     return;
4116   focused_frame->ExecuteCommand(command, value);
4117 }
4118
4119 void WebFrameWidgetImpl::Undo() {
4120   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4121   if (!focused_frame)
4122     return;
4123   focused_frame->ExecuteCommand(WebString::FromLatin1("Undo"));
4124 }
4125
4126 void WebFrameWidgetImpl::Redo() {
4127   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4128   if (!focused_frame)
4129     return;
4130   focused_frame->ExecuteCommand(WebString::FromLatin1("Redo"));
4131 }
4132
4133 void WebFrameWidgetImpl::Cut() {
4134   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4135   if (!focused_frame)
4136     return;
4137   focused_frame->ExecuteCommand(WebString::FromLatin1("Cut"));
4138 }
4139
4140 void WebFrameWidgetImpl::Copy() {
4141   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4142   if (!focused_frame)
4143     return;
4144   focused_frame->ExecuteCommand(WebString::FromLatin1("Copy"));
4145 }
4146
4147 void WebFrameWidgetImpl::CopyToFindPboard() {
4148 #if BUILDFLAG(IS_MAC)
4149   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4150   if (!focused_frame)
4151     return;
4152   To<WebLocalFrameImpl>(focused_frame)->CopyToFindPboard();
4153 #endif
4154 }
4155
4156 void WebFrameWidgetImpl::CenterSelection() {
4157   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4158   if (!focused_frame) {
4159     return;
4160   }
4161   To<WebLocalFrameImpl>(focused_frame)->CenterSelection();
4162 }
4163
4164 void WebFrameWidgetImpl::Paste() {
4165   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4166   if (!focused_frame)
4167     return;
4168   focused_frame->ExecuteCommand(WebString::FromLatin1("Paste"));
4169 }
4170
4171 void WebFrameWidgetImpl::PasteAndMatchStyle() {
4172   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4173   if (!focused_frame)
4174     return;
4175   focused_frame->ExecuteCommand(WebString::FromLatin1("PasteAndMatchStyle"));
4176 }
4177
4178 void WebFrameWidgetImpl::Delete() {
4179   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4180   if (!focused_frame)
4181     return;
4182   focused_frame->ExecuteCommand(WebString::FromLatin1("Delete"));
4183 }
4184
4185 void WebFrameWidgetImpl::SelectAll() {
4186   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4187   if (!focused_frame)
4188     return;
4189   focused_frame->ExecuteCommand(WebString::FromLatin1("SelectAll"));
4190 }
4191
4192 void WebFrameWidgetImpl::CollapseSelection() {
4193   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4194   if (!focused_frame)
4195     return;
4196   const blink::WebRange& range =
4197       focused_frame->GetInputMethodController()->GetSelectionOffsets();
4198   if (range.IsNull())
4199     return;
4200
4201   focused_frame->SelectRange(blink::WebRange(range.EndOffset(), 0),
4202                              blink::WebLocalFrame::kHideSelectionHandle,
4203                              mojom::blink::SelectionMenuBehavior::kHide,
4204                              blink::WebLocalFrame::kSelectionDoNotSetFocus);
4205 }
4206
4207 void WebFrameWidgetImpl::Replace(const String& word) {
4208   auto* focused_frame = FocusedWebLocalFrameInWidget();
4209   if (!focused_frame)
4210     return;
4211   if (!focused_frame->HasSelection()) {
4212     focused_frame->SelectAroundCaret(mojom::blink::SelectionGranularity::kWord,
4213                                      /*should_show_handle=*/false,
4214                                      /*should_show_context_menu=*/false);
4215   }
4216   focused_frame->ReplaceSelection(word);
4217   // If the resulting selection is not actually a change in selection, we do not
4218   // need to explicitly notify about the selection change.
4219   focused_frame->Client()->SyncSelectionIfRequired(
4220       blink::SyncCondition::kNotForced);
4221 }
4222
4223 void WebFrameWidgetImpl::ReplaceMisspelling(const String& word) {
4224   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4225   if (!focused_frame)
4226     return;
4227   if (!focused_frame->HasSelection())
4228     return;
4229   focused_frame->ReplaceMisspelledRange(word);
4230 }
4231
4232 void WebFrameWidgetImpl::SelectRange(const gfx::Point& base_in_dips,
4233                                      const gfx::Point& extent_in_dips) {
4234   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4235   if (!focused_frame)
4236     return;
4237   focused_frame->SelectRange(
4238       widget_base_->DIPsToRoundedBlinkSpace(base_in_dips),
4239       widget_base_->DIPsToRoundedBlinkSpace(extent_in_dips));
4240 }
4241
4242 void WebFrameWidgetImpl::AdjustSelectionByCharacterOffset(
4243     int32_t start,
4244     int32_t end,
4245     mojom::blink::SelectionMenuBehavior selection_menu_behavior) {
4246   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4247   if (!focused_frame)
4248     return;
4249   blink::WebRange range =
4250       focused_frame->GetInputMethodController()->GetSelectionOffsets();
4251   if (range.IsNull())
4252     return;
4253
4254   // Sanity checks to disallow empty and out of range selections.
4255   if (start - end > range.length() || range.StartOffset() + start < 0)
4256     return;
4257
4258   // A negative adjust amount moves the selection towards the beginning of
4259   // the document, a positive amount moves the selection towards the end of
4260   // the document.
4261   focused_frame->SelectRange(blink::WebRange(range.StartOffset() + start,
4262                                              range.length() + end - start),
4263                              blink::WebLocalFrame::kPreserveHandleVisibility,
4264                              selection_menu_behavior,
4265                              blink::WebLocalFrame::kSelectionSetFocus);
4266 }
4267
4268 void WebFrameWidgetImpl::MoveRangeSelectionExtent(
4269     const gfx::Point& extent_in_dips) {
4270   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4271   if (!focused_frame)
4272     return;
4273   focused_frame->MoveRangeSelectionExtent(
4274       widget_base_->DIPsToRoundedBlinkSpace(extent_in_dips));
4275 }
4276
4277 void WebFrameWidgetImpl::ScrollFocusedEditableNodeIntoView() {
4278   WebLocalFrameImpl* local_frame = FocusedWebLocalFrameInWidget();
4279   if (!local_frame)
4280     return;
4281
4282   // OnSynchronizeVisualProperties does not call DidChangeVisibleViewport
4283   // on OOPIFs. Since we are starting a new scroll operation now, call
4284   // DidChangeVisibleViewport to ensure that we don't assume the element
4285   // is already in view and ignore the scroll.
4286   local_frame->ResetHasScrolledFocusedEditableIntoView();
4287   local_frame->ScrollFocusedEditableElementIntoView();
4288 }
4289
4290 void WebFrameWidgetImpl::WaitForPageScaleAnimationForTesting(
4291     WaitForPageScaleAnimationForTestingCallback callback) {
4292   DCHECK(ForMainFrame());
4293   DCHECK(LocalRootImpl()->GetFrame()->IsOutermostMainFrame());
4294   page_scale_animation_for_testing_callback_ = std::move(callback);
4295 }
4296
4297 void WebFrameWidgetImpl::ZoomToFindInPageRect(
4298     const gfx::Rect& rect_in_root_frame) {
4299   if (ForMainFrame()) {
4300     View()->ZoomToFindInPageRect(rect_in_root_frame);
4301   } else {
4302     GetAssociatedFrameWidgetHost()->ZoomToFindInPageRectInMainFrame(
4303         rect_in_root_frame);
4304   }
4305 }
4306
4307 void WebFrameWidgetImpl::MoveCaret(const gfx::Point& point_in_dips) {
4308   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4309   if (!focused_frame)
4310     return;
4311   focused_frame->MoveCaretSelection(
4312       widget_base_->DIPsToRoundedBlinkSpace(point_in_dips));
4313 }
4314
4315 void WebFrameWidgetImpl::SelectAroundCaret(
4316     mojom::blink::SelectionGranularity granularity,
4317     bool should_show_handle,
4318     bool should_show_context_menu,
4319     SelectAroundCaretCallback callback) {
4320   auto* focused_frame = FocusedWebLocalFrameInWidget();
4321   if (!focused_frame) {
4322     std::move(callback).Run(std::move(nullptr));
4323     return;
4324   }
4325
4326   int extended_start_adjust = 0;
4327   int extended_end_adjust = 0;
4328   int word_start_adjust = 0;
4329   int word_end_adjust = 0;
4330   blink::WebRange initial_range = focused_frame->SelectionRange();
4331   SetHandlingInputEvent(true);
4332
4333   if (initial_range.IsNull()) {
4334     std::move(callback).Run(std::move(nullptr));
4335     return;
4336   }
4337
4338   // If the requested granularity is not word, still calculate the hypothetical
4339   // word selection offsets. This is needed for contextual search to support
4340   // legacy semantics for the word that was tapped.
4341   blink::WebRange word_range;
4342   if (granularity != mojom::blink::SelectionGranularity::kWord) {
4343     word_range = focused_frame->GetWordSelectionRangeAroundCaret();
4344   }
4345
4346   // Select around the caret at the specified |granularity|.
4347   if (!focused_frame->SelectAroundCaret(granularity, should_show_handle,
4348                                         should_show_context_menu)) {
4349     std::move(callback).Run(std::move(nullptr));
4350     return;
4351   }
4352
4353   blink::WebRange extended_range = focused_frame->SelectionRange();
4354   DCHECK(!extended_range.IsNull());
4355   extended_start_adjust =
4356       extended_range.StartOffset() - initial_range.StartOffset();
4357   extended_end_adjust = extended_range.EndOffset() - initial_range.EndOffset();
4358
4359   if (granularity == mojom::blink::SelectionGranularity::kWord) {
4360     // Since the requested granularity was word, simply set the word offset
4361     // to be the same as the extended offset values.
4362     word_start_adjust = extended_start_adjust;
4363     word_end_adjust = extended_end_adjust;
4364   } else {
4365     // Calculate the word offset compared to the initial selection (caret).
4366     DCHECK(!word_range.IsNull());
4367     word_start_adjust = word_range.StartOffset() - initial_range.StartOffset();
4368     word_end_adjust = word_range.EndOffset() - initial_range.EndOffset();
4369   }
4370
4371   SetHandlingInputEvent(false);
4372   auto result = mojom::blink::SelectAroundCaretResult::New();
4373   result->extended_start_adjust = extended_start_adjust;
4374   result->extended_end_adjust = extended_end_adjust;
4375   result->word_start_adjust = word_start_adjust;
4376   result->word_end_adjust = word_end_adjust;
4377   std::move(callback).Run(std::move(result));
4378 }
4379
4380 void WebFrameWidgetImpl::ForEachRemoteFrameControlledByWidget(
4381     base::FunctionRef<void(RemoteFrame*)> callback) {
4382   ForEachRemoteFrameChildrenControlledByWidget(local_root_->GetFrame(),
4383                                                callback);
4384 }
4385
4386 void WebFrameWidgetImpl::CalculateSelectionBounds(
4387     gfx::Rect& anchor_root_frame,
4388     gfx::Rect& focus_root_frame,
4389     gfx::Rect* bounding_box_in_root_frame) {
4390   const LocalFrame* local_frame = FocusedLocalFrameInWidget();
4391   if (!local_frame)
4392     return;
4393
4394   gfx::Rect anchor;
4395   gfx::Rect focus;
4396   auto& selection = local_frame->Selection();
4397   if (!selection.ComputeAbsoluteBounds(anchor, focus))
4398     return;
4399
4400   // Apply the visual viewport for main frames this will apply the page scale.
4401   // For subframes it will just be a 1:1 transformation and the browser
4402   // will then apply later transformations to these rects.
4403   VisualViewport& visual_viewport = GetPage()->GetVisualViewport();
4404   anchor_root_frame = visual_viewport.RootFrameToViewport(
4405       local_frame->View()->ConvertToRootFrame(anchor));
4406   focus_root_frame = visual_viewport.RootFrameToViewport(
4407       local_frame->View()->ConvertToRootFrame(focus));
4408
4409   // Calculate the bounding box of the selection area.
4410   if (bounding_box_in_root_frame) {
4411     Range* range =
4412         CreateRange(selection.GetSelectionInDOMTree().ComputeRange());
4413     const gfx::Rect bounding_box = ToEnclosingRect(range->BoundingRect());
4414     range->Dispose();
4415     *bounding_box_in_root_frame = visual_viewport.RootFrameToViewport(
4416         local_frame->View()->ConvertToRootFrame(bounding_box));
4417   }
4418 }
4419
4420 const viz::LocalSurfaceId& WebFrameWidgetImpl::LocalSurfaceIdFromParent() {
4421   return widget_base_->local_surface_id_from_parent();
4422 }
4423
4424 cc::LayerTreeHost* WebFrameWidgetImpl::LayerTreeHost() {
4425   return widget_base_->LayerTreeHost();
4426 }
4427
4428 cc::LayerTreeHost* WebFrameWidgetImpl::LayerTreeHostForTesting() const {
4429   return widget_base_->LayerTreeHost();
4430 }
4431
4432 ScreenMetricsEmulator* WebFrameWidgetImpl::DeviceEmulator() {
4433   return device_emulator_.Get();
4434 }
4435
4436 bool WebFrameWidgetImpl::AutoResizeMode() {
4437   return View()->AutoResizeMode();
4438 }
4439
4440 void WebFrameWidgetImpl::SetScreenMetricsEmulationParameters(
4441     bool enabled,
4442     const DeviceEmulationParams& params) {
4443   if (enabled)
4444     View()->ActivateDevToolsTransform(params);
4445   else
4446     View()->DeactivateDevToolsTransform();
4447 }
4448
4449 void WebFrameWidgetImpl::SetScreenInfoAndSize(
4450     const display::ScreenInfos& screen_infos,
4451     const gfx::Size& widget_size_in_dips,
4452     const gfx::Size& visible_viewport_size_in_dips) {
4453   // Emulation happens on regular main frames which don't use auto-resize mode.
4454   DCHECK(!AutoResizeMode());
4455
4456   UpdateScreenInfo(screen_infos);
4457   widget_base_->SetVisibleViewportSizeInDIPs(visible_viewport_size_in_dips);
4458   Resize(widget_base_->DIPsToCeiledBlinkSpace(widget_size_in_dips));
4459 }
4460
4461 float WebFrameWidgetImpl::GetCompositingScaleFactor() {
4462   return compositing_scale_factor_;
4463 }
4464
4465 const cc::LayerTreeDebugState& WebFrameWidgetImpl::GetLayerTreeDebugState() {
4466   return widget_base_->LayerTreeHost()->GetDebugState();
4467 }
4468
4469 void WebFrameWidgetImpl::SetLayerTreeDebugState(
4470     const cc::LayerTreeDebugState& state) {
4471   widget_base_->LayerTreeHost()->SetDebugState(state);
4472 }
4473
4474 void WebFrameWidgetImpl::NotifyCompositingScaleFactorChanged(
4475     float compositing_scale_factor) {
4476   compositing_scale_factor_ = compositing_scale_factor;
4477
4478   // Update the scale factor for remote frames which in turn depends on the
4479   // compositing scale factor set in the widget.
4480   ForEachRemoteFrameControlledByWidget([](RemoteFrame* remote_frame) {
4481     // Only RemoteFrames with a local parent frame participate in compositing
4482     // (and thus have a view).
4483     if (remote_frame->View())
4484       remote_frame->View()->UpdateCompositingScaleFactor();
4485   });
4486 }
4487
4488 void WebFrameWidgetImpl::NotifyPageScaleFactorChanged(
4489     float page_scale_factor,
4490     bool is_pinch_gesture_active) {
4491   // Store the value to give to any new RemoteFrame that will be created as a
4492   // descendant of this widget.
4493   page_scale_factor_in_mainframe_ = page_scale_factor;
4494   is_pinch_gesture_active_in_mainframe_ = is_pinch_gesture_active;
4495   // Push the page scale factor down to any child RemoteFrames.
4496   // TODO(danakj): This ends up setting the page scale factor in the
4497   // RenderWidgetHost of the child WebFrameWidgetImpl, so that it can bounce
4498   // the value down to its WebFrameWidgetImpl. Since this is essentially a
4499   // global value per-page, we could instead store it once in the browser
4500   // (such as in RenderViewHost) and distribute it to each WebFrameWidgetImpl
4501   // from there.
4502   ForEachRemoteFrameControlledByWidget(
4503       [page_scale_factor, is_pinch_gesture_active](RemoteFrame* remote_frame) {
4504         remote_frame->PageScaleFactorChanged(page_scale_factor,
4505                                              is_pinch_gesture_active);
4506       });
4507 }
4508
4509 void WebFrameWidgetImpl::SetPageScaleStateAndLimits(
4510     float page_scale_factor,
4511     bool is_pinch_gesture_active,
4512     float minimum,
4513     float maximum) {
4514   widget_base_->LayerTreeHost()->SetPageScaleFactorAndLimits(page_scale_factor,
4515                                                              minimum, maximum);
4516
4517   // Only propagate page scale from the main frame.
4518   if (ForMainFrame()) {
4519     // If page scale hasn't changed, then just return without notifying
4520     // the remote frames.
4521     if (page_scale_factor == page_scale_factor_in_mainframe_ &&
4522         is_pinch_gesture_active == is_pinch_gesture_active_in_mainframe_) {
4523       return;
4524     }
4525
4526     NotifyPageScaleFactorChanged(page_scale_factor, is_pinch_gesture_active);
4527   }
4528 }
4529
4530 void WebFrameWidgetImpl::UpdateViewportDescription(
4531     const ViewportDescription& viewport) {
4532   bool is_device_width = viewport.max_width.IsDeviceWidth();
4533   bool is_zoom_at_least_one = viewport.zoom >= 1.0 || viewport.min_zoom >= 1;
4534   widget_base_->LayerTreeHost()->UpdateViewportIsMobileOptimized(
4535       (is_device_width && is_zoom_at_least_one) ||
4536       (is_device_width && !viewport.zoom_is_explicit) ||
4537       (viewport.max_width.IsAuto() && is_zoom_at_least_one));
4538 }
4539
4540 bool WebFrameWidgetImpl::UpdateScreenRects(
4541     const gfx::Rect& widget_screen_rect,
4542     const gfx::Rect& window_screen_rect) {
4543   if (!device_emulator_)
4544     return false;
4545   device_emulator_->OnUpdateScreenRects(widget_screen_rect, window_screen_rect);
4546   return true;
4547 }
4548
4549 #if BUILDFLAG(IS_EFL)
4550 void WebFrameWidgetImpl::GetContentSnapshot(const gfx::Rect& snapshot_rect,
4551                                             float page_scale_factor,
4552                                             SkBitmap* snapshot) {
4553   WebView* view = View();
4554   if (!view || !view->MainFrame()) {
4555     LOG(ERROR) << "SoftBitmap:Capture Invalid view";
4556     return;
4557   }
4558
4559   if (view->HasAcceleratedCanvasWithinViewport()) {
4560     LOG(ERROR)
4561         << "SoftBitmap:Capture avoided for WebGl/Cavas2D content on viewport";
4562     return;
4563   }
4564
4565   if (view->MainFrameWidget()->Size().IsEmpty()) {
4566     LOG(ERROR) << "SoftBitmap:Capture Invalid size";
4567     return;
4568   }
4569
4570   snapshot->allocPixels(SkImageInfo::MakeN32Premul(snapshot_rect.width(),
4571                                                    snapshot_rect.height()));
4572   SkCanvas canvas(*snapshot);
4573   if (!view->PaintSoftBitmap(&canvas, snapshot_rect)) {
4574     LOG(ERROR) << "SoftBitmap:Capture PaintSoftBitmap failed";
4575     return;
4576   }
4577
4578   *snapshot = skia::ImageOperations::Resize(
4579       *snapshot, skia::ImageOperations::RESIZE_GOOD,
4580       page_scale_factor * snapshot->width(),
4581       page_scale_factor * snapshot->height());
4582 }
4583
4584 SkColor WebFrameWidgetImpl::GetBackgroundColor() {
4585   SkColor bg_color = View()->BackgroundColor();
4586   return bg_color;
4587 }
4588
4589 gfx::RectF WebFrameWidgetImpl::UpdateFocusedNodeBounds() {
4590   Element* element = FocusedElement();
4591   if (!element)
4592     return gfx::RectF();
4593
4594   WebElement web_element = WebElement(element);
4595
4596   if (!web_element.IsNull() && web_element.IsElementNode()) {
4597     gfx::RectF focused_node_bounds_scaled = gfx::ScaleRect(
4598         gfx::RectF(web_element.BoundsInWidget()), View()->PageScaleFactor());
4599     return focused_node_bounds_scaled;
4600   }
4601   return gfx::RectF();
4602 }
4603
4604 void WebFrameWidgetImpl::SetLongPollingGlobalTimeout(uint64_t timeout) {
4605   WebView* view = View();
4606   if (view)
4607     view->SetLongPollingGlobalTimeout(timeout);
4608 }
4609
4610 bool WebFrameWidgetImpl::QueryInputType() {
4611   Element* element = FocusedElement();
4612   if (!element)
4613     return false;
4614
4615   auto* input_element = DynamicTo<HTMLInputElement>(element);
4616   if (input_element && input_element->type() == input_type_names::kPassword)
4617     return true;
4618
4619   return false;
4620 }
4621
4622 void WebFrameWidgetImpl::SelectClosestWord(uint32_t x, uint32_t y) {
4623   if (!View())
4624     return;
4625
4626   blink::WebFrame* main_frame = View()->MainFrame();
4627   if (!main_frame)
4628     return;
4629
4630   SetHandlingInputEvent(true);
4631   main_frame->SelectClosestWord(x, y);
4632   SetHandlingInputEvent(false);
4633 }
4634
4635 void WebFrameWidgetImpl::SelectFocusedLink() {
4636   Element* element = FocusedElement();
4637   if (!element)
4638     return;
4639
4640   WebElement web_element = WebElement(element);
4641   if (web_element.IsNull() || web_element.IsEditable() ||
4642       web_element.HasHTMLTagName("select")) {
4643     return;
4644   }
4645
4646   gfx::Rect box_rect = web_element.BoundsInWidget();
4647   if (box_rect.IsEmpty())
4648     return;
4649
4650   if (!View())
4651     return;
4652
4653   float page_scale = View()->PageScaleFactor();
4654   int focused_x = (box_rect.x() + box_rect.width() / 2) / page_scale;
4655   int focused_y = (box_rect.y() + box_rect.height() / 2) / page_scale;
4656
4657   SelectClosestWord(focused_x, focused_y);
4658 }
4659
4660 gfx::Rect WebFrameWidgetImpl::RequestSelectionRect() {
4661   if (!View())
4662     return gfx::Rect();
4663
4664   return gfx::Rect(View()->CurrentSelectionRect());
4665 }
4666
4667 void WebFrameWidgetImpl::ResetLastInteractedElements() {
4668 #if defined(TIZEN_AUTOFILL_FW)
4669   if (!View())
4670     return;
4671
4672   if (auto* frame = View()->FocusedFrame())
4673     frame->ResetLastInteractedElements();
4674 #endif
4675 }
4676
4677 void WebFrameWidgetImpl::PrintToPdf(uint32_t width,
4678                                     uint32_t height,
4679                                     const base::FilePath& filename) {
4680   WebLocalFrame* focused_frame = FocusedWebLocalFrameInWidget();
4681   if (!focused_frame || !focused_frame->Client())
4682     return;
4683
4684   focused_frame->Client()->PrintToPdf(
4685       width, height, filename,
4686       content::RenderFrame::FromWebFrame(focused_frame));
4687 }
4688
4689 void WebFrameWidgetImpl::SetMainFrameScrollbarVisible(bool visible) {
4690   blink::WebView* view = View();
4691   if (!view || !view->MainFrame() || !view->MainFrame()->ToWebLocalFrame())
4692     return;
4693
4694   view->MainFrame()->ToWebLocalFrame()->ChangeScrollbarVisibility(visible);
4695 }
4696
4697 bool WebFrameWidgetImpl::RequestMainFrameScrollbarVisible(bool& visible) {
4698   blink::WebView* view = View();
4699   if (!view || !view->MainFrame() || !view->MainFrame()->ToWebLocalFrame())
4700     return false;
4701
4702   auto local_frame = view->MainFrame()->ToWebLocalFrame();
4703   visible = local_frame->HasHorizontalScrollbar() ||
4704             local_frame->HasVerticalScrollbar();
4705   return true;
4706 }
4707
4708 #if BUILDFLAG(IS_TIZEN_TV)
4709 void WebFrameWidgetImpl::SetFloatVideoWindowState(bool enabled) {
4710   View()->SetFloatVideoWindowState(enabled);
4711 }
4712
4713 void WebFrameWidgetImpl::SuspendNetworkLoading() {
4714   View()->SuspendNetworkLoading();
4715 }
4716
4717 void WebFrameWidgetImpl::ResumeNetworkLoading() {
4718   View()->ResumeNetworkLoading();
4719 }
4720 #endif  // IS_TIZEN_TV
4721 #endif  // IS_EFL
4722
4723 #if BUILDFLAG(IS_TIZEN)
4724 void WebFrameWidgetImpl::SetMaxRefreshRate(uint32_t max_refresh_rate) {
4725   widget_base_->SetMaxRefreshRate(max_refresh_rate);
4726 }
4727 #endif
4728
4729 #if BUILDFLAG(IS_TIZEN)
4730 void WebFrameWidgetImpl::DidChangeLoadState(bool is_loading) {
4731   widget_base_->LayerTreeHost()->DidChangeLoadState(is_loading);
4732 }
4733 #endif
4734
4735 void WebFrameWidgetImpl::OrientationChanged() {
4736   local_root_->SendOrientationChangeEvent();
4737 }
4738
4739 #if BUILDFLAG(IS_TIZEN)
4740 void WebFrameWidgetImpl::PauseScheduledTasks() {
4741   View()->PauseScheduledTasks();
4742 }
4743
4744 void WebFrameWidgetImpl::UnPauseScheduledTasks() {
4745   View()->UnpauseScheduledTasks();
4746 }
4747 #endif
4748
4749 void WebFrameWidgetImpl::DidUpdateSurfaceAndScreen(
4750     const display::ScreenInfos& previous_original_screen_infos) {
4751   display::ScreenInfo screen_info = widget_base_->GetScreenInfo();
4752   View()->SetZoomFactorForDeviceScaleFactor(screen_info.device_scale_factor);
4753
4754   if (ShouldAutoDetermineCompositingToLCDTextSetting()) {
4755     // This causes compositing state to be modified which dirties the
4756     // document lifecycle. Android Webview relies on the document
4757     // lifecycle being clean after the RenderWidget is initialized, in
4758     // order to send IPCs that query and change compositing state. So
4759     // WebFrameWidgetImpl::Resize() must come after this call, as it runs the
4760     // entire document lifecycle.
4761     View()->GetSettings()->SetLCDTextPreference(
4762         widget_base_->ComputeLCDTextPreference());
4763   }
4764
4765   // When the device scale changes, the size and position of the popup would
4766   // need to be adjusted, which we can't do. Just close the popup, which is
4767   // also consistent with page zoom and resize behavior.
4768   display::ScreenInfos original_screen_infos = GetOriginalScreenInfos();
4769   if (previous_original_screen_infos.current().device_scale_factor !=
4770       original_screen_infos.current().device_scale_factor) {
4771     View()->CancelPagePopup();
4772   }
4773
4774   const bool window_screen_has_changed =
4775       !Screen::AreWebExposedScreenPropertiesEqual(
4776           previous_original_screen_infos.current(),
4777           original_screen_infos.current());
4778
4779   // Update Screens interface data before firing any events. The API is designed
4780   // to offer synchronous access to the most up-to-date cached screen
4781   // information when a change event is fired.  It is not required but it
4782   // is convenient to have all ScreenDetailed objects be up to date when any
4783   // window.screen events are fired as well.
4784   ForEachLocalFrameControlledByWidget(
4785       LocalRootImpl()->GetFrame(),
4786       [&original_screen_infos,
4787        window_screen_has_changed](WebLocalFrameImpl* local_frame) {
4788         auto* screen = local_frame->GetFrame()->DomWindow()->screen();
4789         screen->UpdateDisplayId(original_screen_infos.current().display_id);
4790         CoreInitializer::GetInstance().DidUpdateScreens(
4791             *local_frame->GetFrame(), original_screen_infos);
4792         if (window_screen_has_changed)
4793           screen->DispatchEvent(*Event::Create(event_type_names::kChange));
4794       });
4795
4796   if (previous_original_screen_infos != original_screen_infos) {
4797     // Propagate changes down to child local root RenderWidgets and
4798     // BrowserPlugins in other frame trees/processes.
4799     ForEachRemoteFrameControlledByWidget(
4800         [&original_screen_infos](RemoteFrame* remote_frame) {
4801           remote_frame->DidChangeScreenInfos(original_screen_infos);
4802         });
4803   }
4804 }
4805
4806 gfx::Rect WebFrameWidgetImpl::ViewportVisibleRect() {
4807   if (ForMainFrame()) {
4808     return widget_base_->CompositorViewportRect();
4809   } else {
4810     return child_data().compositor_visible_rect;
4811   }
4812 }
4813
4814 absl::optional<display::mojom::blink::ScreenOrientation>
4815 WebFrameWidgetImpl::ScreenOrientationOverride() {
4816   return View()->ScreenOrientationOverride();
4817 }
4818
4819 void WebFrameWidgetImpl::WasHidden() {
4820   ForEachLocalFrameControlledByWidget(local_root_->GetFrame(),
4821                                       [](WebLocalFrameImpl* local_frame) {
4822                                         local_frame->Client()->WasHidden();
4823                                       });
4824
4825   if (animation_frame_timing_monitor_) {
4826     animation_frame_timing_monitor_->Shutdown();
4827     animation_frame_timing_monitor_.Clear();
4828   }
4829 }
4830
4831 void WebFrameWidgetImpl::WasShown(bool was_evicted) {
4832   ForEachLocalFrameControlledByWidget(local_root_->GetFrame(),
4833                                       [](WebLocalFrameImpl* local_frame) {
4834                                         local_frame->Client()->WasShown();
4835                                       });
4836   if (was_evicted) {
4837     ForEachRemoteFrameControlledByWidget(
4838         // On eviction, the last SurfaceId is invalidated. We need to
4839         // allocate a new id.
4840         &RemoteFrame::ResendVisualProperties);
4841   }
4842
4843   CHECK(local_root_ && local_root_->GetFrame());
4844   if (!animation_frame_timing_monitor_ &&
4845       RuntimeEnabledFeatures::LongAnimationFrameMonitoringEnabled(
4846           local_root_->GetFrame()->DomWindow())) {
4847     animation_frame_timing_monitor_ =
4848         MakeGarbageCollected<AnimationFrameTimingMonitor>(
4849             *this, local_root_->GetFrame()->GetProbeSink());
4850   }
4851 }
4852
4853 void WebFrameWidgetImpl::RunPaintBenchmark(int repeat_count,
4854                                            cc::PaintBenchmarkResult& result) {
4855   if (!ForMainFrame())
4856     return;
4857   if (auto* frame_view = LocalRootImpl()->GetFrameView())
4858     frame_view->RunPaintBenchmark(repeat_count, result);
4859 }
4860
4861 void WebFrameWidgetImpl::NotifyInputObservers(
4862     const WebCoalescedInputEvent& coalesced_event) {
4863   LocalFrame* frame = FocusedLocalFrameInWidget();
4864   if (!frame)
4865     return;
4866
4867   LocalFrameView* frame_view = frame->View();
4868   if (!frame_view)
4869     return;
4870
4871   const WebInputEvent& input_event = coalesced_event.Event();
4872   auto& paint_timing_detector = frame_view->GetPaintTimingDetector();
4873
4874   if (paint_timing_detector.NeedToNotifyInputOrScroll())
4875     paint_timing_detector.NotifyInputEvent(input_event.GetType());
4876 }
4877
4878 Frame* WebFrameWidgetImpl::FocusedCoreFrame() const {
4879   return GetPage() ? GetPage()->GetFocusController().FocusedOrMainFrame()
4880                    : nullptr;
4881 }
4882
4883 Element* WebFrameWidgetImpl::FocusedElement() const {
4884   LocalFrame* frame = GetPage()->GetFocusController().FocusedFrame();
4885   if (!frame)
4886     return nullptr;
4887
4888   Document* document = frame->GetDocument();
4889   if (!document)
4890     return nullptr;
4891
4892   return document->FocusedElement();
4893 }
4894
4895 HitTestResult WebFrameWidgetImpl::HitTestResultForRootFramePos(
4896     const gfx::PointF& pos_in_root_frame) {
4897   gfx::PointF doc_point =
4898       LocalRootImpl()->GetFrame()->View()->ConvertFromRootFrame(
4899           pos_in_root_frame);
4900   HitTestLocation location(doc_point);
4901   HitTestResult result =
4902       LocalRootImpl()->GetFrame()->View()->HitTestWithThrottlingAllowed(
4903           location, HitTestRequest::kReadOnly | HitTestRequest::kActive);
4904   return result;
4905 }
4906
4907 KURL WebFrameWidgetImpl::GetURLForDebugTrace() {
4908   WebFrame* main_frame = View()->MainFrame();
4909   if (main_frame->IsWebLocalFrame())
4910     return main_frame->ToWebLocalFrame()->GetDocument().Url();
4911   return {};
4912 }
4913
4914 float WebFrameWidgetImpl::GetTestingDeviceScaleFactorOverride() {
4915   return device_scale_factor_for_testing_;
4916 }
4917
4918 void WebFrameWidgetImpl::ReleaseMouseLockAndPointerCaptureForTesting() {
4919   GetPage()->GetPointerLockController().ExitPointerLock();
4920   MouseCaptureLost();
4921 }
4922
4923 const viz::FrameSinkId& WebFrameWidgetImpl::GetFrameSinkId() {
4924   // It is valid to create a WebFrameWidget with an invalid frame sink id for
4925   // printing and placeholders. But if we go to use it, it should be valid.
4926   DCHECK(frame_sink_id_.is_valid());
4927   return frame_sink_id_;
4928 }
4929
4930 WebHitTestResult WebFrameWidgetImpl::HitTestResultAt(const gfx::PointF& point) {
4931   return CoreHitTestResultAt(point);
4932 }
4933
4934 void WebFrameWidgetImpl::SetZoomLevelForTesting(double zoom_level) {
4935   DCHECK(ForMainFrame());
4936   DCHECK_NE(zoom_level, -INFINITY);
4937   zoom_level_for_testing_ = zoom_level;
4938   SetZoomLevel(zoom_level);
4939 }
4940
4941 void WebFrameWidgetImpl::ResetZoomLevelForTesting() {
4942   DCHECK(ForMainFrame());
4943   zoom_level_for_testing_ = -INFINITY;
4944   SetZoomLevel(0);
4945 }
4946
4947 void WebFrameWidgetImpl::SetDeviceScaleFactorForTesting(float factor) {
4948   DCHECK(ForMainFrame());
4949   DCHECK_GE(factor, 0.f);
4950
4951   // Stash the window size before we adjust the scale factor, as subsequent
4952   // calls to convert will use the new scale factor.
4953   gfx::Size size_in_dips = widget_base_->BlinkSpaceToFlooredDIPs(Size());
4954   device_scale_factor_for_testing_ = factor;
4955
4956   // Receiving a 0 is used to reset between tests, it removes the override in
4957   // order to listen to the browser for the next test.
4958   if (!factor)
4959     return;
4960
4961   // We are changing the device scale factor from the renderer, so allocate a
4962   // new viz::LocalSurfaceId to avoid surface invariants violations in tests.
4963   widget_base_->LayerTreeHost()->RequestNewLocalSurfaceId();
4964
4965   display::ScreenInfos screen_infos = widget_base_->screen_infos();
4966   screen_infos.mutable_current().device_scale_factor = factor;
4967   gfx::Size size_with_dsf = gfx::ScaleToCeiledSize(size_in_dips, factor);
4968   widget_base_->UpdateCompositorViewportAndScreenInfo(gfx::Rect(size_with_dsf),
4969                                                       screen_infos);
4970   if (!AutoResizeMode()) {
4971     // This picks up the new device scale factor as
4972     // `UpdateCompositorViewportAndScreenInfo()` has applied a new value.
4973     Resize(widget_base_->DIPsToCeiledBlinkSpace(size_in_dips));
4974   }
4975 }
4976
4977 FrameWidgetTestHelper*
4978 WebFrameWidgetImpl::GetFrameWidgetTestHelperForTesting() {
4979   return nullptr;
4980 }
4981
4982 void WebFrameWidgetImpl::PrepareForFinalLifecyclUpdateForTesting() {
4983   ForEachLocalFrameControlledByWidget(
4984       LocalRootImpl()->GetFrame(), [](WebLocalFrameImpl* local_frame) {
4985         LocalFrame* core_frame = local_frame->GetFrame();
4986         // A frame in the frame tree is fully attached and must always have a
4987         // core frame.
4988         DCHECK(core_frame);
4989         Document* document = core_frame->GetDocument();
4990         // Similarly, a fully attached frame must always have a document.
4991         DCHECK(document);
4992
4993         // In a web test, a rendering update may not have occurred before the
4994         // test finishes so ensure the transition moves out of rendering
4995         // blocked state.
4996         if (RuntimeEnabledFeatures::ViewTransitionOnNavigationEnabled()) {
4997           if (auto* transition =
4998                   ViewTransitionUtils::GetTransition(*document)) {
4999             transition->ActivateFromSnapshot();
5000           }
5001         }
5002       });
5003 }
5004
5005 void WebFrameWidgetImpl::SetMayThrottleIfUndrawnFrames(
5006     bool may_throttle_if_undrawn_frames) {
5007   if (!View()->does_composite())
5008     return;
5009   widget_base_->LayerTreeHost()->SetMayThrottleIfUndrawnFrames(
5010       may_throttle_if_undrawn_frames);
5011 }
5012
5013 int WebFrameWidgetImpl::GetVirtualKeyboardResizeHeight() const {
5014   DCHECK(!virtual_keyboard_resize_height_physical_px_ || ForTopMostMainFrame());
5015   return virtual_keyboard_resize_height_physical_px_;
5016 }
5017
5018 void WebFrameWidgetImpl::SetVirtualKeyboardResizeHeightForTesting(int height) {
5019   virtual_keyboard_resize_height_physical_px_ = height;
5020 }
5021
5022 bool WebFrameWidgetImpl::GetMayThrottleIfUndrawnFramesForTesting() {
5023   return widget_base_->LayerTreeHost()
5024       ->GetMayThrottleIfUndrawnFramesForTesting();
5025 }
5026
5027 WebPlugin* WebFrameWidgetImpl::GetFocusedPluginContainer() {
5028   LocalFrame* focused_frame = FocusedLocalFrameInWidget();
5029   if (!focused_frame)
5030     return nullptr;
5031   if (auto* container = focused_frame->GetWebPluginContainer())
5032     return container->Plugin();
5033   return nullptr;
5034 }
5035
5036 bool WebFrameWidgetImpl::HasPendingPageScaleAnimation() {
5037   return LayerTreeHost()->HasPendingPageScaleAnimation();
5038 }
5039
5040 void WebFrameWidgetImpl::SetSourceURLForCompositor(ukm::SourceId source_id,
5041                                                    const KURL& url) {
5042   LayerTreeHost()->SetSourceURL(source_id, GURL(url));
5043 }
5044
5045 base::ReadOnlySharedMemoryRegion
5046 WebFrameWidgetImpl::CreateSharedMemoryForSmoothnessUkm() {
5047   return LayerTreeHost()->CreateSharedMemoryForSmoothnessUkm();
5048 }
5049
5050 bool WebFrameWidgetImpl::CanComposeInline() {
5051   if (auto* plugin = GetFocusedPluginContainer())
5052     return plugin->CanComposeInline();
5053   return true;
5054 }
5055
5056 bool WebFrameWidgetImpl::ShouldDispatchImeEventsToPlugin() {
5057   if (auto* plugin = GetFocusedPluginContainer())
5058     return plugin->ShouldDispatchImeEventsToPlugin();
5059   return false;
5060 }
5061
5062 void WebFrameWidgetImpl::ImeSetCompositionForPlugin(
5063     const String& text,
5064     const Vector<ui::ImeTextSpan>& ime_text_spans,
5065     const gfx::Range& replacement_range,
5066     int selection_start,
5067     int selection_end) {
5068   if (auto* plugin = GetFocusedPluginContainer()) {
5069     plugin->ImeSetCompositionForPlugin(
5070         text,
5071         std::vector<ui::ImeTextSpan>(ime_text_spans.begin(),
5072                                      ime_text_spans.end()),
5073         replacement_range, selection_start, selection_end);
5074   }
5075 }
5076
5077 void WebFrameWidgetImpl::ImeCommitTextForPlugin(
5078     const String& text,
5079     const Vector<ui::ImeTextSpan>& ime_text_spans,
5080     const gfx::Range& replacement_range,
5081     int relative_cursor_pos) {
5082   if (auto* plugin = GetFocusedPluginContainer()) {
5083     plugin->ImeCommitTextForPlugin(
5084         text,
5085         std::vector<ui::ImeTextSpan>(ime_text_spans.begin(),
5086                                      ime_text_spans.end()),
5087         replacement_range, relative_cursor_pos);
5088   }
5089 }
5090
5091 void WebFrameWidgetImpl::ImeFinishComposingTextForPlugin(bool keep_selection) {
5092   if (auto* plugin = GetFocusedPluginContainer())
5093     plugin->ImeFinishComposingTextForPlugin(keep_selection);
5094 }
5095
5096 void WebFrameWidgetImpl::SetWindowRect(const gfx::Rect& requested_rect,
5097                                        const gfx::Rect& adjusted_rect) {
5098   DCHECK(ForMainFrame());
5099   SetPendingWindowRect(adjusted_rect);
5100   View()->SendWindowRectToMainFrameHost(
5101       requested_rect, WTF::BindOnce(&WebFrameWidgetImpl::AckPendingWindowRect,
5102                                     WrapWeakPersistent(this)));
5103 }
5104
5105 void WebFrameWidgetImpl::SetWindowRectSynchronouslyForTesting(
5106     const gfx::Rect& new_window_rect) {
5107   DCHECK(ForMainFrame());
5108   SetWindowRectSynchronously(new_window_rect);
5109 }
5110
5111 void WebFrameWidgetImpl::SetWindowRectSynchronously(
5112     const gfx::Rect& new_window_rect) {
5113   // This method is only call in tests, and it applies the |new_window_rect| to
5114   // all three of:
5115   // a) widget size (in |size_|)
5116   // b) blink viewport (in |visible_viewport_size_|)
5117   // c) compositor viewport (in cc::LayerTreeHost)
5118   // Normally the browser controls these three things independently, but this is
5119   // used in tests to control the size from the renderer.
5120
5121   // We are resizing the window from the renderer, so allocate a new
5122   // viz::LocalSurfaceId to avoid surface invariants violations in tests.
5123   widget_base_->LayerTreeHost()->RequestNewLocalSurfaceId();
5124
5125   gfx::Rect compositor_viewport_pixel_rect(gfx::ScaleToCeiledSize(
5126       new_window_rect.size(),
5127       widget_base_->GetScreenInfo().device_scale_factor));
5128   widget_base_->UpdateSurfaceAndScreenInfo(
5129       widget_base_->local_surface_id_from_parent(),
5130       compositor_viewport_pixel_rect, widget_base_->screen_infos());
5131
5132   Resize(new_window_rect.size());
5133   widget_base_->SetScreenRects(new_window_rect, new_window_rect);
5134 }
5135
5136 void WebFrameWidgetImpl::DidCreateLocalRootView() {
5137   // If this WebWidget still hasn't received its size from the embedder, block
5138   // the parser. This is necessary, because the parser can cause layout to
5139   // happen, which needs to be done with the correct size.
5140   if (ForSubframe() && !size_) {
5141     child_data().did_suspend_parsing = true;
5142     LocalRootImpl()->GetFrame()->Loader().GetDocumentLoader()->BlockParser();
5143   }
5144 }
5145
5146 bool WebFrameWidgetImpl::ShouldAutoDetermineCompositingToLCDTextSetting() {
5147   return true;
5148 }
5149
5150 void WebFrameWidgetImpl::NotifyZoomLevelChanged(LocalFrame* root) {
5151   if (root) {
5152     Document* document = root->GetDocument();
5153     DCHECK(document);
5154     if (LocalFrameView* view = document->View())
5155       view->GetLayoutShiftTracker().NotifyZoomLevelChanged();
5156   }
5157 }
5158
5159 #if BUILDFLAG(IS_EFL)
5160 void WebFrameWidgetImpl::NotifyKeyEvent(WebInputEvent::Type type,
5161                                         bool processed) {
5162   GetAssociatedFrameWidgetHost()->HandleKeyEvent(type, processed);
5163 }
5164 #endif
5165
5166 #if BUILDFLAG(IS_TIZEN)
5167 void WebFrameWidgetImpl::SetDrawsTransparentBackground(
5168     bool draws_transparent_background) {
5169   WebViewImpl* webview = View();
5170   if (!webview)
5171     return;
5172
5173   SkColor backgroundColor = draws_transparent_background
5174                                 ? static_cast<SkColor>(0x00000000)
5175                                 : static_cast<SkColor>(0xFFFFFFFF);
5176
5177   webview->SetPageBaseBackgroundColor(absl::make_optional(backgroundColor));
5178   // set transparent bg for Render process
5179   if (draws_transparent_background) {
5180     widget_base_->LayerTreeHost()->set_background_color(SkColors::kTransparent);
5181   }
5182 }
5183
5184 void WebFrameWidgetImpl::SetBackgroundColor(int32_t red,
5185                                             int32_t green,
5186                                             int32_t blue,
5187                                             int32_t alpha) {
5188   WebViewImpl* webview = View();
5189   if (!webview)
5190     return;
5191
5192   SkColor backgroundColor = SkColorSetARGB(alpha, red, green, blue);
5193   webview->SetPageBaseBackgroundColor(absl::make_optional(backgroundColor));
5194 }
5195 #endif
5196
5197 }  // namespace blink