chromium/third_party/blink/renderer/core/frame/local_frame_view.cc

/*
 * Copyright (C) 1998, 1999 Torben Weis <[email protected]>
 *                     1999 Lars Knoll <[email protected]>
 *                     1999 Antti Koivisto <[email protected]>
 *                     2000 Dirk Mueller <[email protected]>
 * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
 *           (C) 2006 Graham Dennis ([email protected])
 *           (C) 2006 Alexey Proskuryakov ([email protected])
 * Copyright (C) 2009 Google Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "third_party/blink/renderer/core/frame/local_frame_view.h"

#include <algorithm>
#include <memory>
#include <utility>

#include "base/auto_reset.h"
#include "base/feature_list.h"
#include "base/functional/callback.h"
#include "base/functional/function_ref.h"
#include "base/memory/ptr_util.h"
#include "base/metrics/field_trial_params.h"
#include "base/numerics/safe_conversions.h"
#include "base/timer/lap_timer.h"
#include "base/trace_event/typed_macros.h"
#include "cc/animation/animation_host.h"
#include "cc/animation/animation_timeline.h"
#include "cc/base/features.h"
#include "cc/input/main_thread_scrolling_reason.h"
#include "cc/layers/picture_layer.h"
#include "cc/tiles/frame_viewer_instrumentation.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/view_transition/view_transition_request.h"
#include "components/paint_preview/common/paint_preview_tracker.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/mojom/frame/frame.mojom-blink.h"
#include "third_party/blink/public/mojom/frame/remote_frame.mojom-blink.h"
#include "third_party/blink/public/mojom/scroll/scroll_into_view_params.mojom-blink.h"
#include "third_party/blink/public/mojom/scroll/scrollbar_mode.mojom-blink.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/public/web/web_local_frame_client.h"
#include "third_party/blink/renderer/bindings/core/v8/capture_source_location.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_scroll_into_view_options.h"
#include "third_party/blink/renderer/core/accessibility/ax_object_cache.h"
#include "third_party/blink/renderer/core/animation/document_animations.h"
#include "third_party/blink/renderer/core/animation/document_timeline.h"
#include "third_party/blink/renderer/core/css/font_face_set_document.h"
#include "third_party/blink/renderer/core/css/post_style_update_scope.h"
#include "third_party/blink/renderer/core/css/properties/longhands.h"
#include "third_party/blink/renderer/core/css/style_change_reason.h"
#include "third_party/blink/renderer/core/display_lock/display_lock_document_state.h"
#include "third_party/blink/renderer/core/display_lock/display_lock_utilities.h"
#include "third_party/blink/renderer/core/dom/static_node_list.h"
#include "third_party/blink/renderer/core/editing/drag_caret.h"
#include "third_party/blink/renderer/core/editing/frame_selection.h"
#include "third_party/blink/renderer/core/editing/markers/document_marker_controller.h"
#include "third_party/blink/renderer/core/events/error_event.h"
#include "third_party/blink/renderer/core/exported/web_plugin_container_impl.h"
#include "third_party/blink/renderer/core/fragment_directive/fragment_directive_utils.h"
#include "third_party/blink/renderer/core/fragment_directive/text_fragment_handler.h"
#include "third_party/blink/renderer/core/frame/browser_controls.h"
#include "third_party/blink/renderer/core/frame/find_in_page.h"
#include "third_party/blink/renderer/core/frame/frame_overlay.h"
#include "third_party/blink/renderer/core/frame/frame_view_auto_size_info.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/local_frame_client.h"
#include "third_party/blink/renderer/core/frame/local_frame_ukm_aggregator.h"
#include "third_party/blink/renderer/core/frame/location.h"
#include "third_party/blink/renderer/core/frame/page_scale_constraints_set.h"
#include "third_party/blink/renderer/core/frame/pagination_state.h"
#include "third_party/blink/renderer/core/frame/remote_frame.h"
#include "third_party/blink/renderer/core/frame/remote_frame_view.h"
#include "third_party/blink/renderer/core/frame/root_frame_viewport.h"
#include "third_party/blink/renderer/core/frame/settings.h"
#include "third_party/blink/renderer/core/frame/visual_viewport.h"
#include "third_party/blink/renderer/core/frame/web_frame_widget_impl.h"
#include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
#include "third_party/blink/renderer/core/fullscreen/fullscreen.h"
#include "third_party/blink/renderer/core/highlight/highlight_registry.h"
#include "third_party/blink/renderer/core/html/fenced_frame/document_fenced_frames.h"
#include "third_party/blink/renderer/core/html/fenced_frame/html_fenced_frame_element.h"
#include "third_party/blink/renderer/core/html/forms/text_control_element.h"
#include "third_party/blink/renderer/core/html/html_embed_element.h"
#include "third_party/blink/renderer/core/html/html_frame_element.h"
#include "third_party/blink/renderer/core/html/html_frame_set_element.h"
#include "third_party/blink/renderer/core/html/html_object_element.h"
#include "third_party/blink/renderer/core/html/html_plugin_element.h"
#include "third_party/blink/renderer/core/html/media/html_video_element.h"
#include "third_party/blink/renderer/core/html/parser/text_resource_decoder.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/input/event_handler.h"
#include "third_party/blink/renderer/core/inspector/inspector_trace_events.h"
#include "third_party/blink/renderer/core/intersection_observer/intersection_observation.h"
#include "third_party/blink/renderer/core/intersection_observer/intersection_observer_controller.h"
#include "third_party/blink/renderer/core/layout/adjust_for_absolute_zoom.h"
#include "third_party/blink/renderer/core/layout/block_node.h"
#include "third_party/blink/renderer/core/layout/geometry/transform_state.h"
#include "third_party/blink/renderer/core/layout/geometry/writing_mode_converter.h"
#include "third_party/blink/renderer/core/layout/layout_counter.h"
#include "third_party/blink/renderer/core/layout/layout_embedded_content.h"
#include "third_party/blink/renderer/core/layout/layout_embedded_object.h"
#include "third_party/blink/renderer/core/layout/layout_shift_tracker.h"
#include "third_party/blink/renderer/core/layout/layout_view.h"
#include "third_party/blink/renderer/core/layout/legacy_layout_tree_walking.h"
#include "third_party/blink/renderer/core/layout/pagination_utils.h"
#include "third_party/blink/renderer/core/layout/physical_box_fragment.h"
#include "third_party/blink/renderer/core/layout/svg/layout_svg_root.h"
#include "third_party/blink/renderer/core/layout/text_autosizer.h"
#include "third_party/blink/renderer/core/layout/traced_layout_object.h"
#include "third_party/blink/renderer/core/loader/document_loader.h"
#include "third_party/blink/renderer/core/loader/frame_loader.h"
#include "third_party/blink/renderer/core/media_type_names.h"
#include "third_party/blink/renderer/core/mobile_metrics/mobile_friendliness_checker.h"
#include "third_party/blink/renderer/core/mobile_metrics/tap_friendliness_checker.h"
#include "third_party/blink/renderer/core/page/autoscroll_controller.h"
#include "third_party/blink/renderer/core/page/chrome_client.h"
#include "third_party/blink/renderer/core/page/focus_controller.h"
#include "third_party/blink/renderer/core/page/frame_tree.h"
#include "third_party/blink/renderer/core/page/link_highlight.h"
#include "third_party/blink/renderer/core/page/page.h"
#include "third_party/blink/renderer/core/page/page_animator.h"
#include "third_party/blink/renderer/core/page/scrolling/fragment_anchor.h"
#include "third_party/blink/renderer/core/page/scrolling/scrolling_coordinator.h"
#include "third_party/blink/renderer/core/page/scrolling/snap_coordinator.h"
#include "third_party/blink/renderer/core/page/scrolling/top_document_root_scroller_controller.h"
#include "third_party/blink/renderer/core/page/spatial_navigation_controller.h"
#include "third_party/blink/renderer/core/page/validation_message_client.h"
#include "third_party/blink/renderer/core/paint/cull_rect_updater.h"
#include "third_party/blink/renderer/core/paint/frame_painter.h"
#include "third_party/blink/renderer/core/paint/paint_layer.h"
#include "third_party/blink/renderer/core/paint/paint_layer_painter.h"
#include "third_party/blink/renderer/core/paint/paint_layer_scrollable_area.h"
#include "third_party/blink/renderer/core/paint/pre_paint_tree_walk.h"
#include "third_party/blink/renderer/core/paint/timing/paint_timing.h"
#include "third_party/blink/renderer/core/paint/timing/paint_timing_detector.h"
#include "third_party/blink/renderer/core/probe/core_probes.h"
#include "third_party/blink/renderer/core/resize_observer/resize_observer_controller.h"
#include "third_party/blink/renderer/core/scroll/scroll_alignment.h"
#include "third_party/blink/renderer/core/scroll/scroll_animator_base.h"
#include "third_party/blink/renderer/core/scroll/smooth_scroll_sequencer.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/core/style/position_try_fallbacks.h"
#include "third_party/blink/renderer/core/svg/svg_document_extensions.h"
#include "third_party/blink/renderer/core/svg/svg_svg_element.h"
#include "third_party/blink/renderer/core/view_transition/view_transition.h"
#include "third_party/blink/renderer/core/view_transition/view_transition_request.h"
#include "third_party/blink/renderer/core/view_transition/view_transition_utils.h"
#include "third_party/blink/renderer/platform/bindings/script_forbidden_scope.h"
#include "third_party/blink/renderer/platform/fonts/font_cache.h"
#include "third_party/blink/renderer/platform/fonts/font_performance.h"
#include "third_party/blink/renderer/platform/graphics/compositing/paint_artifact_compositor.h"
#include "third_party/blink/renderer/platform/graphics/dark_mode_settings_builder.h"
#include "third_party/blink/renderer/platform/graphics/graphics_context.h"
#include "third_party/blink/renderer/platform/graphics/paint/cull_rect.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h"
#include "third_party/blink/renderer/platform/graphics/paint/paint_controller.h"
#include "third_party/blink/renderer/platform/instrumentation/histogram.h"
#include "third_party/blink/renderer/platform/instrumentation/resource_coordinator/document_resource_coordinator.h"
#include "third_party/blink/renderer/platform/instrumentation/tracing/trace_event.h"
#include "third_party/blink/renderer/platform/instrumentation/tracing/traced_value.h"
#include "third_party/blink/renderer/platform/language.h"
#include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
#include "third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h"
#include "third_party/blink/renderer/platform/web_test_support.h"
#include "third_party/blink/renderer/platform/widget/frame_widget.h"
#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
#include "third_party/blink/renderer/platform/wtf/wtf_size_t.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/base/cursor/cursor.h"
#include "ui/base/cursor/mojom/cursor_type.mojom-blink.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/quad_f.h"
#include "ui/gfx/geometry/rect_f.h"

// Used to check for dirty layouts violating document lifecycle rules.
// If arg evaluates to true, the program will continue. If arg evaluates to
// false, program will crash if DCHECK_IS_ON() or return false from the current
// function.
#define CHECK_FOR_DIRTY_LAYOUT(arg)

namespace blink {
namespace {

// Logs a UseCounter for the size of the cursor that will be set. This will be
// used for compatibility analysis to determine whether the maximum size can be
// reduced.
void LogCursorSizeCounter(LocalFrame* frame, const ui::Cursor& cursor) {}

gfx::QuadF GetQuadForTimelinePaintEvent(const scoped_refptr<cc::Layer>& layer) {}

// Default value for how long we want to delay the
// compositor commit beyond the start of document lifecycle updates to avoid
// flash between navigations. The delay should be small enough so that it won't
// confuse users expecting a new page to appear after navigation and the omnibar
// has updated the url display.
constexpr int kCommitDelayDefaultInMs =;  // 30 frames @ 60hz

}  // namespace

// The maximum number of updatePlugins iterations that should be done before
// returning.
static const unsigned kMaxUpdatePluginsIterations =;

// The number of |InvalidationDisallowedScope| class instances. Used to ensure
// that no more than one instance of this class exists at any given time.
int LocalFrameView::InvalidationDisallowedScope::instance_count_ =;

LocalFrameView::LocalFrameView(LocalFrame& frame)
    :{}

LocalFrameView::LocalFrameView(LocalFrame& frame, const gfx::Size& initial_size)
    :{}

LocalFrameView::LocalFrameView(LocalFrame& frame, gfx::Rect frame_rect)
    :{}

LocalFrameView::~LocalFrameView() {}

void LocalFrameView::Trace(Visitor* visitor) const {}

void LocalFrameView::ForAllChildViewsAndPlugins(
    base::FunctionRef<void(EmbeddedContentView&)> function) {}

void LocalFrameView::ForAllChildLocalFrameViews(
    base::FunctionRef<void(LocalFrameView&)> function) {}

// Note: if this logic is updated, `ForAllThrottledLocalFrameViews()` may
// need to be updated as well.
void LocalFrameView::ForAllNonThrottledLocalFrameViews(
    base::FunctionRef<void(LocalFrameView&)> function,
    TraversalOrder order) {}

// Note: if this logic is updated, `ForAllNonThrottledLocalFrameViews()` may
// need to be updated as well.
void LocalFrameView::ForAllThrottledLocalFrameViews(
    base::FunctionRef<void(LocalFrameView&)> function) {}

void LocalFrameView::ForAllRemoteFrameViews(
    base::FunctionRef<void(RemoteFrameView&)> function) {}

void LocalFrameView::Dispose() {}

void LocalFrameView::InvalidateAllCustomScrollbarsOnActiveChanged() {}

void LocalFrameView::UsesOverlayScrollbarsChanged() {}

bool LocalFrameView::DidFirstLayout() const {}

bool LocalFrameView::LifecycleUpdatesActive() const {}

void LocalFrameView::SetLifecycleUpdatesThrottledForTesting(bool throttled) {}

void LocalFrameView::FrameRectsChanged(const gfx::Rect& old_rect) {}

Page* LocalFrameView::GetPage() const {}

LayoutView* LocalFrameView::GetLayoutView() const {}

cc::AnimationHost* LocalFrameView::GetCompositorAnimationHost() const {}

cc::AnimationTimeline* LocalFrameView::GetScrollAnimationTimeline() const {}

void LocalFrameView::SetLayoutOverflowSize(const gfx::Size& size) {}

void LocalFrameView::AdjustViewSize() {}

void LocalFrameView::CountObjectsNeedingLayout(unsigned& needs_layout_objects,
                                               unsigned& total_objects,
                                               bool& is_subtree) {}

bool LocalFrameView::LayoutFromRootObject(LayoutObject& root) {}

#define PERFORM_LAYOUT_TRACE_CATEGORIES

void LocalFrameView::PerformLayout() {}

void LocalFrameView::UpdateLayout() {}

void LocalFrameView::WillStartForcedLayout() {}

void LocalFrameView::DidFinishForcedLayout(DocumentUpdateReason reason) {}

void LocalFrameView::MarkFirstEligibleToPaint() {}

void LocalFrameView::MarkIneligibleToPaint() {}

void LocalFrameView::SetNeedsPaintPropertyUpdate() {}

gfx::SizeF LocalFrameView::SmallViewportSizeForViewportUnits() const {}

gfx::SizeF LocalFrameView::LargeViewportSizeForViewportUnits() const {}

gfx::SizeF LocalFrameView::ViewportSizeForMediaQueries() const {}

gfx::SizeF LocalFrameView::DynamicViewportSizeForViewportUnits() const {}

DocumentLifecycle& LocalFrameView::Lifecycle() const {}

bool LocalFrameView::InvalidationDisallowed() const {}

void LocalFrameView::RunPostLifecycleSteps() {}

void LocalFrameView::RunIntersectionObserverSteps() {}

void LocalFrameView::ForceUpdateViewportIntersections() {}

LayoutSVGRoot* LocalFrameView::EmbeddedReplacedContent() const {}

bool LocalFrameView::GetIntrinsicSizingInfo(
    IntrinsicSizingInfo& intrinsic_sizing_info) const {}

bool LocalFrameView::HasIntrinsicSizingInfo() const {}

void LocalFrameView::UpdateGeometry() {}

void LocalFrameView::AddPartToUpdate(LayoutEmbeddedObject& object) {}

void LocalFrameView::SetMediaType(const AtomicString& media_type) {}

AtomicString LocalFrameView::MediaType() const {}

void LocalFrameView::AdjustMediaTypeForPrinting(bool printing) {}

void LocalFrameView::AddBackgroundAttachmentFixedObject(
    LayoutBoxModelObject& object) {}

void LocalFrameView::RemoveBackgroundAttachmentFixedObject(
    LayoutBoxModelObject& object) {}

static bool BackgroundAttachmentFixedNeedsRepaintOnScroll(
    const LayoutObject& object) {}

bool LocalFrameView::RequiresMainThreadScrollingForBackgroundAttachmentFixed()
    const {}

void LocalFrameView::ViewportSizeChanged() {}

void LocalFrameView::InvalidateLayoutForViewportConstrainedObjects() {}

void LocalFrameView::DynamicViewportUnitsChanged() {}

bool LocalFrameView::ShouldSetCursor() const {}

void LocalFrameView::UpdateCanCompositeBackgroundAttachmentFixed() {}

void LocalFrameView::InvalidateBackgroundAttachmentFixedDescendantsOnScroll(
    const LayoutBox& scroller) {}

HitTestResult LocalFrameView::HitTestWithThrottlingAllowed(
    const HitTestLocation& location,
    HitTestRequest::HitTestRequestType request_type) const {}

void LocalFrameView::ProcessUrlFragment(const KURL& url,
                                        bool same_document_navigation,
                                        bool should_scroll) {}

void LocalFrameView::SetLayoutSize(const gfx::Size& size) {}

void LocalFrameView::SetLayoutSizeFixedToFrameSize(bool is_fixed) {}

ChromeClient* LocalFrameView::GetChromeClient() const {}

void LocalFrameView::HandleLoadCompleted() {}

void LocalFrameView::ClearLayoutSubtreeRoot(const LayoutObject& root) {}

void LocalFrameView::ClearLayoutSubtreeRootsAndMarkContainingBlocks() {}

bool LocalFrameView::CheckLayoutInvalidationIsAllowed() const {}

bool LocalFrameView::RunPostLayoutIntersectionObserverSteps() {}

void LocalFrameView::ComputePostLayoutIntersections(
    unsigned parent_flags,
    ComputeIntersectionsContext& context) {}

void LocalFrameView::ScheduleRelayout() {}

void LocalFrameView::ScheduleRelayoutOfSubtree(LayoutObject* relayout_root) {}

bool LocalFrameView::LayoutPending() const {}

bool LocalFrameView::IsInPerformLayout() const {}

bool LocalFrameView::NeedsLayout() const {}

NOINLINE bool LocalFrameView::CheckDoesNotNeedLayout() const {}

void LocalFrameView::SetNeedsLayout() {}

bool LocalFrameView::ShouldUseColorAdjustBackground() const {}

Color LocalFrameView::BaseBackgroundColor() const {}

void LocalFrameView::SetBaseBackgroundColor(const Color& background_color) {}

void LocalFrameView::SetUseColorAdjustBackground(UseColorAdjustBackground use,
                                                 bool color_scheme_changed) {}

bool LocalFrameView::ShouldPaintBaseBackgroundColor() const {}

void LocalFrameView::UpdateBaseBackgroundColorRecursively(
    const Color& base_background_color) {}

void LocalFrameView::InvokeFragmentAnchor() {}

void LocalFrameView::ClearFragmentAnchor() {}

bool LocalFrameView::UpdatePlugins() {}

void LocalFrameView::UpdatePluginsTimerFired(TimerBase*) {}

void LocalFrameView::FlushAnyPendingPostLayoutTasks() {}

void LocalFrameView::ScheduleUpdatePluginsIfNecessary() {}

void LocalFrameView::PerformPostLayoutTasks(bool visual_viewport_size_changed) {}

float LocalFrameView::InputEventsScaleFactor() const {}

void LocalFrameView::NotifyPageThatContentAreaWillPaint() const {}

void LocalFrameView::UpdateDocumentDraggableRegions() const {}

void LocalFrameView::DidAttachDocument() {}

void LocalFrameView::InitializeRootScroller() {}

Color LocalFrameView::DocumentBackgroundColor() {}

void LocalFrameView::WillBeRemovedFromFrame() {}

bool LocalFrameView::IsUpdatingLifecycle() const {}

LocalFrameView* LocalFrameView::ParentFrameView() const {}

LayoutEmbeddedContent* LocalFrameView::GetLayoutEmbeddedContent() const {}

bool LocalFrameView::LoadAllLazyLoadedIframes() {}

void LocalFrameView::UpdateGeometriesIfNeeded() {}

bool LocalFrameView::UpdateAllLifecyclePhases(DocumentUpdateReason reason) {}

bool LocalFrameView::UpdateAllLifecyclePhasesForTest() {}

bool LocalFrameView::UpdateLifecycleToPrePaintClean(
    DocumentUpdateReason reason) {}

bool LocalFrameView::UpdateLifecycleToCompositingInputsClean(
    DocumentUpdateReason reason) {}

bool LocalFrameView::UpdateAllLifecyclePhasesExceptPaint(
    DocumentUpdateReason reason) {}

void LocalFrameView::UpdateLifecyclePhasesForPrinting() {}

bool LocalFrameView::UpdateLifecycleToLayoutClean(DocumentUpdateReason reason) {}

LocalFrameView::InvalidationDisallowedScope::InvalidationDisallowedScope(
    const LocalFrameView& frame_view)
    :{}

LocalFrameView::InvalidationDisallowedScope::~InvalidationDisallowedScope() {}

void LocalFrameView::ScheduleVisualUpdateForVisualOverflowIfNeeded() {}

void LocalFrameView::ScheduleVisualUpdateForPaintInvalidationIfNeeded() {}

bool LocalFrameView::NotifyResizeObservers() {}

bool LocalFrameView::LocalFrameTreeAllowsThrottling() const {}

bool LocalFrameView::LocalFrameTreeForcesThrottling() const {}

void LocalFrameView::PrepareForLifecycleUpdateRecursive() {}

// TODO(leviw): We don't assert lifecycle information from documents in child
// WebPluginContainerImpls.
bool LocalFrameView::UpdateLifecyclePhases(
    DocumentLifecycle::LifecycleState target_state,
    DocumentUpdateReason reason) {}

void LocalFrameView::UpdateLifecyclePhasesInternal(
    DocumentLifecycle::LifecycleState target_state) {}

bool LocalFrameView::RunScrollSnapshotClientSteps() {}

bool LocalFrameView::RunViewTransitionSteps(
    DocumentLifecycle::LifecycleState target_state) {}

bool LocalFrameView::RunResizeObserverSteps(
    DocumentLifecycle::LifecycleState target_state) {}

void LocalFrameView::ClearResizeObserverLimit() {}

bool LocalFrameView::ShouldDeferLayoutSnap() const {}

void LocalFrameView::EnqueueScrollSnapChangingFromImplIfNecessary() {}

bool LocalFrameView::RunStyleAndLayoutLifecyclePhases(
    DocumentLifecycle::LifecycleState target_state) {}

bool LocalFrameView::RunCompositingInputsLifecyclePhase(
    DocumentLifecycle::LifecycleState target_state) {}

bool LocalFrameView::RunPrePaintLifecyclePhase(
    DocumentLifecycle::LifecycleState target_state) {}

bool LocalFrameView::AnyFrameIsPrintingOrPaintingPreview() {}

void LocalFrameView::RunPaintLifecyclePhase(PaintBenchmarkMode benchmark_mode) {}

void LocalFrameView::RunAccessibilitySteps() {}

void LocalFrameView::EnqueueScrollAnchoringAdjustment(
    ScrollableArea* scrollable_area) {}

void LocalFrameView::DequeueScrollAnchoringAdjustment(
    ScrollableArea* scrollable_area) {}

void LocalFrameView::SetNeedsEnqueueScrollEvent(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::PerformScrollAnchoringAdjustments() {}

void LocalFrameView::EnqueueScrollEvents() {}

void LocalFrameView::PaintTree(
    PaintBenchmarkMode benchmark_mode,
    std::optional<PaintController>& paint_controller) {}

cc::Layer* LocalFrameView::RootCcLayer() {}

const cc::Layer* LocalFrameView::RootCcLayer() const {}

void LocalFrameView::CreatePaintTimelineEvents() {}

void LocalFrameView::PushPaintArtifactToCompositor(bool repainted) {}

void LocalFrameView::AppendViewTransitionRequests(
    WTF::Vector<std::unique_ptr<ViewTransitionRequest>>& requests) {}

std::unique_ptr<JSONObject> LocalFrameView::CompositedLayersAsJSON(
    LayerTreeFlags flags) {}

void LocalFrameView::UpdateStyleAndLayoutIfNeededRecursive() {}

void LocalFrameView::UpdateStyleAndLayout() {}

bool LocalFrameView::UpdateStyleAndLayoutInternal() {}

void LocalFrameView::EnableAutoSizeMode(const gfx::Size& min_size,
                                        const gfx::Size& max_size) {}

void LocalFrameView::DisableAutoSizeMode() {}

void LocalFrameView::ForceLayoutForPagination(float maximum_shrink_factor) {}

void LocalFrameView::DestroyPaginationLayout() {}

gfx::Rect LocalFrameView::RootFrameToDocument(
    const gfx::Rect& rect_in_root_frame) {}

gfx::Point LocalFrameView::RootFrameToDocument(
    const gfx::Point& point_in_root_frame) {}

gfx::PointF LocalFrameView::RootFrameToDocument(
    const gfx::PointF& point_in_root_frame) {}

gfx::Rect LocalFrameView::DocumentToFrame(
    const gfx::Rect& rect_in_document) const {}

gfx::Point LocalFrameView::DocumentToFrame(
    const gfx::Point& point_in_document) const {}

gfx::PointF LocalFrameView::DocumentToFrame(
    const gfx::PointF& point_in_document) const {}

PhysicalOffset LocalFrameView::DocumentToFrame(
    const PhysicalOffset& offset_in_document) const {}

PhysicalRect LocalFrameView::DocumentToFrame(
    const PhysicalRect& rect_in_document) const {}

gfx::Point LocalFrameView::FrameToDocument(
    const gfx::Point& point_in_frame) const {}

PhysicalOffset LocalFrameView::FrameToDocument(
    const PhysicalOffset& offset_in_frame) const {}

gfx::Rect LocalFrameView::FrameToDocument(
    const gfx::Rect& rect_in_frame) const {}

PhysicalRect LocalFrameView::FrameToDocument(
    const PhysicalRect& rect_in_frame) const {}

gfx::Rect LocalFrameView::ConvertToContainingEmbeddedContentView(
    const gfx::Rect& local_rect) const {}

gfx::Rect LocalFrameView::ConvertFromContainingEmbeddedContentView(
    const gfx::Rect& parent_rect) const {}

PhysicalOffset LocalFrameView::ConvertToContainingEmbeddedContentView(
    const PhysicalOffset& local_offset) const {}

gfx::PointF LocalFrameView::ConvertToContainingEmbeddedContentView(
    const gfx::PointF& local_point) const {}

PhysicalOffset LocalFrameView::ConvertFromContainingEmbeddedContentView(
    const PhysicalOffset& parent_offset) const {}

gfx::PointF LocalFrameView::ConvertFromContainingEmbeddedContentView(
    const gfx::PointF& parent_point) const {}

void LocalFrameView::SetTracksRasterInvalidations(
    bool track_raster_invalidations) {}

void LocalFrameView::ServiceScrollAnimations(base::TimeTicks start_time) {}

void LocalFrameView::ScheduleAnimation(base::TimeDelta delay,
                                       base::Location location) {}

void LocalFrameView::OnCommitRequested() {}

void LocalFrameView::AddScrollAnchoringScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::RemoveScrollAnchoringScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::AddAnimatingScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::RemoveAnimatingScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::AddUserScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::RemoveUserScrollableArea(
    PaintLayerScrollableArea* scrollable_area) {}

void LocalFrameView::AttachToLayout() {}

void LocalFrameView::DetachFromLayout() {}

void LocalFrameView::AddPlugin(WebPluginContainerImpl* plugin) {}

void LocalFrameView::RemovePlugin(WebPluginContainerImpl* plugin) {}

void LocalFrameView::RemoveScrollbar(Scrollbar* scrollbar) {}

void LocalFrameView::AddScrollbar(Scrollbar* scrollbar) {}

bool LocalFrameView::VisualViewportSuppliesScrollbars() {}

AXObjectCache* LocalFrameView::ExistingAXObjectCache() const {}

void LocalFrameView::SetCursor(const ui::Cursor& cursor) {}

void LocalFrameView::PropagateFrameRects() {}

void LocalFrameView::ZoomFactorChanged(float zoom_factor) {}

void LocalFrameView::SetLayoutSizeInternal(const gfx::Size& size) {}

void LocalFrameView::DidChangeScrollOffset() {}

ScrollableArea* LocalFrameView::ScrollableAreaWithElementId(
    const CompositorElementId& id) {}

void LocalFrameView::ScrollRectToVisibleInRemoteParent(
    const PhysicalRect& rect_to_scroll,
    mojom::blink::ScrollIntoViewParamsPtr params) {}

void LocalFrameView::NotifyFrameRectsChangedIfNeeded() {}

PhysicalOffset LocalFrameView::ViewportToFrame(
    const PhysicalOffset& point_in_viewport) const {}

gfx::PointF LocalFrameView::ViewportToFrame(
    const gfx::PointF& point_in_viewport) const {}

gfx::Rect LocalFrameView::ViewportToFrame(
    const gfx::Rect& rect_in_viewport) const {}

gfx::Point LocalFrameView::ViewportToFrame(
    const gfx::Point& point_in_viewport) const {}

gfx::Rect LocalFrameView::FrameToViewport(
    const gfx::Rect& rect_in_frame) const {}

gfx::Point LocalFrameView::FrameToViewport(
    const gfx::Point& point_in_frame) const {}

gfx::PointF LocalFrameView::FrameToViewport(
    const gfx::PointF& point_in_frame) const {}

gfx::Rect LocalFrameView::FrameToScreen(const gfx::Rect& rect) const {}

gfx::Point LocalFrameView::SoonToBeRemovedUnscaledViewportToContents(
    const gfx::Point& point_in_viewport) const {}

LocalFrameView::AllowThrottlingScope::AllowThrottlingScope(
    const LocalFrameView& frame_view)
    :{}

LocalFrameView::DisallowThrottlingScope::DisallowThrottlingScope(
    const LocalFrameView& frame_view)
    :{}

LocalFrameView::ForceThrottlingScope::ForceThrottlingScope(
    const LocalFrameView& frame_view)
    :{}

PaintControllerPersistentData&
LocalFrameView::EnsurePaintControllerPersistentData() {}

bool LocalFrameView::CapturePaintPreview(
    GraphicsContext& context,
    const gfx::Vector2d& paint_offset) const {}

void LocalFrameView::Paint(GraphicsContext& context,
                           PaintFlags paint_flags,
                           const CullRect& cull_rect,
                           const gfx::Vector2d& paint_offset) const {}

void LocalFrameView::PaintFrame(GraphicsContext& context,
                                PaintFlags paint_flags) const {}

void LocalFrameView::PrintPage(GraphicsContext& context,
                               wtf_size_t page_index,
                               const CullRect& cull_rect) {}

static bool PaintOutsideOfLifecycleIsAllowed(GraphicsContext& context,
                                             const LocalFrameView& frame_view) {}

void LocalFrameView::PaintOutsideOfLifecycle(GraphicsContext& context,
                                             const PaintFlags paint_flags,
                                             const CullRect& cull_rect) {}

void LocalFrameView::PaintOutsideOfLifecycleWithThrottlingAllowed(
    GraphicsContext& context,
    const PaintFlags paint_flags,
    const CullRect& cull_rect) {}

void LocalFrameView::PaintForTest(const CullRect& cull_rect) {}

PaintRecord LocalFrameView::GetPaintRecord(const gfx::Rect* cull_rect) const {}

const PaintArtifact& LocalFrameView::GetPaintArtifact() const {}

gfx::Rect LocalFrameView::ConvertToRootFrame(
    const gfx::Rect& local_rect) const {}

gfx::Point LocalFrameView::ConvertToRootFrame(
    const gfx::Point& local_point) const {}

PhysicalOffset LocalFrameView::ConvertToRootFrame(
    const PhysicalOffset& local_offset) const {}

gfx::PointF LocalFrameView::ConvertToRootFrame(
    const gfx::PointF& local_point) const {}

PhysicalRect LocalFrameView::ConvertToRootFrame(
    const PhysicalRect& local_rect) const {}

gfx::Rect LocalFrameView::ConvertFromRootFrame(
    const gfx::Rect& rect_in_root_frame) const {}

gfx::Point LocalFrameView::ConvertFromRootFrame(
    const gfx::Point& point_in_root_frame) const {}

PhysicalOffset LocalFrameView::ConvertFromRootFrame(
    const PhysicalOffset& offset_in_root_frame) const {}

gfx::PointF LocalFrameView::ConvertFromRootFrame(
    const gfx::PointF& point_in_root_frame) const {}

void LocalFrameView::ParentVisibleChanged() {}

void LocalFrameView::SelfVisibleChanged() {}

void LocalFrameView::Show() {}

void LocalFrameView::Hide() {}

int LocalFrameView::ViewportWidth() const {}

int LocalFrameView::ViewportHeight() const {}

ScrollableArea* LocalFrameView::GetScrollableArea() {}

PaintLayerScrollableArea* LocalFrameView::LayoutViewport() const {}

RootFrameViewport* LocalFrameView::GetRootFrameViewport() {}

void LocalFrameView::CollectDraggableRegions(
    LayoutObject& layout_object,
    Vector<DraggableRegionValue>& regions) const {}

bool LocalFrameView::UpdateViewportIntersectionsForSubtree(
    unsigned parent_flags,
    ComputeIntersectionsContext& context) {}

void LocalFrameView::DeliverSynchronousIntersectionObservations() {}

void LocalFrameView::CrossOriginToNearestMainFrameChanged() {}

void LocalFrameView::CrossOriginToParentFrameChanged() {}

void LocalFrameView::SetViewportIntersection(
    const mojom::blink::ViewportIntersectionState& intersection_state) {}

void LocalFrameView::VisibilityForThrottlingChanged() {}

void LocalFrameView::VisibilityChanged(
    blink::mojom::FrameVisibility visibility) {}

void LocalFrameView::RenderThrottlingStatusChanged() {}

void LocalFrameView::SetIntersectionObservationState(
    IntersectionObservationState state) {}

void LocalFrameView::UpdateIntersectionObservationStateOnScroll(
    gfx::Vector2dF scroll_delta) {}

void LocalFrameView::SetVisualViewportOrOverlayNeedsRepaint() {}

bool LocalFrameView::VisualViewportOrOverlayNeedsRepaintForTesting() const {}

void LocalFrameView::SetPaintArtifactCompositorNeedsUpdate() {}

PaintArtifactCompositor* LocalFrameView::GetPaintArtifactCompositor() const {}

unsigned LocalFrameView::GetIntersectionObservationFlags(
    unsigned parent_flags) const {}

bool LocalFrameView::ShouldThrottleRendering() const {}

bool LocalFrameView::ShouldThrottleRenderingForTest() const {}

bool LocalFrameView::CanThrottleRendering() const {}

void LocalFrameView::UpdateRenderThrottlingStatus(bool hidden_for_throttling,
                                                  bool subtree_throttled,
                                                  bool display_locked,
                                                  bool recurse) {}

void LocalFrameView::SetThrottledForViewTransition(bool throttled) {}

void LocalFrameView::BeginLifecycleUpdates() {}

bool LocalFrameView::WillDoPaintHoldingForFCP() const {}

String LocalFrameView::MainThreadScrollingReasonsAsText() {}

bool LocalFrameView::MapToVisualRectInRemoteRootFrame(
    PhysicalRect& rect,
    bool apply_overflow_clip) {}

void LocalFrameView::MapLocalToRemoteMainFrame(
    TransformState& transform_state) {}

LayoutUnit LocalFrameView::CaretWidth() const {}

void LocalFrameView::RegisterTapEvent(Element* target) {}

LocalFrameUkmAggregator* LocalFrameView::GetUkmAggregator() {}

void LocalFrameView::ResetUkmAggregatorForTesting() {}

void LocalFrameView::OnFirstContentfulPaint() {}

void LocalFrameView::RegisterForLifecycleNotifications(
    LifecycleNotificationObserver* observer) {}

void LocalFrameView::UnregisterFromLifecycleNotifications(
    LifecycleNotificationObserver* observer) {}

void LocalFrameView::EnqueueStartOfLifecycleTask(base::OnceClosure closure) {}

void LocalFrameView::NotifyVideoIsDominantVisibleStatus(
    HTMLVideoElement* element,
    bool is_dominant) {}

bool LocalFrameView::HasDominantVideoElement() const {}

#if DCHECK_IS_ON()
LocalFrameView::DisallowLayoutInvalidationScope::
    DisallowLayoutInvalidationScope(LocalFrameView* view)
    :{}

LocalFrameView::DisallowLayoutInvalidationScope::
    ~DisallowLayoutInvalidationScope() {}

#endif

bool LocalFrameView::UpdatePaintDebugInfoEnabled() {}

OverlayInterstitialAdDetector&
LocalFrameView::EnsureOverlayInterstitialAdDetector() {}

StickyAdDetector& LocalFrameView::EnsureStickyAdDetector() {}

static PaintLayer* GetXrOverlayLayer(Document& document) {}

PaintLayer* LocalFrameView::GetXROverlayLayer() const {}

void LocalFrameView::SetCullRectNeedsUpdateForFrames(bool disable_expansion) {}

void LocalFrameView::RunPaintBenchmark(int repeat_count,
                                       cc::PaintBenchmarkResult& result) {}

DarkModeFilter& LocalFrameView::EnsureDarkModeFilter() {}

void LocalFrameView::AddPendingTransformUpdate(LayoutObject& object) {}

bool LocalFrameView::RemovePendingTransformUpdate(const LayoutObject& object) {}

void LocalFrameView::AddPendingOpacityUpdate(LayoutObject& object) {}

bool LocalFrameView::RemovePendingOpacityUpdate(const LayoutObject& object) {}

bool LocalFrameView::ExecuteAllPendingUpdates() {}

void LocalFrameView::RemoveAllPendingUpdates() {}

void LocalFrameView::AddPendingStickyUpdate(PaintLayerScrollableArea* object) {}

bool LocalFrameView::HasPendingStickyUpdate(
    PaintLayerScrollableArea* object) const {}

void LocalFrameView::ExecutePendingStickyUpdates() {}

void LocalFrameView::AddPendingSnapUpdate(PaintLayerScrollableArea* object) {}

void LocalFrameView::RemovePendingSnapUpdate(PaintLayerScrollableArea* object) {}

void LocalFrameView::ExecutePendingSnapUpdates() {}

void LocalFrameView::NotifyElementWithRememberedSizeDisconnected(
    Element* element) {}

bool LocalFrameView::UpdateLastSuccessfulPositionFallbacks() {}

}  // namespace blink