chromium/third_party/blink/renderer/core/paint/paint_layer_scrollable_area.cc

/*
 * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
 * reserved.
 *
 * Portions are Copyright (C) 1998 Netscape Communications Corporation.
 *
 * Other contributors:
 *   Robert O'Callahan <[email protected]>
 *   David Baron <[email protected]>
 *   Christian Biesinger <[email protected]>
 *   Randall Jesup <[email protected]>
 *   Roland Mainz <[email protected]>
 *   Josh Soref <[email protected]>
 *   Boris Zbarsky <[email protected]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 *
 * Alternatively, the contents of this file may be used under the terms
 * of either the Mozilla Public License Version 1.1, found at
 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
 * (the "GPL"), in which case the provisions of the MPL or the GPL are
 * applicable instead of those above.  If you wish to allow use of your
 * version of this file only under the terms of one of those two
 * licenses (the MPL or the GPL) and not to allow others to use your
 * version of this file under the LGPL, indicate your decision by
 * deletingthe provisions above and replace them with the notice and
 * other provisions required by the MPL or the GPL, as the case may be.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under any of the LGPL, the MPL or the GPL.
 */

#include "third_party/blink/renderer/core/paint/paint_layer_scrollable_area.h"

#include <utility>

#include "base/numerics/checked_math.h"
#include "base/task/single_thread_task_runner.h"
#include "cc/animation/animation_timeline.h"
#include "cc/input/main_thread_scrolling_reason.h"
#include "cc/input/snap_selection_strategy.h"
#include "cc/layers/picture_layer.h"
#include "third_party/blink/public/common/features.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/platform.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/renderer/core/accessibility/ax_object_cache.h"
#include "third_party/blink/renderer/core/animation/scroll_timeline.h"
#include "third_party/blink/renderer/core/content_capture/content_capture_manager.h"
#include "third_party/blink/renderer/core/css/color_scheme_flags.h"
#include "third_party/blink/renderer/core/css/container_query_evaluator.h"
#include "third_party/blink/renderer/core/css/snapped_query_scroll_snapshot.h"
#include "third_party/blink/renderer/core/css/style_request.h"
#include "third_party/blink/renderer/core/dom/dom_node_ids.h"
#include "third_party/blink/renderer/core/dom/node.h"
#include "third_party/blink/renderer/core/dom/node_computed_style.h"
#include "third_party/blink/renderer/core/dom/shadow_root.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/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/local_frame_client.h"
#include "third_party/blink/renderer/core/frame/local_frame_view.h"
#include "third_party/blink/renderer/core/frame/page_scale_constraints_set.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/fullscreen/fullscreen.h"
#include "third_party/blink/renderer/core/html/forms/html_input_element.h"
#include "third_party/blink/renderer/core/html/forms/html_select_element.h"
#include "third_party/blink/renderer/core/html/forms/text_control_element.h"
#include "third_party/blink/renderer/core/html/html_frame_owner_element.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/layout/custom_scrollbar.h"
#include "third_party/blink/renderer/core/layout/layout_custom_scrollbar_part.h"
#include "third_party/blink/renderer/core/layout/layout_embedded_content.h"
#include "third_party/blink/renderer/core/layout/layout_theme.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/physical_box_fragment.h"
#include "third_party/blink/renderer/core/loader/document_loader.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/page.h"
#include "third_party/blink/renderer/core/page/scrolling/fragment_anchor.h"
#include "third_party/blink/renderer/core/page/scrolling/root_scroller_controller.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/sticky_position_scrolling_constraints.h"
#include "third_party/blink/renderer/core/page/scrolling/top_document_root_scroller_controller.h"
#include "third_party/blink/renderer/core/paint/compositing/compositing_reason_finder.h"
#include "third_party/blink/renderer/core/paint/object_paint_invalidator.h"
#include "third_party/blink/renderer/core/paint/paint_invalidator.h"
#include "third_party/blink/renderer/core/paint/paint_layer.h"
#include "third_party/blink/renderer/core/paint/paint_layer_fragment.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/scroll_into_view_util.h"
#include "third_party/blink/renderer/core/scroll/scrollable_area.h"
#include "third_party/blink/renderer/core/scroll/scrollbar_theme.h"
#include "third_party/blink/renderer/core/scroll/smooth_scroll_sequencer.h"
#include "third_party/blink/renderer/core/view_transition/view_transition.h"
#include "third_party/blink/renderer/core/view_transition/view_transition_utils.h"
#include "third_party/blink/renderer/platform/graphics/paint/drawing_recorder.h"
#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
#include "third_party/blink/renderer/platform/runtime_enabled_features.h"
#include "ui/base/ui_base_features.h"
#include "ui/gfx/geometry/point_conversions.h"

namespace blink {

PaintLayerScrollableAreaRareData::PaintLayerScrollableAreaRareData() = default;

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

const int kResizerControlExpandRatioForTouch =;

PaintLayerScrollableArea::PaintLayerScrollableArea(PaintLayer& layer)
    :{}

PaintLayerScrollableArea::~PaintLayerScrollableArea() {}

PaintLayerScrollableArea* PaintLayerScrollableArea::FromNode(const Node& node) {}

void PaintLayerScrollableArea::DidCompositorScroll(
    const gfx::PointF& position) {}

void PaintLayerScrollableArea::DisposeImpl() {}

void PaintLayerScrollableArea::ApplyPendingHistoryRestoreScrollOffset() {}

void PaintLayerScrollableArea::SetTickmarksOverride(
    Vector<gfx::Rect> tickmarks) {}

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

bool PaintLayerScrollableArea::IsThrottled() const {}

ChromeClient* PaintLayerScrollableArea::GetChromeClient() const {}

SmoothScrollSequencer* PaintLayerScrollableArea::GetSmoothScrollSequencer()
    const {}

bool PaintLayerScrollableArea::IsActive() const {}

bool PaintLayerScrollableArea::IsScrollCornerVisible() const {}

static int CornerStart(const LayoutBox& box,
                       int min_x,
                       int max_x,
                       int thickness) {}

gfx::Rect PaintLayerScrollableArea::CornerRect() const {}

gfx::Rect PaintLayerScrollableArea::ScrollCornerRect() const {}

void PaintLayerScrollableArea::SetScrollCornerNeedsPaintInvalidation() {}

gfx::Rect
PaintLayerScrollableArea::ConvertFromScrollbarToContainingEmbeddedContentView(
    const Scrollbar& scrollbar,
    const gfx::Rect& scrollbar_rect) const {}

gfx::Point
PaintLayerScrollableArea::ConvertFromScrollbarToContainingEmbeddedContentView(
    const Scrollbar& scrollbar,
    const gfx::Point& scrollbar_point) const {}

gfx::Point
PaintLayerScrollableArea::ConvertFromContainingEmbeddedContentViewToScrollbar(
    const Scrollbar& scrollbar,
    const gfx::Point& parent_point) const {}

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

gfx::Point PaintLayerScrollableArea::ConvertFromRootFrameToVisualViewport(
    const gfx::Point& point_in_root_frame) const {}

int PaintLayerScrollableArea::ScrollSize(
    ScrollbarOrientation orientation) const {}

void PaintLayerScrollableArea::UpdateScrollOffset(
    const ScrollOffset& new_offset,
    mojom::blink::ScrollType scroll_type) {}

void PaintLayerScrollableArea::InvalidatePaintForScrollOffsetChange() {}

// See the comment in .h about background-attachment:fixed.
bool PaintLayerScrollableArea::BackgroundNeedsRepaintOnScroll() const {}

gfx::Vector2d PaintLayerScrollableArea::ScrollOffsetInt() const {}

ScrollOffset PaintLayerScrollableArea::GetScrollOffset() const {}

void PaintLayerScrollableArea::EnqueueScrollEventIfNeeded() {}

gfx::Vector2d PaintLayerScrollableArea::MinimumScrollOffsetInt() const {}

gfx::Vector2d PaintLayerScrollableArea::MaximumScrollOffsetInt() const {}

void PaintLayerScrollableArea::VisibleSizeChanged() {}

PhysicalRect PaintLayerScrollableArea::LayoutContentRect(
    IncludeScrollbarsInRect scrollbar_inclusion) const {}

gfx::Rect PaintLayerScrollableArea::VisibleContentRect(
    IncludeScrollbarsInRect scrollbar_inclusion) const {}

PhysicalRect PaintLayerScrollableArea::VisibleScrollSnapportRect(
    IncludeScrollbarsInRect scrollbar_inclusion) const {}

gfx::Size PaintLayerScrollableArea::ContentsSize() const {}

gfx::Size PaintLayerScrollableArea::PixelSnappedContentsSize(
    const PhysicalOffset& paint_offset) const {}

void PaintLayerScrollableArea::ContentsResized() {}

gfx::Point PaintLayerScrollableArea::LastKnownMousePosition() const {}

bool PaintLayerScrollableArea::ScrollAnimatorEnabled() const {}

bool PaintLayerScrollableArea::ShouldSuspendScrollAnimations() const {}

void PaintLayerScrollableArea::ScrollbarVisibilityChanged() {}

void PaintLayerScrollableArea::ScrollbarFrameRectChanged() {}

bool PaintLayerScrollableArea::ScrollbarsCanBeActive() const {}

void PaintLayerScrollableArea::RegisterForAnimation() {}

void PaintLayerScrollableArea::DeregisterForAnimation() {}

bool PaintLayerScrollableArea::UserInputScrollable(
    ScrollbarOrientation orientation) const {}

bool PaintLayerScrollableArea::ShouldPlaceVerticalScrollbarOnLeft() const {}

int PaintLayerScrollableArea::PageStep(ScrollbarOrientation orientation) const {}

bool PaintLayerScrollableArea::IsRootFrameLayoutViewport() const {}

LayoutBox* PaintLayerScrollableArea::GetLayoutBox() const {}

PaintLayer* PaintLayerScrollableArea::Layer() const {}

PhysicalSize PaintLayerScrollableArea::Size() const {}

LayoutUnit PaintLayerScrollableArea::ScrollWidth() const {}

LayoutUnit PaintLayerScrollableArea::ScrollHeight() const {}

void PaintLayerScrollableArea::UpdateScrollOrigin() {}

void PaintLayerScrollableArea::UpdateScrollDimensions() {}

void PaintLayerScrollableArea::UpdateScrollbarEnabledState(
    bool is_horizontal_scrollbar_frozen,
    bool is_vertical_scrollbar_frozen) {}

void PaintLayerScrollableArea::UpdateScrollbarProportions() {}

void PaintLayerScrollableArea::SetScrollOffsetUnconditionally(
    const ScrollOffset& offset,
    mojom::blink::ScrollType scroll_type) {}

void PaintLayerScrollableArea::UpdateAfterLayout() {}

Element* PaintLayerScrollableArea::GetElementForScrollStart() const {}

void PaintLayerScrollableArea::SetShouldCheckForPaintInvalidation() {}

bool PaintLayerScrollableArea::IsApplyingScrollStart() const {}

void PaintLayerScrollableArea::StopApplyingScrollStart() {}

void PaintLayerScrollableArea::DelayableClampScrollOffsetAfterOverflowChange() {}

void PaintLayerScrollableArea::ClampScrollOffsetAfterOverflowChange() {}

void PaintLayerScrollableArea::ClampScrollOffsetAfterOverflowChangeInternal() {}

void PaintLayerScrollableArea::DidChangeGlobalRootScroller() {}

bool PaintLayerScrollableArea::ShouldPerformScrollAnchoring() const {}

bool PaintLayerScrollableArea::RestoreScrollAnchor(
    const SerializedAnchor& serialized_anchor) {}

gfx::QuadF PaintLayerScrollableArea::LocalToVisibleContentQuad(
    const gfx::QuadF& quad,
    const LayoutObject* local_object,
    MapCoordinatesFlags flags) const {}

scoped_refptr<base::SingleThreadTaskRunner>
PaintLayerScrollableArea::GetTimerTaskRunner() const {}

mojom::blink::ScrollBehavior PaintLayerScrollableArea::ScrollBehaviorStyle()
    const {}

mojom::blink::ColorScheme PaintLayerScrollableArea::UsedColorSchemeScrollbars()
    const {}

bool PaintLayerScrollableArea::UsedColorSchemeScrollbarsChanged(
    const ComputedStyle* old_style) const {}

bool PaintLayerScrollableArea::IsGlobalRootNonOverlayScroller() const {}

bool PaintLayerScrollableArea::HasHorizontalOverflow() const {}

bool PaintLayerScrollableArea::HasVerticalOverflow() const {}

// This function returns true if the given box requires overflow scrollbars (as
// opposed to the viewport scrollbars managed by VisualViewport).
static bool CanHaveOverflowScrollbars(const LayoutBox& box) {}

void PaintLayerScrollableArea::UpdateAfterStyleChange(
    const ComputedStyle* old_style) {}

void PaintLayerScrollableArea::UpdateAfterOverflowRecalc() {}

gfx::Rect PaintLayerScrollableArea::RectForHorizontalScrollbar() const {}

gfx::Rect PaintLayerScrollableArea::RectForVerticalScrollbar() const {}

int PaintLayerScrollableArea::VerticalScrollbarStart() const {}

int PaintLayerScrollableArea::HorizontalScrollbarStart() const {}

gfx::Vector2d PaintLayerScrollableArea::ScrollbarOffset(
    const Scrollbar& scrollbar) const {}

static inline const LayoutObject& ScrollbarStyleSource(
    const LayoutBox& layout_box) {}

int PaintLayerScrollableArea::HypotheticalScrollbarThickness(
    ScrollbarOrientation orientation,
    bool should_include_overlay_thickness) const {}

// Hypothetical scrollbar thickness is computed and cached during layout, but
// only as needed to avoid a performance penalty. It is needed for every
// LayoutView, to support frame view auto-sizing; and it's needed whenever CSS
// scrollbar-gutter requires it.
bool PaintLayerScrollableArea::NeedsHypotheticalScrollbarThickness(
    ScrollbarOrientation orientation) const {}

int PaintLayerScrollableArea::ComputeHypotheticalScrollbarThickness(
    ScrollbarOrientation orientation,
    bool should_include_overlay_thickness) const {}

bool PaintLayerScrollableArea::NeedsScrollbarReconstruction() const {}

void PaintLayerScrollableArea::ComputeScrollbarExistence(
    bool& needs_horizontal_scrollbar,
    bool& needs_vertical_scrollbar,
    ComputeScrollbarExistenceOption option) const {}

bool PaintLayerScrollableArea::TryRemovingAutoScrollbars(
    const bool& needs_horizontal_scrollbar,
    const bool& needs_vertical_scrollbar) {}

void PaintLayerScrollableArea::RemoveScrollbarsForReconstruction() {}

CompositorElementId PaintLayerScrollableArea::GetScrollCornerElementId() const {}

void PaintLayerScrollableArea::SetHasHorizontalScrollbar(bool has_scrollbar) {}

void PaintLayerScrollableArea::SetHasVerticalScrollbar(bool has_scrollbar) {}

int PaintLayerScrollableArea::VerticalScrollbarWidth(
    OverlayScrollbarClipBehavior overlay_scrollbar_clip_behavior) const {}

int PaintLayerScrollableArea::HorizontalScrollbarHeight(
    OverlayScrollbarClipBehavior overlay_scrollbar_clip_behavior) const {}

const cc::SnapContainerData* PaintLayerScrollableArea::GetSnapContainerData()
    const {}

void PaintLayerScrollableArea::SetSnapContainerData(
    std::optional<cc::SnapContainerData> data) {}

bool PaintLayerScrollableArea::SetTargetSnapAreaElementIds(
    cc::TargetSnapAreaElementIds snap_target_ids) {}

void PaintLayerScrollableArea::UpdateFocusDataForSnapAreas() {}

std::optional<cc::TargetSnapAreaElementIds>
PaintLayerScrollableArea::GetScrollsnapchangingTargetIds() const {}

const cc::SnapSelectionStrategy* PaintLayerScrollableArea::GetImplSnapStrategy()
    const {}

void PaintLayerScrollableArea::SetImplSnapStrategy(
    std::unique_ptr<cc::SnapSelectionStrategy> strategy) {}

std::optional<gfx::PointF>
PaintLayerScrollableArea::GetSnapPositionAndSetTarget(
    const cc::SnapSelectionStrategy& strategy) {}

bool PaintLayerScrollableArea::HasOverflowControls() const {}

bool PaintLayerScrollableArea::HasOverlayOverflowControls() const {}

bool PaintLayerScrollableArea::NeedsScrollCorner() const {}

bool PaintLayerScrollableArea::ShouldOverflowControlsPaintAsOverlay() const {}

void PaintLayerScrollableArea::PositionOverflowControls() {}

void PaintLayerScrollableArea::UpdateScrollCornerStyle() {}

bool PaintLayerScrollableArea::HitTestOverflowControls(
    HitTestResult& result,
    const gfx::Point& local_point) {}

gfx::Rect PaintLayerScrollableArea::ResizerCornerRect(
    ResizerHitTestType resizer_hit_test_type) const {}

gfx::Rect PaintLayerScrollableArea::ScrollCornerAndResizerRect() const {}

bool PaintLayerScrollableArea::IsAbsolutePointInResizeControl(
    const gfx::Point& absolute_point,
    ResizerHitTestType resizer_hit_test_type) const {}

bool PaintLayerScrollableArea::IsLocalPointInResizeControl(
    const gfx::Point& local_point,
    ResizerHitTestType resizer_hit_test_type) const {}

void PaintLayerScrollableArea::UpdateResizerStyle(
    const ComputedStyle* old_style) {}

void PaintLayerScrollableArea::EnqueueForSnapUpdateIfNeeded() {}

void PaintLayerScrollableArea::UpdateAllStickyConstraints() {}

void PaintLayerScrollableArea::EnqueueForStickyUpdateIfNeeded() {}

void PaintLayerScrollableArea::InvalidatePaintForStickyDescendants() {}

gfx::Vector2d PaintLayerScrollableArea::OffsetFromResizeCorner(
    const gfx::Point& absolute_point) const {}

void PaintLayerScrollableArea::Resize(const gfx::Point& pos,
                                      const gfx::Vector2d& old_offset) {}

PhysicalOffset PaintLayerScrollableArea::LocalToScrollOriginOffset() const {}

PhysicalRect PaintLayerScrollableArea::ScrollIntoView(
    const PhysicalRect& absolute_rect,
    const PhysicalBoxStrut& scroll_margin,
    const mojom::blink::ScrollIntoViewParamsPtr& params) {}

void PaintLayerScrollableArea::UpdateScrollableAreaSet() {}

ScrollingCoordinator* PaintLayerScrollableArea::GetScrollingCoordinator()
    const {}

bool PaintLayerScrollableArea::ShouldScrollOnMainThread() const {}

bool PaintLayerScrollableArea::PrefersNonCompositedScrolling() const {}

bool PaintLayerScrollableArea::UsesCompositedScrolling() const {}

bool PaintLayerScrollableArea::VisualViewportSuppliesScrollbars() const {}

bool PaintLayerScrollableArea::ScheduleAnimation() {}

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

cc::AnimationTimeline*
PaintLayerScrollableArea::GetCompositorAnimationTimeline() const {}

bool PaintLayerScrollableArea::HasTickmarks() const {}

Vector<gfx::Rect> PaintLayerScrollableArea::GetTickmarks() const {}

void PaintLayerScrollableArea::ScrollbarManager::SetHasHorizontalScrollbar(
    bool has_scrollbar) {}

void PaintLayerScrollableArea::ScrollbarManager::SetHasVerticalScrollbar(
    bool has_scrollbar) {}

Scrollbar* PaintLayerScrollableArea::ScrollbarManager::CreateScrollbar(
    ScrollbarOrientation orientation) {}

void PaintLayerScrollableArea::ScrollbarManager::DestroyScrollbar(
    ScrollbarOrientation orientation) {}

void PaintLayerScrollableArea::ScrollbarManager::DestroyDetachedScrollbars() {}

void PaintLayerScrollableArea::ScrollbarManager::Dispose() {}

void PaintLayerScrollableArea::ScrollbarManager::Trace(
    blink::Visitor* visitor) const {}

int PaintLayerScrollableArea::FreezeScrollbarsScope::count_ =;

PaintLayerScrollableArea::FreezeScrollbarsRootScope::FreezeScrollbarsRootScope(
    const LayoutBox& box,
    bool freeze_horizontal,
    bool freeze_vertical)
    :{}

PaintLayerScrollableArea::FreezeScrollbarsRootScope::
    ~FreezeScrollbarsRootScope() {}

int PaintLayerScrollableArea::DelayScrollOffsetClampScope::count_ =;

PaintLayerScrollableArea::DelayScrollOffsetClampScope::
    DelayScrollOffsetClampScope() {}

PaintLayerScrollableArea::DelayScrollOffsetClampScope::
    ~DelayScrollOffsetClampScope() {}

void PaintLayerScrollableArea::DelayScrollOffsetClampScope::SetNeedsClamp(
    PaintLayerScrollableArea* scrollable_area) {}

void PaintLayerScrollableArea::DelayScrollOffsetClampScope::
    ClampScrollableAreas() {}

HeapVector<Member<PaintLayerScrollableArea>>&
PaintLayerScrollableArea::DelayScrollOffsetClampScope::NeedsClampList() {}

ScrollbarTheme& PaintLayerScrollableArea::GetPageScrollbarTheme() const {}

void PaintLayerScrollableArea::DidAddScrollbar(
    Scrollbar& scrollbar,
    ScrollbarOrientation orientation) {}

void PaintLayerScrollableArea::WillRemoveScrollbar(
    Scrollbar& scrollbar,
    ScrollbarOrientation orientation) {}

// Returns true if the scroll control is invalidated.
static bool ScrollControlNeedsPaintInvalidation(
    const gfx::Rect& new_visual_rect,
    const gfx::Rect& previous_visual_rect,
    bool needs_paint_invalidation) {}

bool PaintLayerScrollableArea::MayCompositeScrollbar(
    const Scrollbar& scrollbar) const {}

void PaintLayerScrollableArea::EstablishScrollbarRoot(bool freeze_horizontal,
                                                      bool freeze_vertical) {}

void PaintLayerScrollableArea::ClearScrollbarRoot() {}

void PaintLayerScrollableArea::InvalidatePaintOfScrollbarIfNeeded(
    const PaintInvalidatorContext& context,
    bool needs_paint_invalidation,
    Scrollbar* scrollbar,
    bool& previously_was_overlay,
    bool& previously_might_be_composited,
    gfx::Rect& visual_rect) {}

void PaintLayerScrollableArea::InvalidatePaintOfScrollControlsIfNeeded(
    const PaintInvalidatorContext& context) {}

void PaintLayerScrollableArea::ScrollControlWasSetNeedsPaintInvalidation() {}

void PaintLayerScrollableArea::DidScrollWithScrollbar(
    ScrollbarPart part,
    ScrollbarOrientation orientation,
    WebInputEvent::Type type) {}

CompositorElementId PaintLayerScrollableArea::GetScrollElementId() const {}

gfx::Size PaintLayerScrollableArea::PixelSnappedBorderBoxSize() const {}

void PaintLayerScrollableArea::DropCompositorScrollDeltaNextCommit() {}

gfx::Rect PaintLayerScrollableArea::ScrollingBackgroundVisualRect(
    const PhysicalOffset& paint_offset) const {}

String
PaintLayerScrollableArea::ScrollingBackgroundDisplayItemClient::DebugName()
    const {}

DOMNodeId
PaintLayerScrollableArea::ScrollingBackgroundDisplayItemClient::OwnerNodeId()
    const {}

String PaintLayerScrollableArea::ScrollCornerDisplayItemClient::DebugName()
    const {}

DOMNodeId PaintLayerScrollableArea::ScrollCornerDisplayItemClient::OwnerNodeId()
    const {}

void PaintLayerScrollableArea::
    UpdateSnappedTargetsAndEnqueueScrollSnapChange() {}

void PaintLayerScrollableArea::SetScrollsnapchangingTargetIds(
    std::optional<cc::TargetSnapAreaElementIds> ids) {}

void PaintLayerScrollableArea::
    UpdateScrollSnapChangingTargetsAndEnqueueScrollSnapChanging(
        const cc::TargetSnapAreaElementIds& new_target_ids) {}

void PaintLayerScrollableArea::
    EnqueueScrollSnapChangingEventFromImplIfNeeded() {}

Node* PaintLayerScrollableArea::GetSnapTargetAlongAxis(
    cc::TargetSnapAreaElementIds ids,
    cc::SnapAxis axis) const {}

Node* PaintLayerScrollableArea::GetSnapEventTargetAlongAxis(
    const AtomicString& event_type,
    cc::SnapAxis axis) const {}

Element* PaintLayerScrollableArea::GetSnappedQueryTargetAlongAxis(
    cc::SnapAxis axis) const {}

void PaintLayerScrollableArea::SetScrollsnapchangeTargetIds(
    std::optional<cc::TargetSnapAreaElementIds> ids) {}

SnappedQueryScrollSnapshot&
PaintLayerScrollableArea::EnsureSnappedQueryScrollSnapshot() {}

void PaintLayerScrollableArea::CreateAndSetSnappedQueryScrollSnapshotIfNeeded(
    cc::TargetSnapAreaElementIds ids) {}

}  // namespace blink