/*
 * Copyright (C) 2013 Google Inc. All rights reserved.
 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
 *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
 * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.
 * All rights reserved.
 * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
 * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
 * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
 * (http://www.torchmobile.com/)
 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
 * Copyright (C) Research In Motion Limited 2011. All rights reserved.
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "core/CSSPropertyNames.h"
#include "core/CSSValueKeywords.h"
#include "core/StyleBuilderFunctions.h"
#include "core/StylePropertyShorthand.h"
#include "core/animation/css/CSSAnimations.h"
#include "core/css/CSSCounterValue.h"
#include "core/css/CSSCursorImageValue.h"
#include "core/css/CSSCustomPropertyDeclaration.h"
#include "core/css/CSSFunctionValue.h"
#include "core/css/CSSGridTemplateAreasValue.h"
#include "core/css/CSSHelper.h"
#include "core/css/CSSImageSetValue.h"
#include "core/css/CSSPendingSubstitutionValue.h"
#include "core/css/CSSPrimitiveValueMappings.h"
#include "core/css/CSSPropertyMetadata.h"
#include "core/css/CSSVariableReferenceValue.h"
#include "core/css/PropertyRegistration.h"
#include "core/css/PropertyRegistry.h"
#include "core/css/StylePropertySet.h"
#include "core/css/StyleRule.h"
#include "core/css/resolver/CSSVariableResolver.h"
#include "core/css/resolver/ElementStyleResources.h"
#include "core/css/resolver/FilterOperationResolver.h"
#include "core/css/resolver/FontBuilder.h"
#include "core/css/resolver/StyleBuilder.h"
#include "core/frame/LocalFrame.h"
#include "core/frame/Settings.h"
#include "core/style/ComputedStyle.h"
#include "core/style/ComputedStyleConstants.h"
#include "core/style/ContentData.h"
#include "core/style/CounterContent.h"
#include "core/style/QuotesData.h"
#include "core/style/SVGComputedStyle.h"
#include "core/style/StyleGeneratedImage.h"
#include "core/style/StyleInheritedVariables.h"
#include "core/style/StyleNonInheritedVariables.h"
#include "platform/fonts/FontDescription.h"
#include "wtf/MathExtras.h"
#include "wtf/PtrUtil.h"
#include "wtf/StdLibExtras.h"
#include "wtf/Vector.h"
#include <memory>

namespace blink {

namespace {

static inline bool isValidVisitedLinkProperty(CSSPropertyID id) {
  switch (id) {
    case CSSPropertyBackgroundColor:
    case CSSPropertyBorderLeftColor:
    case CSSPropertyBorderRightColor:
    case CSSPropertyBorderTopColor:
    case CSSPropertyBorderBottomColor:
    case CSSPropertyCaretColor:
    case CSSPropertyColor:
    case CSSPropertyFill:
    case CSSPropertyOutlineColor:
    case CSSPropertyStroke:
    case CSSPropertyTextDecorationColor:
    case CSSPropertyColumnRuleColor:
    case CSSPropertyWebkitTextEmphasisColor:
    case CSSPropertyWebkitTextFillColor:
    case CSSPropertyWebkitTextStrokeColor:
      return true;
    default:
      return false;
  }
}

}  // namespace

void StyleBuilder::applyProperty(CSSPropertyID id,
                                 StyleResolverState& state,
                                 const CSSValue& value) {
  if (id != CSSPropertyVariable && (value.isVariableReferenceValue() ||
                                    value.isPendingSubstitutionValue())) {
    bool omitAnimationTainted = CSSAnimations::isAnimationAffectingProperty(id);
    const CSSValue* resolvedValue =
        CSSVariableResolver::resolveVariableReferences(state, id, value,
                                                       omitAnimationTainted);
    applyProperty(id, state, *resolvedValue);

    if (!state.style()->hasVariableReferenceFromNonInheritedProperty() &&
        !CSSPropertyMetadata::isInheritedProperty(id))
      state.style()->setHasVariableReferenceFromNonInheritedProperty();
    return;
  }

  DCHECK(!isShorthandProperty(id)) << "Shorthand property id = " << id
                                   << " wasn't expanded at parsing time";

  bool isInherit = state.parentNode() && value.isInheritedValue();
  bool isInitial = value.isInitialValue() ||
                   (!state.parentNode() && value.isInheritedValue());

  // isInherit => !isInitial && isInitial => !isInherit
  DCHECK(!isInherit || !isInitial);
  // isInherit => (state.parentNode() && state.parentStyle())
  DCHECK(!isInherit || (state.parentNode() && state.parentStyle()));

  if (!state.applyPropertyToRegularStyle() &&
      (!state.applyPropertyToVisitedLinkStyle() ||
       !isValidVisitedLinkProperty(id))) {
    // Limit the properties that can be applied to only the ones honored by
    // :visited.
    return;
  }

  if (isInherit && !state.parentStyle()->hasExplicitlyInheritedProperties() &&
      !CSSPropertyMetadata::isInheritedProperty(id)) {
    state.parentStyle()->setHasExplicitlyInheritedProperties();
  } else if (value.isUnsetValue()) {
    DCHECK(!isInherit && !isInitial);
    if (CSSPropertyMetadata::isInheritedProperty(id))
      isInherit = true;
    else
      isInitial = true;
  }

  StyleBuilder::applyProperty(id, state, value, isInitial, isInherit);
}

void StyleBuilderFunctions::applyInitialCSSPropertyColor(
    StyleResolverState& state) {
  Color color = ComputedStyle::initialColor();
  if (state.applyPropertyToRegularStyle())
    state.style()->setColor(color);
  if (state.applyPropertyToVisitedLinkStyle())
    state.style()->setVisitedLinkColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyColor(
    StyleResolverState& state) {
  Color color = state.parentStyle()->color();
  if (state.applyPropertyToRegularStyle())
    state.style()->setColor(color);
  if (state.applyPropertyToVisitedLinkStyle())
    state.style()->setVisitedLinkColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyColor(
    StyleResolverState& state,
    const CSSValue& value) {
  // As per the spec, 'color: currentColor' is treated as 'color: inherit'
  if (value.isIdentifierValue() &&
      toCSSIdentifierValue(value).getValueID() == CSSValueCurrentcolor) {
    applyInheritCSSPropertyColor(state);
    return;
  }

  if (state.applyPropertyToRegularStyle())
    state.style()->setColor(StyleBuilderConverter::convertColor(state, value));
  if (state.applyPropertyToVisitedLinkStyle())
    state.style()->setVisitedLinkColor(
        StyleBuilderConverter::convertColor(state, value, true));
}

void StyleBuilderFunctions::applyInitialCSSPropertyCursor(
    StyleResolverState& state) {
  state.style()->clearCursorList();
  state.style()->setCursor(ComputedStyle::initialCursor());
}

void StyleBuilderFunctions::applyInheritCSSPropertyCursor(
    StyleResolverState& state) {
  state.style()->setCursor(state.parentStyle()->cursor());
  state.style()->setCursorList(state.parentStyle()->cursors());
}

void StyleBuilderFunctions::applyValueCSSPropertyCursor(
    StyleResolverState& state,
    const CSSValue& value) {
  state.style()->clearCursorList();
  if (value.isValueList()) {
    state.style()->setCursor(ECursor::kAuto);
    for (const auto& item : toCSSValueList(value)) {
      if (item->isCursorImageValue()) {
        const CSSCursorImageValue& cursor = toCSSCursorImageValue(*item);
        const CSSValue& image = cursor.imageValue();
        state.style()->addCursor(state.styleImage(CSSPropertyCursor, image),
                                 cursor.hotSpotSpecified(), cursor.hotSpot());
      } else {
        state.style()->setCursor(
            toCSSIdentifierValue(*item).convertTo<ECursor>());
      }
    }
  } else {
    state.style()->setCursor(toCSSIdentifierValue(value).convertTo<ECursor>());
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyDirection(
    StyleResolverState& state,
    const CSSValue& value) {
  state.style()->setDirection(
      toCSSIdentifierValue(value).convertTo<TextDirection>());
}

void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateAreas(
    StyleResolverState& state) {
  state.style()->setNamedGridArea(ComputedStyle::initialNamedGridArea());
  state.style()->setNamedGridAreaRowCount(
      ComputedStyle::initialNamedGridAreaCount());
  state.style()->setNamedGridAreaColumnCount(
      ComputedStyle::initialNamedGridAreaCount());
}

void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateAreas(
    StyleResolverState& state) {
  state.style()->setNamedGridArea(state.parentStyle()->namedGridArea());
  state.style()->setNamedGridAreaRowCount(
      state.parentStyle()->namedGridAreaRowCount());
  state.style()->setNamedGridAreaColumnCount(
      state.parentStyle()->namedGridAreaColumnCount());
}

void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateAreas(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isIdentifierValue()) {
    // FIXME: Shouldn't we clear the grid-area values
    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
    return;
  }

  const CSSGridTemplateAreasValue& gridTemplateAreasValue =
      toCSSGridTemplateAreasValue(value);
  const NamedGridAreaMap& newNamedGridAreas =
      gridTemplateAreasValue.gridAreaMap();

  NamedGridLinesMap namedGridColumnLines;
  NamedGridLinesMap namedGridRowLines;
  StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(
      state.style()->orderedNamedGridColumnLines(), namedGridColumnLines);
  StyleBuilderConverter::convertOrderedNamedGridLinesMapToNamedGridLinesMap(
      state.style()->orderedNamedGridRowLines(), namedGridRowLines);
  StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(
      newNamedGridAreas, namedGridColumnLines, ForColumns);
  StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea(
      newNamedGridAreas, namedGridRowLines, ForRows);
  state.style()->setNamedGridColumnLines(namedGridColumnLines);
  state.style()->setNamedGridRowLines(namedGridRowLines);

  state.style()->setNamedGridArea(newNamedGridAreas);
  state.style()->setNamedGridAreaRowCount(gridTemplateAreasValue.rowCount());
  state.style()->setNamedGridAreaColumnCount(
      gridTemplateAreasValue.columnCount());
}

void StyleBuilderFunctions::applyValueCSSPropertyListStyleImage(
    StyleResolverState& state,
    const CSSValue& value) {
  state.style()->setListStyleImage(
      state.styleImage(CSSPropertyListStyleImage, value));
}

void StyleBuilderFunctions::applyInitialCSSPropertyOutlineStyle(
    StyleResolverState& state) {
  state.style()->setOutlineStyleIsAuto(
      ComputedStyle::initialOutlineStyleIsAuto());
  state.style()->setOutlineStyle(ComputedStyle::initialBorderStyle());
}

void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(
    StyleResolverState& state) {
  state.style()->setOutlineStyleIsAuto(
      state.parentStyle()->outlineStyleIsAuto());
  state.style()->setOutlineStyle(state.parentStyle()->outlineStyle());
}

void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(
    StyleResolverState& state,
    const CSSValue& value) {
  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
  state.style()->setOutlineStyleIsAuto(
      identifierValue.convertTo<OutlineIsAuto>());
  state.style()->setOutlineStyle(identifierValue.convertTo<EBorderStyle>());
}

void StyleBuilderFunctions::applyValueCSSPropertyResize(
    StyleResolverState& state,
    const CSSValue& value) {
  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);

  EResize r = RESIZE_NONE;
  if (identifierValue.getValueID() == CSSValueAuto) {
    if (Settings* settings = state.document().settings())
      r = settings->getTextAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
  } else {
    r = identifierValue.convertTo<EResize>();
  }
  state.style()->setResize(r);
}

static float mmToPx(float mm) {
  return mm * cssPixelsPerMillimeter;
}
static float inchToPx(float inch) {
  return inch * cssPixelsPerInch;
}
static FloatSize getPageSizeFromName(const CSSIdentifierValue& pageSizeName) {
  switch (pageSizeName.getValueID()) {
    case CSSValueA5:
      return FloatSize(mmToPx(148), mmToPx(210));
    case CSSValueA4:
      return FloatSize(mmToPx(210), mmToPx(297));
    case CSSValueA3:
      return FloatSize(mmToPx(297), mmToPx(420));
    case CSSValueB5:
      return FloatSize(mmToPx(176), mmToPx(250));
    case CSSValueB4:
      return FloatSize(mmToPx(250), mmToPx(353));
    case CSSValueLetter:
      return FloatSize(inchToPx(8.5), inchToPx(11));
    case CSSValueLegal:
      return FloatSize(inchToPx(8.5), inchToPx(14));
    case CSSValueLedger:
      return FloatSize(inchToPx(11), inchToPx(17));
    default:
      NOTREACHED();
      return FloatSize(0, 0);
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertySize(StyleResolverState&) {}
void StyleBuilderFunctions::applyInheritCSSPropertySize(StyleResolverState&) {}
void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolverState& state,
                                                      const CSSValue& value) {
  state.style()->resetPageSizeType();
  FloatSize size;
  PageSizeType pageSizeType = PAGE_SIZE_AUTO;
  const CSSValueList& list = toCSSValueList(value);
  if (list.length() == 2) {
    // <length>{2} | <page-size> <orientation>
    const CSSValue& first = list.item(0);
    const CSSValue& second = list.item(1);
    if (first.isPrimitiveValue() && toCSSPrimitiveValue(first).isLength()) {
      // <length>{2}
      size = FloatSize(
          toCSSPrimitiveValue(first).computeLength<float>(
              state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)),
          toCSSPrimitiveValue(second).computeLength<float>(
              state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)));
    } else {
      // <page-size> <orientation>
      size = getPageSizeFromName(toCSSIdentifierValue(first));

      DCHECK(toCSSIdentifierValue(second).getValueID() == CSSValueLandscape ||
             toCSSIdentifierValue(second).getValueID() == CSSValuePortrait);
      if (toCSSIdentifierValue(second).getValueID() == CSSValueLandscape)
        size = size.transposedSize();
    }
    pageSizeType = PAGE_SIZE_RESOLVED;
  } else {
    DCHECK_EQ(list.length(), 1U);
    // <length> | auto | <page-size> | [ portrait | landscape]
    const CSSValue& first = list.item(0);
    if (first.isPrimitiveValue() && toCSSPrimitiveValue(first).isLength()) {
      // <length>
      pageSizeType = PAGE_SIZE_RESOLVED;
      float width = toCSSPrimitiveValue(first).computeLength<float>(
          state.cssToLengthConversionData().copyWithAdjustedZoom(1.0));
      size = FloatSize(width, width);
    } else {
      const CSSIdentifierValue& ident = toCSSIdentifierValue(first);
      switch (ident.getValueID()) {
        case CSSValueAuto:
          pageSizeType = PAGE_SIZE_AUTO;
          break;
        case CSSValuePortrait:
          pageSizeType = PAGE_SIZE_AUTO_PORTRAIT;
          break;
        case CSSValueLandscape:
          pageSizeType = PAGE_SIZE_AUTO_LANDSCAPE;
          break;
        default:
          // <page-size>
          pageSizeType = PAGE_SIZE_RESOLVED;
          size = getPageSizeFromName(ident);
      }
    }
  }
  state.style()->setPageSizeType(pageSizeType);
  state.style()->setPageSize(size);
}

void StyleBuilderFunctions::applyInitialCSSPropertySnapHeight(
    StyleResolverState& state) {
  state.style()->setSnapHeightUnit(0);
  state.style()->setSnapHeightPosition(0);
}

void StyleBuilderFunctions::applyInheritCSSPropertySnapHeight(
    StyleResolverState& state) {
  state.style()->setSnapHeightUnit(state.parentStyle()->snapHeightUnit());
  state.style()->setSnapHeightPosition(
      state.parentStyle()->snapHeightPosition());
}

void StyleBuilderFunctions::applyValueCSSPropertySnapHeight(
    StyleResolverState& state,
    const CSSValue& value) {
  const CSSValueList& list = toCSSValueList(value);
  const CSSPrimitiveValue& first = toCSSPrimitiveValue(list.item(0));
  DCHECK(first.isLength());
  int unit = first.computeLength<int>(state.cssToLengthConversionData());
  DCHECK_GE(unit, 0);
  state.style()->setSnapHeightUnit(clampTo<uint8_t>(unit));

  if (list.length() == 1) {
    state.style()->setSnapHeightPosition(0);
    return;
  }

  DCHECK_EQ(list.length(), 2U);
  const CSSPrimitiveValue& second = toCSSPrimitiveValue(list.item(1));
  DCHECK(second.isNumber());
  int position = second.getIntValue();
  DCHECK(position > 0 && position <= 100);
  state.style()->setSnapHeightPosition(position);
}

void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isIdentifierValue() &&
      toCSSIdentifierValue(value).getValueID() != CSSValueWebkitMatchParent) {
    // Special case for th elements - UA stylesheet text-align does not apply if
    // parent's computed value for text-align is not its initial value
    // https://html.spec.whatwg.org/multipage/rendering.html#tables-2
    const CSSIdentifierValue& identValue = toCSSIdentifierValue(value);
    if (identValue.getValueID() == CSSValueInternalCenter &&
        state.parentStyle()->textAlign() != ComputedStyle::initialTextAlign())
      state.style()->setTextAlign(state.parentStyle()->textAlign());
    else
      state.style()->setTextAlign(identValue.convertTo<ETextAlign>());
  } else if (state.parentStyle()->textAlign() == ETextAlign::kStart) {
    state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection()
                                    ? ETextAlign::kLeft
                                    : ETextAlign::kRight);
  } else if (state.parentStyle()->textAlign() == ETextAlign::kEnd) {
    state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection()
                                    ? ETextAlign::kRight
                                    : ETextAlign::kLeft);
  } else {
    state.style()->setTextAlign(state.parentStyle()->textAlign());
  }
  state.style()->setTextAlignIsInherited(false);
}

void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(
    StyleResolverState& state) {
  state.style()->setTextIndent(state.parentStyle()->textIndent());
  state.style()->setTextIndentLine(state.parentStyle()->getTextIndentLine());
  state.style()->setTextIndentType(state.parentStyle()->getTextIndentType());
}

void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(
    StyleResolverState& state) {
  state.style()->setTextIndent(ComputedStyle::initialTextIndent());
  state.style()->setTextIndentLine(ComputedStyle::initialTextIndentLine());
  state.style()->setTextIndentType(ComputedStyle::initialTextIndentType());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(
    StyleResolverState& state,
    const CSSValue& value) {
  Length lengthOrPercentageValue;
  TextIndentLine textIndentLineValue = ComputedStyle::initialTextIndentLine();
  TextIndentType textIndentTypeValue = ComputedStyle::initialTextIndentType();

  for (auto& listValue : toCSSValueList(value)) {
    if (listValue->isPrimitiveValue()) {
      lengthOrPercentageValue =
          toCSSPrimitiveValue(*listValue)
              .convertToLength(state.cssToLengthConversionData());
    } else if (toCSSIdentifierValue(*listValue).getValueID() ==
               CSSValueEachLine) {
      textIndentLineValue = TextIndentEachLine;
    } else if (toCSSIdentifierValue(*listValue).getValueID() ==
               CSSValueHanging) {
      textIndentTypeValue = TextIndentHanging;
    } else {
      NOTREACHED();
    }
  }

  state.style()->setTextIndent(lengthOrPercentageValue);
  state.style()->setTextIndentLine(textIndentLineValue);
  state.style()->setTextIndentType(textIndentTypeValue);
}

void StyleBuilderFunctions::applyInheritCSSPropertyVerticalAlign(
    StyleResolverState& state) {
  EVerticalAlign verticalAlign = state.parentStyle()->verticalAlign();
  state.style()->setVerticalAlign(verticalAlign);
  if (verticalAlign == EVerticalAlign::kLength)
    state.style()->setVerticalAlignLength(
        state.parentStyle()->getVerticalAlignLength());
}

void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isIdentifierValue()) {
    state.style()->setVerticalAlign(
        toCSSIdentifierValue(value).convertTo<EVerticalAlign>());
  } else {
    state.style()->setVerticalAlignLength(
        toCSSPrimitiveValue(value).convertToLength(
            state.cssToLengthConversionData()));
  }
}

static void resetEffectiveZoom(StyleResolverState& state) {
  // Reset the zoom in effect. This allows the setZoom method to accurately
  // compute a new zoom in effect.
  state.setEffectiveZoom(state.parentStyle()
                             ? state.parentStyle()->effectiveZoom()
                             : ComputedStyle::initialZoom());
}

void StyleBuilderFunctions::applyInitialCSSPropertyZoom(
    StyleResolverState& state) {
  resetEffectiveZoom(state);
  state.setZoom(ComputedStyle::initialZoom());
}

void StyleBuilderFunctions::applyInheritCSSPropertyZoom(
    StyleResolverState& state) {
  resetEffectiveZoom(state);
  state.setZoom(state.parentStyle()->zoom());
}

void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolverState& state,
                                                      const CSSValue& value) {
  SECURITY_DCHECK(value.isPrimitiveValue() || value.isIdentifierValue());

  if (value.isIdentifierValue()) {
    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
    if (identifierValue.getValueID() == CSSValueNormal) {
      resetEffectiveZoom(state);
      state.setZoom(ComputedStyle::initialZoom());
    } else if (identifierValue.getValueID() == CSSValueReset) {
      state.setEffectiveZoom(ComputedStyle::initialZoom());
      state.setZoom(ComputedStyle::initialZoom());
    } else if (identifierValue.getValueID() == CSSValueDocument) {
      float docZoom = state.rootElementStyle()
                          ? state.rootElementStyle()->zoom()
                          : ComputedStyle::initialZoom();
      state.setEffectiveZoom(docZoom);
      state.setZoom(docZoom);
    }
  } else if (value.isPrimitiveValue()) {
    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
    if (primitiveValue.isPercentage()) {
      resetEffectiveZoom(state);
      if (float percent = primitiveValue.getFloatValue())
        state.setZoom(percent / 100.0f);
    } else if (primitiveValue.isNumber()) {
      resetEffectiveZoom(state);
      if (float number = primitiveValue.getFloatValue())
        state.setZoom(number);
    }
  }
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitBorderImage(
    StyleResolverState& state,
    const CSSValue& value) {
  NinePieceImage image;
  CSSToStyleMap::mapNinePieceImage(state, CSSPropertyWebkitBorderImage, value,
                                   image);
  state.style()->setBorderImage(image);
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisStyle(
    StyleResolverState& state) {
  state.style()->setTextEmphasisFill(ComputedStyle::initialTextEmphasisFill());
  state.style()->setTextEmphasisMark(ComputedStyle::initialTextEmphasisMark());
  state.style()->setTextEmphasisCustomMark(
      ComputedStyle::initialTextEmphasisCustomMark());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextEmphasisStyle(
    StyleResolverState& state) {
  state.style()->setTextEmphasisFill(
      state.parentStyle()->getTextEmphasisFill());
  state.style()->setTextEmphasisMark(
      state.parentStyle()->getTextEmphasisMark());
  state.style()->setTextEmphasisCustomMark(
      state.parentStyle()->textEmphasisCustomMark());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isValueList()) {
    const CSSValueList& list = toCSSValueList(value);
    DCHECK_EQ(list.length(), 2U);
    for (unsigned i = 0; i < 2; ++i) {
      const CSSIdentifierValue& value = toCSSIdentifierValue(list.item(i));
      if (value.getValueID() == CSSValueFilled ||
          value.getValueID() == CSSValueOpen)
        state.style()->setTextEmphasisFill(value.convertTo<TextEmphasisFill>());
      else
        state.style()->setTextEmphasisMark(value.convertTo<TextEmphasisMark>());
    }
    state.style()->setTextEmphasisCustomMark(nullAtom);
    return;
  }

  if (value.isStringValue()) {
    state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
    state.style()->setTextEmphasisMark(TextEmphasisMarkCustom);
    state.style()->setTextEmphasisCustomMark(
        AtomicString(toCSSStringValue(value).value()));
    return;
  }

  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);

  state.style()->setTextEmphasisCustomMark(nullAtom);

  if (identifierValue.getValueID() == CSSValueFilled ||
      identifierValue.getValueID() == CSSValueOpen) {
    state.style()->setTextEmphasisFill(
        identifierValue.convertTo<TextEmphasisFill>());
    state.style()->setTextEmphasisMark(TextEmphasisMarkAuto);
  } else {
    state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
    state.style()->setTextEmphasisMark(
        identifierValue.convertTo<TextEmphasisMark>());
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWillChange(
    StyleResolverState& state) {
  state.style()->setWillChangeContents(false);
  state.style()->setWillChangeScrollPosition(false);
  state.style()->setWillChangeProperties(Vector<CSSPropertyID>());
  state.style()->setSubtreeWillChangeContents(
      state.parentStyle()->subtreeWillChangeContents());
}

void StyleBuilderFunctions::applyInheritCSSPropertyWillChange(
    StyleResolverState& state) {
  state.style()->setWillChangeContents(
      state.parentStyle()->willChangeContents());
  state.style()->setWillChangeScrollPosition(
      state.parentStyle()->willChangeScrollPosition());
  state.style()->setWillChangeProperties(
      state.parentStyle()->willChangeProperties());
  state.style()->setSubtreeWillChangeContents(
      state.parentStyle()->subtreeWillChangeContents());
}

void StyleBuilderFunctions::applyValueCSSPropertyWillChange(
    StyleResolverState& state,
    const CSSValue& value) {
  bool willChangeContents = false;
  bool willChangeScrollPosition = false;
  Vector<CSSPropertyID> willChangeProperties;

  if (value.isIdentifierValue()) {
    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
  } else {
    DCHECK(value.isValueList());
    for (auto& willChangeValue : toCSSValueList(value)) {
      if (willChangeValue->isCustomIdentValue())
        willChangeProperties.push_back(
            toCSSCustomIdentValue(*willChangeValue).valueAsPropertyID());
      else if (toCSSIdentifierValue(*willChangeValue).getValueID() ==
               CSSValueContents)
        willChangeContents = true;
      else if (toCSSIdentifierValue(*willChangeValue).getValueID() ==
               CSSValueScrollPosition)
        willChangeScrollPosition = true;
      else
        NOTREACHED();
    }
  }
  state.style()->setWillChangeContents(willChangeContents);
  state.style()->setWillChangeScrollPosition(willChangeScrollPosition);
  state.style()->setWillChangeProperties(willChangeProperties);
  state.style()->setSubtreeWillChangeContents(
      willChangeContents || state.parentStyle()->subtreeWillChangeContents());
}

void StyleBuilderFunctions::applyInitialCSSPropertyContent(
    StyleResolverState& state) {
  state.style()->setContent(nullptr);
}

void StyleBuilderFunctions::applyInheritCSSPropertyContent(
    StyleResolverState&) {
  // FIXME: In CSS3, it will be possible to inherit content. In CSS2 it is not.
  // This note is a reminder that eventually "inherit" needs to be supported.
}

void StyleBuilderFunctions::applyValueCSSPropertyContent(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isIdentifierValue()) {
    DCHECK(toCSSIdentifierValue(value).getValueID() == CSSValueNormal ||
           toCSSIdentifierValue(value).getValueID() == CSSValueNone);
    state.style()->setContent(nullptr);
    return;
  }

  ContentData* firstContent = nullptr;
  ContentData* prevContent = nullptr;
  for (auto& item : toCSSValueList(value)) {
    ContentData* nextContent = nullptr;
    if (item->isImageGeneratorValue() || item->isImageSetValue() ||
        item->isImageValue()) {
      nextContent =
          ContentData::create(state.styleImage(CSSPropertyContent, *item));
    } else if (item->isCounterValue()) {
      const CSSCounterValue* counterValue = toCSSCounterValue(item.get());
      EListStyleType listStyleType = EListStyleType::kNone;
      CSSValueID listStyleIdent = counterValue->listStyle();
      if (listStyleIdent != CSSValueNone)
        listStyleType =
            static_cast<EListStyleType>(listStyleIdent - CSSValueDisc);
      std::unique_ptr<CounterContent> counter =
          WTF::wrapUnique(new CounterContent(
              AtomicString(counterValue->identifier()), listStyleType,
              AtomicString(counterValue->separator())));
      nextContent = ContentData::create(std::move(counter));
    } else if (item->isIdentifierValue()) {
      QuoteType quoteType;
      switch (toCSSIdentifierValue(*item).getValueID()) {
        default:
          NOTREACHED();
        case CSSValueOpenQuote:
          quoteType = OPEN_QUOTE;
          break;
        case CSSValueCloseQuote:
          quoteType = CLOSE_QUOTE;
          break;
        case CSSValueNoOpenQuote:
          quoteType = NO_OPEN_QUOTE;
          break;
        case CSSValueNoCloseQuote:
          quoteType = NO_CLOSE_QUOTE;
          break;
      }
      nextContent = ContentData::create(quoteType);
    } else {
      String string;
      if (item->isFunctionValue()) {
        const CSSFunctionValue* functionValue = toCSSFunctionValue(item.get());
        DCHECK_EQ(functionValue->functionType(), CSSValueAttr);
        // FIXME: Can a namespace be specified for an attr(foo)?
        if (state.style()->styleType() == PseudoIdNone)
          state.style()->setUnique();
        else
          state.parentStyle()->setUnique();
        QualifiedName attr(
            nullAtom, toCSSCustomIdentValue(functionValue->item(0)).value(),
            nullAtom);
        const AtomicString& value = state.element()->getAttribute(attr);
        string = value.isNull() ? emptyString : value.getString();
      } else {
        string = toCSSStringValue(*item).value();
      }
      if (prevContent && prevContent->isText()) {
        TextContentData* textContent = toTextContentData(prevContent);
        textContent->setText(textContent->text() + string);
        continue;
      }
      nextContent = ContentData::create(string);
    }

    if (!firstContent)
      firstContent = nextContent;
    else
      prevContent->setNext(nextContent);

    prevContent = nextContent;
  }
  DCHECK(firstContent);
  state.style()->setContent(firstContent);
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitLocale(
    StyleResolverState& state,
    const CSSValue& value) {
  if (value.isIdentifierValue()) {
    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
    state.fontBuilder().setLocale(nullptr);
  } else {
    state.fontBuilder().setLocale(
        LayoutLocale::get(AtomicString(toCSSStringValue(value).value())));
  }
}

void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppRegion(
    StyleResolverState&) {}

void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppRegion(
    StyleResolverState&) {}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitAppRegion(
    StyleResolverState& state,
    const CSSValue& value) {
  const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
  state.style()->setDraggableRegionMode(
      identifierValue.getValueID() == CSSValueDrag ? DraggableRegionDrag
                                                   : DraggableRegionNoDrag);
  state.document().setHasAnnotatedRegions(true);
}

void StyleBuilderFunctions::applyValueCSSPropertyWritingMode(
    StyleResolverState& state,
    const CSSValue& value) {
  state.setWritingMode(toCSSIdentifierValue(value).convertTo<WritingMode>());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitWritingMode(
    StyleResolverState& state,
    const CSSValue& value) {
  state.setWritingMode(toCSSIdentifierValue(value).convertTo<WritingMode>());
}

void StyleBuilderFunctions::applyValueCSSPropertyTextOrientation(
    StyleResolverState& state,
    const CSSValue& value) {
  state.setTextOrientation(
      toCSSIdentifierValue(value).convertTo<TextOrientation>());
}

void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(
    StyleResolverState& state,
    const CSSValue& value) {
  state.setTextOrientation(
      toCSSIdentifierValue(value).convertTo<TextOrientation>());
}

void StyleBuilderFunctions::applyValueCSSPropertyVariable(
    StyleResolverState& state,
    const CSSValue& value) {
  const CSSCustomPropertyDeclaration& declaration =
      toCSSCustomPropertyDeclaration(value);
  const AtomicString& name = declaration.name();
  const PropertyRegistration* registration = nullptr;
  const PropertyRegistry* registry = state.document().propertyRegistry();
  if (registry)
    registration = registry->registration(name);

  bool isInheritedProperty = !registration || registration->inherits();
  bool initial = declaration.isInitial(isInheritedProperty);
  bool inherit = declaration.isInherit(isInheritedProperty);
  DCHECK(!(initial && inherit));

  if (!initial && !inherit) {
    if (declaration.value()->needsVariableResolution()) {
      if (isInheritedProperty)
        state.style()->setUnresolvedInheritedVariable(name,
                                                      declaration.value());
      else
        state.style()->setUnresolvedNonInheritedVariable(name,
                                                         declaration.value());
      return;
    }

    if (!registration) {
      state.style()->setResolvedUnregisteredVariable(name, declaration.value());
      return;
    }

    const CSSValue* parsedValue =
        declaration.value()->parseForSyntax(registration->syntax());
    if (parsedValue) {
      DCHECK(parsedValue);
      if (isInheritedProperty)
        state.style()->setResolvedInheritedVariable(name, declaration.value(),
                                                    parsedValue);
      else
        state.style()->setResolvedNonInheritedVariable(
            name, declaration.value(), parsedValue);
      return;
    }
    if (isInheritedProperty)
      inherit = true;
    else
      initial = true;
  }
  DCHECK(initial ^ inherit);

  state.style()->removeVariable(name, isInheritedProperty);
  if (initial) {
    return;
  }

  DCHECK(inherit);
  CSSVariableData* parentValue =
      state.parentStyle()->getVariable(name, isInheritedProperty);
  const CSSValue* parentCSSValue =
      registration && parentValue
          ? state.parentStyle()->getRegisteredVariable(name,
                                                       isInheritedProperty)
          : nullptr;

  if (!isInheritedProperty) {
    DCHECK(registration);
    if (parentValue) {
      state.style()->setResolvedNonInheritedVariable(name, parentValue,
                                                     parentCSSValue);
    }
    return;
  }

  if (parentValue) {
    if (!registration) {
      state.style()->setResolvedUnregisteredVariable(name, parentValue);
    } else {
      state.style()->setResolvedInheritedVariable(name, parentValue,
                                                  parentCSSValue);
    }
  }
}

void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(
    StyleResolverState& state) {
  const SVGComputedStyle& parentSvgStyle = state.parentStyle()->svgStyle();
  EBaselineShift baselineShift = parentSvgStyle.baselineShift();
  SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
  svgStyle.setBaselineShift(baselineShift);
  if (baselineShift == BS_LENGTH)
    svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
}

void StyleBuilderFunctions::applyValueCSSPropertyBaselineShift(
    StyleResolverState& state,
    const CSSValue& value) {
  SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
  if (!value.isIdentifierValue()) {
    svgStyle.setBaselineShift(BS_LENGTH);
    svgStyle.setBaselineShiftValue(StyleBuilderConverter::convertLength(
        state, toCSSPrimitiveValue(value)));
    return;
  }
  switch (toCSSIdentifierValue(value).getValueID()) {
    case CSSValueBaseline:
      svgStyle.setBaselineShift(BS_LENGTH);
      svgStyle.setBaselineShiftValue(Length(Fixed));
      return;
    case CSSValueSub:
      svgStyle.setBaselineShift(BS_SUB);
      return;
    case CSSValueSuper:
      svgStyle.setBaselineShift(BS_SUPER);
      return;
    default:
      NOTREACHED();
  }
}

void StyleBuilderFunctions::applyInheritCSSPropertyPosition(
    StyleResolverState& state) {
  if (!state.parentNode()->isDocumentNode())
    state.style()->setPosition(state.parentStyle()->position());
}

void StyleBuilderFunctions::applyInitialCSSPropertyCaretColor(
    StyleResolverState& state) {
  StyleAutoColor color = StyleAutoColor::autoColor();
  if (state.applyPropertyToRegularStyle())
    state.style()->setCaretColor(color);
  if (state.applyPropertyToVisitedLinkStyle())
    state.style()->setVisitedLinkCaretColor(color);
}

void StyleBuilderFunctions::applyInheritCSSPropertyCaretColor(
    StyleResolverState& state) {
  StyleAutoColor color = state.parentStyle()->caretColor();
  if (state.applyPropertyToRegularStyle())
    state.style()->setCaretColor(color);
  if (state.applyPropertyToVisitedLinkStyle())
    state.style()->setVisitedLinkCaretColor(color);
}

void StyleBuilderFunctions::applyValueCSSPropertyCaretColor(
    StyleResolverState& state,
    const CSSValue& value) {
  if (state.applyPropertyToRegularStyle()) {
    state.style()->setCaretColor(
        StyleBuilderConverter::convertStyleAutoColor(state, value));
  }
  if (state.applyPropertyToVisitedLinkStyle()) {
    state.style()->setVisitedLinkCaretColor(
        StyleBuilderConverter::convertStyleAutoColor(state, value, true));
  }
}

}  // namespace blink