chromium/third_party/blink/renderer/core/css/properties/computed_style_utils.cc

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "third_party/blink/renderer/core/css/properties/computed_style_utils.h"

#include "base/memory/values_equivalent.h"
#include "third_party/blink/renderer/core/css/basic_shape_functions.h"
#include "third_party/blink/renderer/core/css/css_alternate_value.h"
#include "third_party/blink/renderer/core/css/css_border_image.h"
#include "third_party/blink/renderer/core/css/css_border_image_slice_value.h"
#include "third_party/blink/renderer/core/css/css_bracketed_value_list.h"
#include "third_party/blink/renderer/core/css/css_color.h"
#include "third_party/blink/renderer/core/css/css_color_mix_value.h"
#include "third_party/blink/renderer/core/css/css_content_distribution_value.h"
#include "third_party/blink/renderer/core/css/css_counter_value.h"
#include "third_party/blink/renderer/core/css/css_custom_ident_value.h"
#include "third_party/blink/renderer/core/css/css_font_family_value.h"
#include "third_party/blink/renderer/core/css/css_font_feature_value.h"
#include "third_party/blink/renderer/core/css/css_font_style_range_value.h"
#include "third_party/blink/renderer/core/css/css_font_variation_value.h"
#include "third_party/blink/renderer/core/css/css_function_value.h"
#include "third_party/blink/renderer/core/css/css_grid_auto_repeat_value.h"
#include "third_party/blink/renderer/core/css/css_grid_integer_repeat_value.h"
#include "third_party/blink/renderer/core/css/css_grid_template_areas_value.h"
#include "third_party/blink/renderer/core/css/css_initial_value.h"
#include "third_party/blink/renderer/core/css/css_math_function_value.h"
#include "third_party/blink/renderer/core/css/css_numeric_literal_value.h"
#include "third_party/blink/renderer/core/css/css_primitive_value_mappings.h"
#include "third_party/blink/renderer/core/css/css_quad_value.h"
#include "third_party/blink/renderer/core/css/css_reflect_value.h"
#include "third_party/blink/renderer/core/css/css_scroll_value.h"
#include "third_party/blink/renderer/core/css/css_shadow_value.h"
#include "third_party/blink/renderer/core/css/css_string_value.h"
#include "third_party/blink/renderer/core/css/css_timing_function_value.h"
#include "third_party/blink/renderer/core/css/css_uri_value.h"
#include "third_party/blink/renderer/core/css/css_value.h"
#include "third_party/blink/renderer/core/css/css_value_list.h"
#include "third_party/blink/renderer/core/css/css_value_pair.h"
#include "third_party/blink/renderer/core/css/css_view_value.h"
#include "third_party/blink/renderer/core/css/cssom/cross_thread_color_value.h"
#include "third_party/blink/renderer/core/css/cssom/cross_thread_keyword_value.h"
#include "third_party/blink/renderer/core/css/cssom/cross_thread_unit_value.h"
#include "third_party/blink/renderer/core/css/cssom/cross_thread_unparsed_value.h"
#include "third_party/blink/renderer/core/css/cssom/cross_thread_unsupported_value.h"
#include "third_party/blink/renderer/core/css/cssom/css_keyword_value.h"
#include "third_party/blink/renderer/core/css/cssom/css_unit_value.h"
#include "third_party/blink/renderer/core/css/cssom/css_unparsed_value.h"
#include "third_party/blink/renderer/core/css/cssom/css_unsupported_color.h"
#include "third_party/blink/renderer/core/css/cssom_utils.h"
#include "third_party/blink/renderer/core/css/properties/css_parsing_utils.h"
#include "third_party/blink/renderer/core/css/properties/longhands.h"
#include "third_party/blink/renderer/core/css/properties/shorthands.h"
#include "third_party/blink/renderer/core/css/style_color.h"
#include "third_party/blink/renderer/core/frame/web_feature.h"
#include "third_party/blink/renderer/core/layout/grid/layout_grid.h"
#include "third_party/blink/renderer/core/layout/layout_block.h"
#include "third_party/blink/renderer/core/layout/layout_box.h"
#include "third_party/blink/renderer/core/layout/svg/transform_helper.h"
#include "third_party/blink/renderer/core/style/computed_style_constants.h"
#include "third_party/blink/renderer/core/style/position_area.h"
#include "third_party/blink/renderer/core/style/style_intrinsic_length.h"
#include "third_party/blink/renderer/core/style/style_svg_resource.h"
#include "third_party/blink/renderer/core/style_property_shorthand.h"
#include "third_party/blink/renderer/core/svg/svg_rect_element.h"
#include "third_party/blink/renderer/core/svg_element_type_helpers.h"
#include "third_party/blink/renderer/platform/animation/timing_function.h"
#include "third_party/blink/renderer/platform/fonts/font_optical_sizing.h"
#include "third_party/blink/renderer/platform/fonts/font_palette.h"
#include "third_party/blink/renderer/platform/fonts/font_variant_emoji.h"
#include "third_party/blink/renderer/platform/fonts/opentype/font_settings.h"
#include "third_party/blink/renderer/platform/transforms/matrix_3d_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/matrix_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/perspective_transform_operation.h"
#include "third_party/blink/renderer/platform/transforms/skew_transform_operation.h"

namespace blink {

namespace {

const double kFinalStatePercentage =;
const double kMiddleStatePercentage =;

CSSValue* ConvertFontPaletteToCSSValue(const blink::FontPalette* palette) {}

}  // namespace

static Length Negate(const Length& length) {}

// TODO(rjwright): make this const
CSSValue* ComputedStyleUtils::ZoomAdjustedPixelValueForLength(
    const Length& length,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForPosition(const LengthPoint& position,
                                               const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForOffset(const ComputedStyle& style,
                                             const LayoutObject* layout_object,
                                             bool allow_visited_style,
                                             CSSValuePhase value_phase) {}

const CSSValue* ComputedStyleUtils::ValueForColor(
    const StyleColor& style_color) {}

const CSSValue* ComputedStyleUtils::ValueForColor(
    const StyleColor& style_color,
    const ComputedStyle& style,
    const Color* override_current_color,
    CSSValuePhase value_phase) {}

const CSSValue* ComputedStyleUtils::CurrentColorOrValidColor(
    const ComputedStyle& style,
    const StyleColor& color,
    CSSValuePhase value_phase) {}

const blink::Color ComputedStyleUtils::BorderSideColor(
    const ComputedStyle& style,
    const StyleColor& color,
    EBorderStyle border_style,
    bool visited_link,
    bool* is_current_color) {}

const CSSValue* ComputedStyleUtils::BackgroundImageOrMaskImage(
    const ComputedStyle& style,
    bool allow_visited_style,
    const FillLayer& fill_layer,
    CSSValuePhase value_phase) {}

const CSSValue* ComputedStyleUtils::ValueForFillSize(
    const FillSize& fill_size,
    const ComputedStyle& style) {}

const CSSValue* ComputedStyleUtils::BackgroundImageOrMaskSize(
    const ComputedStyle& style,
    const FillLayer& fill_layer) {}

const CSSValueList* ComputedStyleUtils::CreatePositionListForLayer(
    const CSSProperty& property,
    const FillLayer& layer,
    const ComputedStyle& style) {}

const CSSValue* ComputedStyleUtils::ValueForFillRepeat(
    const FillLayer* curr_layer) {}

const CSSValue* ComputedStyleUtils::RepeatStyle(const FillLayer* curr_layer) {}

const CSSValue* ComputedStyleUtils::MaskMode(const FillLayer* curr_layer) {}

const CSSValueList* ComputedStyleUtils::ValuesForBackgroundShorthand(
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

namespace {

// Append clip and origin vals (https://drafts.fxtf.org/css-masking/#the-mask):
// * If one <geometry-box> value and the no-clip keyword are present then
//   <geometry-box> sets mask-origin and no-clip sets mask-clip to that value.
// * If one <geometry-box> value and no no-clip keyword are present then
//   <geometry-box> sets both mask-origin and mask-clip to that value.
// * If two <geometry-box> values are present, then the first sets mask-origin
//   and the second mask-clip.
// Additionally, simplifies when possible.
void AppendValuesForMaskClipAndOrigin(CSSValueList* result_list,
                                      EFillBox origin,
                                      EFillBox clip) {}

}  // namespace

const CSSValueList* ComputedStyleUtils::ValuesForMaskShorthand(
    const StylePropertyShorthand&,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

const CSSValue* ComputedStyleUtils::BackgroundPositionOrMaskPosition(
    const CSSProperty& resolved_property,
    const ComputedStyle& style,
    const FillLayer* curr_layer) {}

const CSSValue* ComputedStyleUtils::BackgroundPositionXOrWebkitMaskPositionX(
    const ComputedStyle& style,
    const FillLayer* curr_layer) {}

const CSSValue* ComputedStyleUtils::BackgroundPositionYOrWebkitMaskPositionY(
    const ComputedStyle& style,
    const FillLayer* curr_layer) {}

static CSSNumericLiteralValue* ValueForImageSlice(const Length& slice) {}

cssvalue::CSSBorderImageSliceValue*
ComputedStyleUtils::ValueForNinePieceImageSlice(const NinePieceImage& image) {}

CSSValue* ValueForBorderImageLength(
    const BorderImageLength& border_image_length,
    const ComputedStyle& style) {}

CSSQuadValue* ComputedStyleUtils::ValueForNinePieceImageQuad(
    const BorderImageLengthBox& box,
    const ComputedStyle& style) {}

CSSValueID ValueForRepeatRule(int rule) {}

CSSValue* ComputedStyleUtils::ValueForNinePieceImageRepeat(
    const NinePieceImage& image) {}

CSSValue* ComputedStyleUtils::ValueForNinePieceImage(
    const NinePieceImage& image,
    const ComputedStyle& style,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForReflection(
    const StyleReflection* reflection,
    const ComputedStyle& style,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::MinWidthOrMinHeightAuto(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForPositionOffset(
    const ComputedStyle& style,
    const CSSProperty& property,
    const LayoutObject* layout_object) {}

CSSValue* ComputedStyleUtils::ValueForItemPositionWithOverflowAlignment(
    const StyleSelfAlignmentData& data) {}

cssvalue::CSSContentDistributionValue*
ComputedStyleUtils::ValueForContentPositionAndDistributionWithOverflowAlignment(
    const StyleContentAlignmentData& data) {}

CSSValue* ComputedStyleUtils::ValueForLineHeight(const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ComputedValueForLineHeight(
    const ComputedStyle& style) {}

CSSValueID IdentifierForFamily(const AtomicString& family) {}

CSSValue* ValueForFamily(const FontFamily& family) {}

CSSValueList* ComputedStyleUtils::ValueForFontFamily(
    const FontFamily& font_family) {}

CSSValueList* ComputedStyleUtils::ValueForFontFamily(
    const ComputedStyle& style) {}

CSSPrimitiveValue* ComputedStyleUtils::ValueForFontSize(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontSizeAdjust(
    const ComputedStyle& style) {}

CSSPrimitiveValue* ComputedStyleUtils::ValueForFontStretch(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontStyle(const ComputedStyle& style) {}

CSSNumericLiteralValue* ComputedStyleUtils::ValueForFontWeight(
    const ComputedStyle& style) {}

CSSIdentifierValue* ComputedStyleUtils::ValueForFontVariantCaps(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontVariantLigatures(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontVariantNumeric(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontVariantAlternates(
    const ComputedStyle& style) {}

CSSIdentifierValue* ComputedStyleUtils::ValueForFontVariantPosition(
    const ComputedStyle& style) {}

CSSIdentifierValue* ComputedStyleUtils::ValueForFontKerning(
    const ComputedStyle& style) {}

CSSIdentifierValue* ComputedStyleUtils::ValueForFontOpticalSizing(
    const ComputedStyle& style) {}

CSSIdentifierValue* ValueForFontStretchAsKeyword(const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontVariantEastAsian(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontFeatureSettings(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontVariationSettings(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFontPalette(const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForFont(const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::SpecifiedValueForGridTrackSize(
    const GridTrackSize& track_size,
    const ComputedStyle& style) {}

enum class NamedLinesType {};
class OrderedNamedLinesCollector {};

class OrderedNamedLinesCollectorInGridLayout
    : public OrderedNamedLinesCollector {};

void OrderedNamedLinesCollector::AppendLines(
    cssvalue::CSSBracketedValueList& line_names_value,
    wtf_size_t index,
    NamedLinesType type,
    bool is_in_repeat) const {}

void OrderedNamedLinesCollector::CollectLineNamesForIndex(
    cssvalue::CSSBracketedValueList& line_names_value,
    wtf_size_t i,
    NamedLinesType type,
    bool is_in_repeat) const {}

void OrderedNamedLinesCollectorInGridLayout::CollectLineNamesForIndex(
    cssvalue::CSSBracketedValueList& line_names_value,
    wtf_size_t i,
    NamedLinesType type,
    bool is_in_repeat) const {}

void AddValuesForNamedGridLinesAtIndex(OrderedNamedLinesCollector& collector,
                                       wtf_size_t i,
                                       CSSValueList& list,
                                       NamedLinesType type,
                                       bool is_in_repeat = false) {}

CSSValue* ComputedStyleUtils::ValueForGridAutoTrackList(
    GridTrackSizingDirection track_direction,
    const LayoutObject* layout_object,
    const ComputedStyle& style) {}

void PopulateGridTrackListUsedValues(CSSValueList* list,
                                     OrderedNamedLinesCollector& collector,
                                     const Vector<LayoutUnit, 1>& tracks,
                                     const ComputedStyle& style,
                                     wtf_size_t start,
                                     wtf_size_t end,
                                     int offset,
                                     bool discard_line_names) {}

void PopulateNonRepeater(CSSValueList* list,
                         OrderedNamedLinesCollector& collector,
                         const blink::NGGridTrackList& track_list,
                         wtf_size_t repeater_index,
                         wtf_size_t track_index,
                         const ComputedStyle& style) {}

void PopulateAutoRepeater(CSSValueList* list,
                          OrderedNamedLinesCollector& collector,
                          const blink::NGGridTrackList& track_list,
                          wtf_size_t repeater_index,
                          const ComputedStyle& style) {}

// Returns the number of tracks populated after expanding repetitions.
wtf_size_t PopulateIntegerRepeater(CSSValueList* list,
                                   OrderedNamedLinesCollector& collector,
                                   const blink::NGGridTrackList& track_list,
                                   wtf_size_t repeater_index,
                                   wtf_size_t track_index,
                                   const ComputedStyle& style) {}

void PopulateGridTrackListComputedValues(
    CSSValueList* list,
    OrderedNamedLinesCollector& collector,
    const blink::NGGridTrackList& track_list,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForGridTrackList(
    GridTrackSizingDirection direction,
    const LayoutObject* layout_object,
    const ComputedStyle& style,
    bool force_computed_value) {}

CSSValue* ComputedStyleUtils::ValueForGridPosition(
    const GridPosition& position) {}

CSSValue* ComputedStyleUtils::ValueForMasonryTrackList(
    const LayoutObject* layout_object,
    const ComputedStyle& style) {}

static bool IsSVGObjectWithWidthAndHeight(const LayoutObject& layout_object) {}

gfx::SizeF ComputedStyleUtils::UsedBoxSize(const LayoutObject& layout_object) {}

CSSValue* ComputedStyleUtils::RenderTextDecorationFlagsToCSSValue(
    TextDecorationLine text_decoration) {}

CSSValue* ComputedStyleUtils::ValueForTextDecorationStyle(
    ETextDecorationStyle text_decoration_style) {}

CSSValue* ComputedStyleUtils::ValueForTextDecorationSkipInk(
    ETextDecorationSkipInk text_decoration_skip_ink) {}

CSSValue* ComputedStyleUtils::TouchActionFlagsToCSSValue(
    TouchAction touch_action) {}

CSSValue* ComputedStyleUtils::ValueForWillChange(
    const Vector<CSSPropertyID>& will_change_properties,
    bool will_change_contents,
    bool will_change_scroll_position) {}

namespace {

template <typename T, wtf_size_t C, typename Func, typename... Args>
CSSValue* CreateAnimationValueList(const Vector<T, C>& values,
                                   Func item_func,
                                   Args&&... args) {}

}  // namespace

CSSValue* ComputedStyleUtils::ValueForAnimationDelay(
    const Timing::Delay& delay) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDelayList(
    const CSSTimingData* timing_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDirection(
    Timing::PlaybackDirection direction) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDirectionList(
    const CSSAnimationData* animation_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDuration(
    const std::optional<double>& duration,
    bool resolve_auto_to_zero) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDurationList(
    const CSSAnimationData* animation_data,
    CSSValuePhase phase) {}

CSSValue* ComputedStyleUtils::ValueForAnimationDurationList(
    const CSSTransitionData* transition_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationFillMode(
    Timing::FillMode fill_mode) {}

CSSValue* ComputedStyleUtils::ValueForAnimationFillModeList(
    const CSSAnimationData* animation_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationIterationCount(
    double iteration_count) {}

CSSValue* ComputedStyleUtils::ValueForAnimationIterationCountList(
    const CSSAnimationData* animation_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationPlayState(
    EAnimPlayState play_state) {}

CSSValue* ComputedStyleUtils::ValueForAnimationPlayStateList(
    const CSSAnimationData* animation_data) {}

namespace {

CSSValue* ValueForAnimationRange(const std::optional<TimelineOffset>& offset,
                                 const ComputedStyle& style,
                                 const Length& default_offset) {}

}  // namespace

CSSValue* ComputedStyleUtils::ValueForAnimationRangeStart(
    const std::optional<TimelineOffset>& offset,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForAnimationRangeStartList(
    const CSSAnimationData* animation_data,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForAnimationRangeEnd(
    const std::optional<TimelineOffset>& offset,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForAnimationRangeEndList(
    const CSSAnimationData* animation_data,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForAnimationTimingFunction(
    const scoped_refptr<TimingFunction>& timing_function) {}

CSSValue* ComputedStyleUtils::ValueForAnimationTimingFunctionList(
    const CSSTimingData* timing_data) {}

CSSValue* ComputedStyleUtils::ValueForAnimationTimeline(
    const StyleTimeline& timeline) {}

CSSValue* ComputedStyleUtils::ValueForAnimationTimelineList(
    const CSSAnimationData* animation_data) {}

CSSValue* ComputedStyleUtils::ValueForTimelineInset(
    const TimelineInset& inset,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::SingleValueForTimelineShorthand(
    const ScopedCSSName* name,
    TimelineAxis axis,
    std::optional<TimelineInset> inset,
    const ComputedStyle& style) {}

CSSValueList* ComputedStyleUtils::ValuesForBorderRadiusCorner(
    const LengthSize& radius,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForBorderRadiusCorner(
    const LengthSize& radius,
    const ComputedStyle& style) {}

CSSFunctionValue* ComputedStyleUtils::ValueForTransform(
    const gfx::Transform& matrix,
    float zoom,
    bool force_matrix3d) {}

CSSValueID ComputedStyleUtils::CSSValueIDForScaleOperation(
    const TransformOperation::OperationType type) {}

CSSValueID ComputedStyleUtils::CSSValueIDForTranslateOperation(
    const TransformOperation::OperationType type) {}

CSSValueID ComputedStyleUtils::CSSValueIDForRotateOperation(
    const TransformOperation::OperationType type) {}

// We collapse functions like translateX into translate, since we will reify
// them as a translate anyway.
CSSFunctionValue* ComputedStyleUtils::ValueForTransformOperation(
    const TransformOperation& operation,
    float zoom,
    gfx::SizeF box_size) {}

CSSValue* ComputedStyleUtils::ValueForTransformList(
    const TransformOperations& transform_list,
    float zoom,
    gfx::SizeF box_size) {}

CSSValue* ComputedStyleUtils::ValueForTransformFunction(
    const TransformOperations& transform_list) {}

gfx::RectF ComputedStyleUtils::ReferenceBoxForTransform(
    const LayoutObject& layout_object) {}

CSSValue* ComputedStyleUtils::ComputedTransformList(
    const ComputedStyle& style,
    const LayoutObject* layout_object) {}

CSSValue* ComputedStyleUtils::ResolvedTransform(
    const LayoutObject* layout_object,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::CreateTransitionPropertyValue(
    const CSSTransitionData::TransitionProperty& property) {}

CSSValue* ComputedStyleUtils::CreateTransitionBehaviorValue(
    const CSSTransitionData::TransitionBehavior& type) {}

CSSValue* ComputedStyleUtils::ValueForTransitionProperty(
    const CSSTransitionData* transition_data) {}

CSSValue* ComputedStyleUtils::ValueForTransitionBehavior(
    const CSSTransitionData* transition_data) {}

CSSValueID ValueForQuoteType(const QuoteType quote_type) {}

CSSValue* ComputedStyleUtils::ValueForContentData(const ComputedStyle& style,
                                                  bool allow_visited_style,
                                                  CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForCounterDirectives(
    const ComputedStyle& style,
    CountersAttachmentContext::Type type) {}

CSSValue* ComputedStyleUtils::ValueForShape(const ComputedStyle& style,
                                            bool allow_visited_style,
                                            ShapeValue* shape_value,
                                            CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValueForBorderRadiusShorthand(
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::StrokeDashArrayToCSSValueList(
    const SVGDashArray& dashes,
    const ComputedStyle& style) {}

const CSSValue* ComputedStyleUtils::ValueForSVGPaint(
    const SVGPaint& paint,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForSVGResource(
    const StyleSVGResource* resource) {}

CSSValue* ComputedStyleUtils::ValueForShadowData(const ShadowData& shadow,
                                                 const ComputedStyle& style,
                                                 bool use_spread,
                                                 CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForShadowList(const ShadowList* shadow_list,
                                                 const ComputedStyle& style,
                                                 bool use_spread,
                                                 CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForFilter(
    const ComputedStyle& style,
    const FilterOperations& filter_operations) {}

CSSValue* ComputedStyleUtils::ValueForScrollSnapType(
    const cc::ScrollSnapType& type,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForScrollSnapAlign(
    const cc::ScrollSnapAlign& align,
    const ComputedStyle& style) {}

// Returns a suitable value for the page-break-(before|after) property, given
// the computed value of the more general break-(before|after) property.
CSSValue* ComputedStyleUtils::ValueForPageBreakBetween(
    EBreakBetween break_value) {}

// Returns a suitable value for the -webkit-column-break-(before|after)
// property, given the computed value of the more general break-(before|after)
// property.
CSSValue* ComputedStyleUtils::ValueForWebkitColumnBreakBetween(
    EBreakBetween break_value) {}

// Returns a suitable value for the page-break-inside property, given the
// computed value of the more general break-inside property.
CSSValue* ComputedStyleUtils::ValueForPageBreakInside(
    EBreakInside break_value) {}

// Returns a suitable value for the -webkit-column-break-inside property, given
// the computed value of the more general break-inside property.
CSSValue* ComputedStyleUtils::ValueForWebkitColumnBreakInside(
    EBreakInside break_value) {}

// https://drafts.csswg.org/cssom/#resolved-value
//
// For 'width' and 'height':
//
// If the property applies to the element or pseudo-element and the resolved
// value of the display property is not none or contents, then the resolved
// value is the used value. Otherwise the resolved value is the computed value
// (https://drafts.csswg.org/css-cascade-4/#computed-value).
//
// (Note that the computed value exists even when the property does not apply.)
bool ComputedStyleUtils::WidthOrHeightShouldReturnUsedValue(
    const LayoutObject* object) {}

CSSValueList* ComputedStyleUtils::ValuesForShorthandProperty(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValuePair* ComputedStyleUtils::ValuesForGapShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForGridShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForGridAreaShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForGridLineShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForGridTemplateShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForSidesShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValuePair* ComputedStyleUtils::ValuesForInlineBlockShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValuePair* ComputedStyleUtils::ValuesForPlaceShorthand(
    const StylePropertyShorthand& shorthand,
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

static CSSValue* ExpandNoneLigaturesValue() {}

CSSValue* ComputedStyleUtils::ValuesForFontVariantProperty(
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValuesForFontSynthesisProperty(
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValueList* ComputedStyleUtils::ValuesForContainerShorthand(
    const ComputedStyle& style,
    const LayoutObject* layout_object,
    bool allow_visited_style,
    CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForGapLength(
    const std::optional<Length>& gap_length,
    const ComputedStyle& style) {}

CSSValue* ComputedStyleUtils::ValueForStyleName(const StyleName& name) {}

CSSValue* ComputedStyleUtils::ValueForStyleNameOrKeyword(
    const StyleNameOrKeyword& value) {}

CSSValue* ComputedStyleUtils::ValueForCustomIdentOrNone(
    const AtomicString& ident) {}

CSSValue* ComputedStyleUtils::ValueForCustomIdentOrNone(
    const ScopedCSSName* name) {}

const CSSValue* ComputedStyleUtils::ValueForStyleAutoColor(
    const ComputedStyle& style,
    const StyleAutoColor& color,
    CSSValuePhase value_phase) {}

CSSValue* ComputedStyleUtils::ValueForIntrinsicLength(
    const ComputedStyle& style,
    const StyleIntrinsicLength& intrinsic_length) {}

CSSValue* ComputedStyleUtils::ValueForScrollStart(const ComputedStyle& style,
                                                  const ScrollStartData& data) {}

namespace {

CSSIdentifierValue* PositionAreaSpanToCSSIdentifierValue(
    PositionAreaRegion span_start,
    PositionAreaRegion span_end) {}

}  // namespace

CSSValue* ComputedStyleUtils::ValueForPositionArea(
    const blink::PositionArea& area) {}

std::unique_ptr<CrossThreadStyleValue>
ComputedStyleUtils::CrossThreadStyleValueFromCSSStyleValue(
    CSSStyleValue* style_value) {}

const CSSValue* ComputedStyleUtils::ComputedPropertyValue(
    const CSSProperty& property,
    const ComputedStyle& style,
    const LayoutObject* layout_object) {}

CSSValue* ComputedStyleUtils::ValueForPositionTryFallbacks(
    const PositionTryFallbacks& fallbacks) {}

}  // namespace blink