#include "config.h"
#include "core/css/CSSComputedStyleDeclaration.h"
-#include "CSSPropertyNames.h"
-#include "FontFamilyNames.h"
-#include "RuntimeEnabledFeatures.h"
-#include "StylePropertyShorthand.h"
-#include "bindings/v8/ExceptionState.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "core/CSSPropertyNames.h"
+#include "core/StylePropertyShorthand.h"
#include "core/animation/DocumentAnimations.h"
#include "core/css/BasicShapeFunctions.h"
-#include "core/css/CSSArrayFunctionValue.h"
#include "core/css/CSSAspectRatioValue.h"
#include "core/css/CSSBorderImage.h"
#include "core/css/CSSFilterValue.h"
#include "core/css/CSSGridLineNamesValue.h"
#include "core/css/CSSGridTemplateAreasValue.h"
#include "core/css/CSSLineBoxContainValue.h"
-#include "core/css/parser/BisonCSSParser.h"
#include "core/css/CSSPrimitiveValue.h"
#include "core/css/CSSPrimitiveValueMappings.h"
+#include "core/css/CSSPropertyMetadata.h"
#include "core/css/CSSReflectValue.h"
#include "core/css/CSSSelector.h"
#include "core/css/CSSShadowValue.h"
#include "core/css/CSSValuePool.h"
#include "core/css/Pair.h"
#include "core/css/Rect.h"
-#include "core/css/RuntimeCSSEnabled.h"
#include "core/css/StylePropertySet.h"
+#include "core/css/parser/CSSParser.h"
#include "core/css/resolver/StyleResolver.h"
#include "core/dom/Document.h"
#include "core/dom/ExceptionCode.h"
#include "core/rendering/RenderGrid.h"
#include "core/rendering/style/ContentData.h"
#include "core/rendering/style/CounterContent.h"
-#include "core/rendering/style/CursorList.h"
#include "core/rendering/style/RenderStyle.h"
#include "core/rendering/style/ShadowList.h"
#include "core/rendering/style/ShapeValue.h"
+#include "platform/FontFamilyNames.h"
+#include "platform/RuntimeEnabledFeatures.h"
#include "platform/fonts/FontFeatureSettings.h"
#include "wtf/text/StringBuilder.h"
-namespace WebCore {
+namespace blink {
// List of all properties we know how to compute, omitting shorthands.
// NOTE: Do not use this list, use computableProperties() instead
CSSPropertyFontFamily,
CSSPropertyFontKerning,
CSSPropertyFontSize,
+ CSSPropertyFontStretch,
CSSPropertyFontStyle,
CSSPropertyFontVariant,
CSSPropertyFontVariantLigatures,
CSSPropertyHeight,
CSSPropertyImageRendering,
CSSPropertyIsolation,
+ CSSPropertyJustifyItems,
CSSPropertyJustifySelf,
CSSPropertyLeft,
CSSPropertyLetterSpacing,
CSSPropertyWebkitAnimationPlayState,
CSSPropertyWebkitAnimationTimingFunction,
CSSPropertyWebkitAppearance,
+ CSSPropertyBackfaceVisibility,
CSSPropertyWebkitBackfaceVisibility,
CSSPropertyWebkitBackgroundClip,
CSSPropertyWebkitBackgroundComposite,
CSSPropertyGridAutoRows,
CSSPropertyGridColumnEnd,
CSSPropertyGridColumnStart,
+ CSSPropertyGridTemplateAreas,
CSSPropertyGridTemplateColumns,
CSSPropertyGridTemplateRows,
CSSPropertyGridRowEnd,
CSSPropertyWebkitMaskRepeat,
CSSPropertyWebkitMaskSize,
CSSPropertyOrder,
+ CSSPropertyPerspective,
CSSPropertyWebkitPerspective,
+ CSSPropertyPerspectiveOrigin,
CSSPropertyWebkitPerspectiveOrigin,
CSSPropertyWebkitPrintColorAdjust,
CSSPropertyWebkitRtlOrdering,
CSSPropertyShapeOutside,
- CSSPropertyShapePadding,
CSSPropertyShapeImageThreshold,
CSSPropertyShapeMargin,
CSSPropertyWebkitTapHighlightColor,
CSSPropertyWebkitTextSecurity,
CSSPropertyWebkitTextStrokeColor,
CSSPropertyWebkitTextStrokeWidth,
+ CSSPropertyTransform,
CSSPropertyWebkitTransform,
+ CSSPropertyTransformOrigin,
CSSPropertyWebkitTransformOrigin,
CSSPropertyTransformStyle,
CSSPropertyWebkitTransformStyle,
CSSPropertyWebkitUserSelect,
CSSPropertyWebkitWritingMode,
CSSPropertyWebkitAppRegion,
- CSSPropertyWebkitWrapFlow,
- CSSPropertyWebkitWrapThrough,
CSSPropertyBufferedRendering,
CSSPropertyClipPath,
CSSPropertyClipRule,
CSSPropertyAlignmentBaseline,
CSSPropertyBaselineShift,
CSSPropertyDominantBaseline,
- CSSPropertyKerning,
CSSPropertyTextAnchor,
CSSPropertyWritingMode,
CSSPropertyGlyphOrientationHorizontal,
{
DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
if (properties.isEmpty())
- RuntimeCSSEnabled::filterEnabledCSSPropertiesIntoVector(staticComputableProperties, WTF_ARRAY_LENGTH(staticComputableProperties), properties);
+ CSSPropertyMetadata::filterEnabledCSSPropertiesIntoVector(staticComputableProperties, WTF_ARRAY_LENGTH(staticComputableProperties), properties);
return properties;
}
return CSSReflectValue::create(direction.release(), offset.release(), valueForNinePieceImage(reflection->mask(), style));
}
-static PassRefPtrWillBeRawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer* layer, const RenderStyle& style)
+static PassRefPtrWillBeRawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const RenderStyle& style)
{
RefPtrWillBeRawPtr<CSSValueList> positionList = CSSValueList::createSpaceSeparated();
- if (layer->isBackgroundXOriginSet()) {
+ if (layer.isBackgroundXOriginSet()) {
ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
- positionList->append(cssValuePool().createValue(layer->backgroundXOrigin()));
+ positionList->append(cssValuePool().createValue(layer.backgroundXOrigin()));
}
- positionList->append(zoomAdjustedPixelValueForLength(layer->xPosition(), style));
- if (layer->isBackgroundYOriginSet()) {
+ positionList->append(zoomAdjustedPixelValueForLength(layer.xPosition(), style));
+ if (layer.isBackgroundYOriginSet()) {
ASSERT(propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
- positionList->append(cssValuePool().createValue(layer->backgroundYOrigin()));
+ positionList->append(cssValuePool().createValue(layer.backgroundYOrigin()));
}
- positionList->append(zoomAdjustedPixelValueForLength(layer->yPosition(), style));
+ positionList->append(zoomAdjustedPixelValueForLength(layer.yPosition(), style));
return positionList.release();
}
// FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
// In other words if left is auto and right is not auto, then left's computed value is negative right().
// So we should get the opposite length unit and see if it is auto.
- return cssValuePool().createValue(l);
+ return cssValuePool().createIdentifierValue(CSSValueAuto);
}
return zoomAdjustedPixelValueForLength(l, style);
Vector<RefPtr<FilterOperation> >::const_iterator end = style.filter().operations().end();
for (Vector<RefPtr<FilterOperation> >::const_iterator it = style.filter().operations().begin(); it != end; ++it) {
- FilterOperation* filterOperation = (*it).get();
+ FilterOperation* filterOperation = it->get();
switch (filterOperation->type()) {
case FilterOperation::REFERENCE:
filterValue = CSSFilterValue::create(CSSFilterValue::ReferenceFilterOperation);
{
const Vector<GridTrackSize>& trackSizes = direction == ForColumns ? style.gridTemplateColumns() : style.gridTemplateRows();
const OrderedNamedGridLines& orderedNamedGridLines = direction == ForColumns ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines();
+ bool isRenderGrid = renderer && renderer->isRenderGrid();
+
+ // Handle the 'none' case.
+ bool trackListIsEmpty = trackSizes.isEmpty();
+ if (isRenderGrid && trackListIsEmpty) {
+ // For grids we should consider every listed track, whether implicitly or explicitly created. If we don't have
+ // any explicit track and there are no children then there are no implicit tracks. We cannot simply check the
+ // number of rows/columns in our internal grid representation because it's always at least 1x1 (see r143331).
+ trackListIsEmpty = !toRenderBlock(renderer)->firstChild();
+ }
- // Handle the 'none' case here.
- if (!trackSizes.size()) {
+ if (trackListIsEmpty) {
ASSERT(orderedNamedGridLines.isEmpty());
return cssValuePool().createIdentifierValue(CSSValueNone);
}
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
- if (renderer && renderer->isRenderGrid()) {
+ if (isRenderGrid) {
const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toRenderGrid(renderer)->columnPositions() : toRenderGrid(renderer)->rowPositions();
// There are at least #tracks + 1 grid lines (trackPositions). Apart from that, the grid container can generate implicit grid tracks,
// so we'll have more trackPositions than trackSizes as the latter only contain the explicit grid.
ASSERT(trackPositions.size() - 1 >= trackSizes.size());
- for (size_t i = 0; i < trackSizes.size(); ++i) {
+ for (size_t i = 0; i < trackPositions.size() - 1; ++i) {
addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
list->append(zoomAdjustedPixelValue(trackPositions[i + 1] - trackPositions[i], style));
}
list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_STRING));
return list;
}
-static PassRefPtrWillBeRawPtr<CSSValue> createTransitionPropertyValue(const CSSAnimationData* animation)
+
+static PassRefPtrWillBeRawPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
{
- RefPtrWillBeRawPtr<CSSValue> propertyValue = nullptr;
- if (animation->animationMode() == CSSAnimationData::AnimateNone)
- propertyValue = cssValuePool().createIdentifierValue(CSSValueNone);
- else if (animation->animationMode() == CSSAnimationData::AnimateAll)
- propertyValue = cssValuePool().createIdentifierValue(CSSValueAll);
- else
- propertyValue = cssValuePool().createValue(getPropertyNameString(animation->property()), CSSPrimitiveValue::CSS_STRING);
- return propertyValue.release();
+ if (property.propertyType == CSSTransitionData::TransitionNone)
+ return cssValuePool().createIdentifierValue(CSSValueNone);
+ if (property.propertyType == CSSTransitionData::TransitionAll)
+ return cssValuePool().createIdentifierValue(CSSValueAll);
+ if (property.propertyType == CSSTransitionData::TransitionUnknown)
+ return cssValuePool().createValue(property.propertyString, CSSPrimitiveValue::CSS_STRING);
+ ASSERT(property.propertyType == CSSTransitionData::TransitionSingleProperty);
+ return cssValuePool().createValue(getPropertyNameString(property.propertyId), CSSPrimitiveValue::CSS_STRING);
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForTransitionProperty(const CSSAnimationDataList* animList)
+
+static PassRefPtrWillBeRawPtr<CSSValue> valueForTransitionProperty(const CSSTransitionData* transitionData)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- if (animList) {
- for (size_t i = 0; i < animList->size(); ++i)
- list->append(createTransitionPropertyValue(animList->animation(i)));
- } else
+ if (transitionData) {
+ for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
+ list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
+ } else {
list->append(cssValuePool().createIdentifierValue(CSSValueAll));
+ }
return list.release();
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDelay(const CSSAnimationDataList* animList)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDelay(const CSSTimingData* timingData)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- if (animList) {
- for (size_t i = 0; i < animList->size(); ++i)
- list->append(cssValuePool().createValue(animList->animation(i)->delay(), CSSPrimitiveValue::CSS_S));
+ if (timingData) {
+ for (size_t i = 0; i < timingData->delayList().size(); ++i)
+ list->append(cssValuePool().createValue(timingData->delayList()[i], CSSPrimitiveValue::CSS_S));
} else {
- // Note that initialAnimationDelay() is used for both transitions and animations
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
+ list->append(cssValuePool().createValue(CSSTimingData::initialDelay(), CSSPrimitiveValue::CSS_S));
}
return list.release();
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDuration(const CSSAnimationDataList* animList)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDuration(const CSSTimingData* timingData)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- if (animList) {
- for (size_t i = 0; i < animList->size(); ++i)
- list->append(cssValuePool().createValue(animList->animation(i)->duration(), CSSPrimitiveValue::CSS_S));
+ if (timingData) {
+ for (size_t i = 0; i < timingData->durationList().size(); ++i)
+ list->append(cssValuePool().createValue(timingData->durationList()[i], CSSPrimitiveValue::CSS_S));
} else {
- // Note that initialAnimationDuration() is used for both transitions and animations
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
+ list->append(cssValuePool().createValue(CSSTimingData::initialDuration(), CSSPrimitiveValue::CSS_S));
}
return list.release();
}
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationIterationCount(double iterationCount)
+{
+ if (iterationCount == std::numeric_limits<double>::infinity())
+ return cssValuePool().createIdentifierValue(CSSValueInfinite);
+ return cssValuePool().createValue(iterationCount, CSSPrimitiveValue::CSS_NUMBER);
+}
+
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationPlayState(EAnimPlayState playState)
+{
+ if (playState == AnimPlayStatePlaying)
+ return cssValuePool().createIdentifierValue(CSSValueRunning);
+ ASSERT(playState == AnimPlayStatePaused);
+ return cssValuePool().createIdentifierValue(CSSValuePaused);
+}
+
static PassRefPtrWillBeRawPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFunction)
{
switch (timingFunction->type()) {
case TimingFunction::StepsFunction:
{
const StepsTimingFunction* stepsTimingFunction = toStepsTimingFunction(timingFunction);
- if (stepsTimingFunction->subType() == StepsTimingFunction::Custom)
- return CSSStepsTimingFunctionValue::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtPosition());
+ StepsTimingFunction::StepAtPosition position = stepsTimingFunction->stepAtPosition();
+ int steps = stepsTimingFunction->numberOfSteps();
+ ASSERT(position == StepsTimingFunction::Start || position == StepsTimingFunction::End);
- CSSValueID valueId;
- switch (stepsTimingFunction->subType()) {
- case StepsTimingFunction::Start:
- valueId = CSSValueStepStart;
- break;
- case StepsTimingFunction::End:
- valueId = CSSValueStepEnd;
- break;
- default:
- ASSERT_NOT_REACHED();
- return nullptr;
- }
+ if (steps > 1)
+ return CSSStepsTimingFunctionValue::create(steps, position);
+ CSSValueID valueId = position == StepsTimingFunction::Start ? CSSValueStepStart : CSSValueStepEnd;
return cssValuePool().createIdentifierValue(valueId);
}
}
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationTimingFunction(const CSSAnimationDataList* animList)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationTimingFunction(const CSSTimingData* timingData)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- if (animList) {
- for (size_t i = 0; i < animList->size(); ++i)
- list->append(createTimingFunctionValue(animList->animation(i)->timingFunction()));
- } else
- // Note that initialAnimationTimingFunction() is used for both transitions and animations
- list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));
+ if (timingData) {
+ for (size_t i = 0; i < timingData->timingFunctionList().size(); ++i)
+ list->append(createTimingFunctionValue(timingData->timingFunctionList()[i].get()));
+ } else {
+ list->append(createTimingFunctionValue(CSSTimingData::initialTimingFunction().get()));
+ }
return list.release();
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationFillMode(unsigned fillMode)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationFillMode(Timing::FillMode fillMode)
{
switch (fillMode) {
- case AnimationFillModeNone:
+ case Timing::FillModeNone:
return cssValuePool().createIdentifierValue(CSSValueNone);
- case AnimationFillModeForwards:
+ case Timing::FillModeForwards:
return cssValuePool().createIdentifierValue(CSSValueForwards);
- case AnimationFillModeBackwards:
+ case Timing::FillModeBackwards:
return cssValuePool().createIdentifierValue(CSSValueBackwards);
- case AnimationFillModeBoth:
+ case Timing::FillModeBoth:
return cssValuePool().createIdentifierValue(CSSValueBoth);
default:
ASSERT_NOT_REACHED();
}
}
-static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDirection(CSSAnimationData::AnimationDirection direction)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForAnimationDirection(Timing::PlaybackDirection direction)
{
switch (direction) {
- case CSSAnimationData::AnimationDirectionNormal:
+ case Timing::PlaybackDirectionNormal:
return cssValuePool().createIdentifierValue(CSSValueNormal);
- case CSSAnimationData::AnimationDirectionAlternate:
+ case Timing::PlaybackDirectionAlternate:
return cssValuePool().createIdentifierValue(CSSValueAlternate);
- case CSSAnimationData::AnimationDirectionReverse:
+ case Timing::PlaybackDirectionReverse:
return cssValuePool().createIdentifierValue(CSSValueReverse);
- case CSSAnimationData::AnimationDirectionAlternateReverse:
+ case Timing::PlaybackDirectionAlternateReverse:
return cssValuePool().createIdentifierValue(CSSValueAlternateReverse);
default:
ASSERT_NOT_REACHED();
return CSSLineBoxContainValue::create(lineBoxContain);
}
-CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
+CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(PassRefPtrWillBeRawPtr<Node> n, bool allowVisitedStyle, const String& pseudoElementName)
: m_node(n)
, m_allowVisitedStyle(allowVisitedStyle)
+#if !ENABLE(OILPAN)
, m_refCount(1)
+#endif
{
unsigned nameWithoutColonsStart = pseudoElementName[0] == ':' ? (pseudoElementName[1] == ':' ? 2 : 1) : 0;
m_pseudoElementSpecifier = CSSSelector::pseudoId(CSSSelector::parsePseudoType(
- AtomicString(pseudoElementName.substring(nameWithoutColonsStart))));
+ AtomicString(pseudoElementName.substring(nameWithoutColonsStart)), false));
}
CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration()
{
}
+#if !ENABLE(OILPAN)
void CSSComputedStyleDeclaration::ref()
{
++m_refCount;
if (!--m_refCount)
delete this;
}
+#endif
String CSSComputedStyleDeclaration::cssText() const
{
if (i)
result.append(' ');
result.append(getPropertyName(properties[i]));
- result.append(": ", 2);
+ result.appendLiteral(": ");
result.append(getPropertyValue(properties[i]));
result.append(';');
}
return zoomAdjustedPixelValue(style->fontDescription().computedPixelSize(), *style);
}
-bool CSSComputedStyleDeclaration::useFixedFontDefaultSize() const
+FixedPitchFontType CSSComputedStyleDeclaration::fixedPitchFontType() const
{
if (!m_node)
- return false;
+ return NonFixedPitchFont;
RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);
if (!style)
- return false;
+ return NonFixedPitchFont;
- return style->fontDescription().useFixedDefaultSize();
+ return style->fontDescription().fixedPitchFontType();
}
PassRefPtrWillBeRawPtr<CSSValue> CSSComputedStyleDeclaration::valueForShadowData(const ShadowData& shadow, const RenderStyle& style, bool useSpread) const
return list.release();
}
-PassRefPtrWillBeRawPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(CSSPropertyID propertyID) const
-{
- return getPropertyCSSValue(propertyID, UpdateLayout);
-}
-
static CSSValueID identifierForFamily(const AtomicString& family)
{
if (family == FontFamilyNames::webkit_cursive)
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
for (const ContentData* contentData = style.contentData(); contentData; contentData = contentData->next()) {
if (contentData->isCounter()) {
- const CounterContent* counter = static_cast<const CounterContentData*>(contentData)->counter();
+ const CounterContent* counter = toCounterContentData(contentData)->counter();
ASSERT(counter);
list->append(cssValuePool().createValue(counter->identifier(), CSSPrimitiveValue::CSS_COUNTER_NAME));
} else if (contentData->isImage()) {
- const StyleImage* image = static_cast<const ImageContentData*>(contentData)->image();
+ const StyleImage* image = toImageContentData(contentData)->image();
ASSERT(image);
list->append(image->cssValue());
- } else if (contentData->isText())
- list->append(cssValuePool().createValue(static_cast<const TextContentData*>(contentData)->text(), CSSPrimitiveValue::CSS_STRING));
+ } else if (contentData->isText()) {
+ list->append(cssValuePool().createValue(toTextContentData(contentData)->text(), CSSPrimitiveValue::CSS_STRING));
+ }
}
return list.release();
}
return zoomAdjustedPixelValue(style.fontDescription().computedPixelSize(), style);
}
+static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontStretch(RenderStyle& style)
+{
+ return cssValuePool().createValue(style.fontDescription().stretch());
+}
+
static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontStyle(RenderStyle& style)
{
- if (style.fontDescription().style() == FontStyleItalic)
- return cssValuePool().createIdentifierValue(CSSValueItalic);
- return cssValuePool().createIdentifierValue(CSSValueNormal);
+ return cssValuePool().createValue(style.fontDescription().style());
}
static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontVariant(RenderStyle& style)
{
- if (style.fontDescription().variant() == FontVariantSmallCaps)
- return cssValuePool().createIdentifierValue(CSSValueSmallCaps);
- return cssValuePool().createIdentifierValue(CSSValueNormal);
+ return cssValuePool().createValue(style.fontDescription().variant());
}
static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFontWeight(RenderStyle& style)
{
- switch (style.fontDescription().weight()) {
- case FontWeight100:
- return cssValuePool().createIdentifierValue(CSSValue100);
- case FontWeight200:
- return cssValuePool().createIdentifierValue(CSSValue200);
- case FontWeight300:
- return cssValuePool().createIdentifierValue(CSSValue300);
- case FontWeightNormal:
- return cssValuePool().createIdentifierValue(CSSValueNormal);
- case FontWeight500:
- return cssValuePool().createIdentifierValue(CSSValue500);
- case FontWeight600:
- return cssValuePool().createIdentifierValue(CSSValue600);
- case FontWeightBold:
- return cssValuePool().createIdentifierValue(CSSValueBold);
- case FontWeight800:
- return cssValuePool().createIdentifierValue(CSSValue800);
- case FontWeight900:
- return cssValuePool().createIdentifierValue(CSSValue900);
- }
- ASSERT_NOT_REACHED();
- return cssValuePool().createIdentifierValue(CSSValueNormal);
+ return cssValuePool().createValue(style.fontDescription().weight());
}
static PassRefPtrWillBeRawPtr<CSSValue> valueForShape(const RenderStyle& style, ShapeValue* shapeValue)
{
if (!shapeValue)
return cssValuePool().createIdentifierValue(CSSValueNone);
- if (shapeValue->type() == ShapeValue::Outside)
- return cssValuePool().createIdentifierValue(CSSValueOutsideShape);
if (shapeValue->type() == ShapeValue::Box)
- return cssValuePool().createValue(shapeValue->layoutBox());
+ return cssValuePool().createValue(shapeValue->cssBox());
if (shapeValue->type() == ShapeValue::Image) {
if (shapeValue->image())
return shapeValue->image()->cssValue();
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
list->append(valueForBasicShape(style, shapeValue->shape()));
- if (shapeValue->layoutBox() != BoxMissing)
- list->append(cssValuePool().createValue(shapeValue->layoutBox()));
+ if (shapeValue->cssBox() != BoxMissing)
+ list->append(cssValuePool().createValue(shapeValue->cssBox()));
return list.release();
}
case CSSPropertyLeft:
case CSSPropertyRight:
case CSSPropertyTop:
+ case CSSPropertyPerspectiveOrigin:
case CSSPropertyWebkitPerspectiveOrigin:
+ case CSSPropertyTransform:
case CSSPropertyWebkitTransform:
+ case CSSPropertyTransformOrigin:
case CSSPropertyWebkitTransformOrigin:
case CSSPropertyWidth:
case CSSPropertyWebkitFilter:
}
}
-PassRefPtr<RenderStyle> CSSComputedStyleDeclaration::computeRenderStyle(CSSPropertyID propertyID) const
+PassRefPtr<RenderStyle> CSSComputedStyleDeclaration::computeRenderStyle() const
{
Node* styledNode = this->styledNode();
ASSERT(styledNode);
return m_node.get();
}
-static PassRefPtrWillBeRawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment)
+static ItemPosition resolveAlignmentAuto(ItemPosition position, Node* element)
+{
+ if (position != ItemPositionAuto)
+ return position;
+
+ bool isFlexOrGrid = element && element->computedStyle()
+ && element->computedStyle()->isDisplayFlexibleOrGridBox();
+
+ return isFlexOrGrid ? ItemPositionStretch : ItemPositionStart;
+}
+
+static PassRefPtrWillBeRawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
{
RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
+ if (positionType == LegacyPosition)
+ result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
result->append(CSSPrimitiveValue::create(itemPosition));
if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
result->append(CSSPrimitiveValue::create(overflowAlignment));
+ ASSERT(result->length() <= 2);
return result.release();
}
if (updateLayout) {
Document& document = styledNode->document();
- // A timing update may be required if a compositor animation is running or animations
- // have been updated via the api.
+ // A timing update may be required if a compositor animation is running.
DocumentAnimations::updateAnimationTimingForGetComputedStyle(*styledNode, propertyID);
document.updateRenderTreeForNodeIfNeeded(styledNode);
styledNode = this->styledNode();
renderer = styledNode->renderer();
- style = computeRenderStyle(propertyID);
+ style = computeRenderStyle();
bool forceFullLayout = isLayoutDependent(propertyID, style, renderer)
|| styledNode->isInShadowTree()
if (forceFullLayout) {
document.updateLayoutIgnorePendingStylesheets();
styledNode = this->styledNode();
- style = computeRenderStyle(propertyID);
+ style = computeRenderStyle();
renderer = styledNode->renderer();
}
} else {
- style = computeRenderStyle(propertyID);
+ style = computeRenderStyle();
}
if (!style)
return m_allowVisitedStyle ? cssValuePool().createColorValue(style->visitedDependentColor(CSSPropertyBackgroundColor).rgb()) : currentColorOrValidColor(*style, style->backgroundColor());
case CSSPropertyBackgroundImage:
case CSSPropertyWebkitMaskImage: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskImage ? style->maskLayers() : style->backgroundLayers();
- if (!layers)
- return cssValuePool().createIdentifierValue(CSSValueNone);
-
- if (!layers->next()) {
- if (layers->image())
- return layers->image()->cssValue();
-
- return cssValuePool().createIdentifierValue(CSSValueNone);
- }
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskImage ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next()) {
if (currLayer->image())
list->append(currLayer->image()->cssValue());
else
case CSSPropertyBackgroundSize:
case CSSPropertyWebkitBackgroundSize:
case CSSPropertyWebkitMaskSize: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskSize ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return valueForFillSize(layers->size(), *style);
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskSize ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
list->append(valueForFillSize(currLayer->size(), *style));
-
return list.release();
}
case CSSPropertyBackgroundRepeat:
case CSSPropertyWebkitMaskRepeat: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskRepeat ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return valueForFillRepeat(layers->repeatX(), layers->repeatY());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskRepeat ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
list->append(valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
-
return list.release();
}
case CSSPropertyMaskSourceType: {
- const FillLayer* layers = style->maskLayers();
-
- if (!layers)
- return cssValuePool().createIdentifierValue(CSSValueNone);
-
- if (!layers->next())
- return valueForFillSourceType(layers->maskSourceType());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ for (const FillLayer* currLayer = &style->maskLayers(); currLayer; currLayer = currLayer->next())
list->append(valueForFillSourceType(currLayer->maskSourceType()));
-
return list.release();
}
case CSSPropertyWebkitBackgroundComposite:
case CSSPropertyWebkitMaskComposite: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskComposite ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return cssValuePool().createValue(layers->composite());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskComposite ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
list->append(cssValuePool().createValue(currLayer->composite()));
-
return list.release();
}
case CSSPropertyBackgroundAttachment: {
- const FillLayer* layers = style->backgroundLayers();
- if (!layers->next())
- return cssValuePool().createValue(layers->attachment());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ for (const FillLayer* currLayer = &style->backgroundLayers(); currLayer; currLayer = currLayer->next())
list->append(cssValuePool().createValue(currLayer->attachment()));
-
return list.release();
}
case CSSPropertyBackgroundClip:
case CSSPropertyWebkitBackgroundOrigin:
case CSSPropertyWebkitMaskClip:
case CSSPropertyWebkitMaskOrigin: {
- const FillLayer* layers = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? style->maskLayers() : style->backgroundLayers();
bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;
- if (!layers->next()) {
- EFillBox box = isClip ? layers->clip() : layers->origin();
- return cssValuePool().createValue(box);
- }
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
+ const FillLayer* currLayer = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next()) {
EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
list->append(cssValuePool().createValue(box));
}
-
return list.release();
}
case CSSPropertyBackgroundPosition:
case CSSPropertyWebkitMaskPosition: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPosition ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return createPositionListForLayer(propertyID, layers, *style);
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
- list->append(createPositionListForLayer(propertyID, currLayer, *style));
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPosition ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
+ list->append(createPositionListForLayer(propertyID, *currLayer, *style));
return list.release();
}
case CSSPropertyBackgroundPositionX:
case CSSPropertyWebkitMaskPositionX: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionX ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return cssValuePool().createValue(layers->xPosition());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
- list->append(cssValuePool().createValue(currLayer->xPosition()));
-
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionX ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
+ list->append(zoomAdjustedPixelValueForLength(currLayer->xPosition(), *style));
return list.release();
}
case CSSPropertyBackgroundPositionY:
case CSSPropertyWebkitMaskPositionY: {
- const FillLayer* layers = propertyID == CSSPropertyWebkitMaskPositionY ? style->maskLayers() : style->backgroundLayers();
- if (!layers->next())
- return cssValuePool().createValue(layers->yPosition());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
- list->append(cssValuePool().createValue(currLayer->yPosition()));
-
+ const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionY ? &style->maskLayers() : &style->backgroundLayers();
+ for (; currLayer; currLayer = currLayer->next())
+ list->append(zoomAdjustedPixelValueForLength(currLayer->yPosition(), *style));
return list.release();
}
case CSSPropertyBorderCollapse:
return cssValuePool().createIdentifierValue(CSSValueAuto);
return cssValuePool().createValue(style->columnCount(), CSSPrimitiveValue::CSS_NUMBER);
case CSSPropertyColumnFill:
- if (RuntimeEnabledFeatures::regionBasedColumnsEnabled())
- return cssValuePool().createValue(style->columnFill());
- return nullptr;
+ ASSERT(RuntimeEnabledFeatures::regionBasedColumnsEnabled());
+ return cssValuePool().createValue(style->columnFill());
case CSSPropertyWebkitColumnGap:
if (style->hasNormalColumnGap())
return cssValuePool().createIdentifierValue(CSSValueNormal);
case CSSPropertyAlignContent:
return cssValuePool().createValue(style->alignContent());
case CSSPropertyAlignItems:
- return valueForItemPositionWithOverflowAlignment(style->alignItems(), style->alignItemsOverflowAlignment());
- case CSSPropertyAlignSelf: {
- ItemPosition alignSelf = style->alignSelf();
- if (alignSelf == ItemPositionAuto) {
- Node* parent = styledNode->parentNode();
- if (parent && parent->computedStyle())
- alignSelf = parent->computedStyle()->alignItems();
- else
- alignSelf = ItemPositionStretch;
- }
- return valueForItemPositionWithOverflowAlignment(alignSelf, style->alignSelfOverflowAlignment());
- }
+ return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->alignItems(), styledNode), style->alignItemsOverflowAlignment(), NonLegacyPosition);
+ case CSSPropertyAlignSelf:
+ return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->alignSelf(), styledNode->parentNode()), style->alignSelfOverflowAlignment(), NonLegacyPosition);
case CSSPropertyFlex:
return valuesForShorthandProperty(flexShorthand());
case CSSPropertyFlexBasis:
- return cssValuePool().createValue(style->flexBasis());
+ return zoomAdjustedPixelValueForLength(style->flexBasis(), *style);
case CSSPropertyFlexDirection:
return cssValuePool().createValue(style->flexDirection());
case CSSPropertyFlexFlow:
computedFont->style = valueForFontStyle(*style);
computedFont->variant = valueForFontVariant(*style);
computedFont->weight = valueForFontWeight(*style);
+ computedFont->stretch = valueForFontStretch(*style);
computedFont->size = valueForFontSize(*style);
computedFont->lineHeight = valueForLineHeight(*style);
computedFont->family = valueForFontFamily(*style);
}
case CSSPropertyFontSize:
return valueForFontSize(*style);
+ case CSSPropertyFontStretch:
+ return valueForFontStretch(*style);
case CSSPropertyFontStyle:
return valueForFontStyle(*style);
case CSSPropertyFontVariant:
}
return list.release();
}
- case CSSPropertyGridAutoFlow:
- return cssValuePool().createValue(style->gridAutoFlow());
+ case CSSPropertyGridAutoFlow: {
+ RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
+ switch (style->gridAutoFlow()) {
+ case AutoFlowRow:
+ case AutoFlowRowDense:
+ list->append(cssValuePool().createIdentifierValue(CSSValueRow));
+ break;
+ case AutoFlowColumn:
+ case AutoFlowColumnDense:
+ list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
+ break;
+ case AutoFlowStackRow:
+ case AutoFlowStackColumn:
+ list->append(cssValuePool().createIdentifierValue(CSSValueStack));
+ break;
+ default:
+ ASSERT_NOT_REACHED();
+ }
+ switch (style->gridAutoFlow()) {
+ case AutoFlowRowDense:
+ case AutoFlowColumnDense:
+ list->append(cssValuePool().createIdentifierValue(CSSValueDense));
+ break;
+ case AutoFlowStackRow:
+ list->append(cssValuePool().createIdentifierValue(CSSValueRow));
+ break;
+ case AutoFlowStackColumn:
+ list->append(cssValuePool().createIdentifierValue(CSSValueColumn));
+ break;
+ default:
+ // Do nothing.
+ break;
+ }
+
+ return list.release();
+ }
// Specs mention that getComputedStyle() should return the used value of the property instead of the computed
// one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like
// grid-auto-columns: 2fr; cannot be resolved to a value in pixels as the '2fr' means very different things
return valuesForGridShorthand(gridRowShorthand());
case CSSPropertyGridArea:
return valuesForGridShorthand(gridAreaShorthand());
-
+ case CSSPropertyGridTemplate:
+ return valuesForGridShorthand(gridTemplateShorthand());
+ case CSSPropertyGrid:
+ return valuesForGridShorthand(gridShorthand());
case CSSPropertyGridTemplateAreas:
if (!style->namedGridAreaRowCount()) {
ASSERT(!style->namedGridAreaColumnCount());
return CSSPrimitiveValue::create(style->imageRendering());
case CSSPropertyIsolation:
return cssValuePool().createValue(style->isolation());
+ case CSSPropertyJustifyItems:
+ return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->justifyItems(), styledNode), style->justifyItemsOverflowAlignment(), style->justifyItemsPositionType());
case CSSPropertyJustifySelf:
- return valueForItemPositionWithOverflowAlignment(style->justifySelf(), style->justifySelfOverflowAlignment());
+ return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style->justifySelf(), styledNode->parentNode()), style->justifySelfOverflowAlignment(), NonLegacyPosition);
case CSSPropertyLeft:
return valueForPositionOffset(*style, CSSPropertyLeft, renderer);
case CSSPropertyLetterSpacing:
return cssValuePool().createValue(style->userModify());
case CSSPropertyMaxHeight: {
const Length& maxHeight = style->maxHeight();
- if (maxHeight.isUndefined())
+ if (maxHeight.isMaxSizeNone())
return cssValuePool().createIdentifierValue(CSSValueNone);
return zoomAdjustedPixelValueForLength(maxHeight, *style);
}
case CSSPropertyMaxWidth: {
const Length& maxWidth = style->maxWidth();
- if (maxWidth.isUndefined())
+ if (maxWidth.isMaxSizeNone())
return cssValuePool().createIdentifierValue(CSSValueNone);
return zoomAdjustedPixelValueForLength(maxWidth, *style);
}
case CSSPropertyTextAlignLast:
return cssValuePool().createValue(style->textAlignLast());
case CSSPropertyTextDecoration:
- return valuesForShorthandProperty(textDecorationShorthand());
+ if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
+ return valuesForShorthandProperty(textDecorationShorthand());
+ // Fall through.
case CSSPropertyTextDecorationLine:
return renderTextDecorationFlagsToCSSValue(style->textDecoration());
case CSSPropertyTextDecorationStyle:
}
}
case CSSPropertyTextIndent: {
+ // If RuntimeEnabledFeatures::css3TextEnabled() returns false or text-indent has only one value(<length> | <percentage>),
+ // getPropertyCSSValue() returns CSSValue.
+ // If RuntimeEnabledFeatures::css3TextEnabled() returns true and text-indent has each-line or hanging,
+ // getPropertyCSSValue() returns CSSValueList.
RefPtrWillBeRawPtr<CSSValue> textIndent = zoomAdjustedPixelValueForLength(style->textIndent(), *style);
- if (RuntimeEnabledFeatures::css3TextEnabled() && style->textIndentLine() == TextIndentEachLine) {
+ if (RuntimeEnabledFeatures::css3TextEnabled() && (style->textIndentLine() == TextIndentEachLine || style->textIndentType() == TextIndentHanging)) {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
list->append(textIndent.release());
- list->append(cssValuePool().createIdentifierValue(CSSValueEachLine));
+ if (style->textIndentLine() == TextIndentEachLine)
+ list->append(cssValuePool().createIdentifierValue(CSSValueEachLine));
+ if (style->textIndentType() == TextIndentHanging)
+ list->append(cssValuePool().createIdentifierValue(CSSValueHanging));
return list.release();
}
return textIndent.release();
case BASELINE_MIDDLE:
return cssValuePool().createIdentifierValue(CSSValueWebkitBaselineMiddle);
case LENGTH:
- return cssValuePool().createValue(style->verticalAlignLength());
+ return zoomAdjustedPixelValueForLength(style->verticalAlignLength(), *style);
}
ASSERT_NOT_REACHED();
return nullptr;
ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
case CSSPropertyWebkitAnimationDirection: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- const CSSAnimationDataList* t = style->animations();
- if (t) {
- for (size_t i = 0; i < t->size(); ++i)
- list->append(valueForAnimationDirection(t->animation(i)->direction()));
- } else
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
+ for (size_t i = 0; i < animationData->directionList().size(); ++i)
+ list->append(valueForAnimationDirection(animationData->directionList()[i]));
+ } else {
list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
+ }
return list.release();
}
case CSSPropertyAnimationDuration:
ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
case CSSPropertyWebkitAnimationFillMode: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- const CSSAnimationDataList* t = style->animations();
- if (t) {
- for (size_t i = 0; i < t->size(); ++i)
- list->append(valueForAnimationFillMode(t->animation(i)->fillMode()));
- } else
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
+ for (size_t i = 0; i < animationData->fillModeList().size(); ++i)
+ list->append(valueForAnimationFillMode(animationData->fillModeList()[i]));
+ } else {
list->append(cssValuePool().createIdentifierValue(CSSValueNone));
+ }
return list.release();
}
case CSSPropertyAnimationIterationCount:
ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
case CSSPropertyWebkitAnimationIterationCount: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- const CSSAnimationDataList* t = style->animations();
- if (t) {
- for (size_t i = 0; i < t->size(); ++i) {
- double iterationCount = t->animation(i)->iterationCount();
- if (iterationCount == CSSAnimationData::IterationCountInfinite)
- list->append(cssValuePool().createIdentifierValue(CSSValueInfinite));
- else
- list->append(cssValuePool().createValue(iterationCount, CSSPrimitiveValue::CSS_NUMBER));
- }
- } else
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
+ for (size_t i = 0; i < animationData->iterationCountList().size(); ++i)
+ list->append(valueForAnimationIterationCount(animationData->iterationCountList()[i]));
+ } else {
+ list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+ }
return list.release();
}
case CSSPropertyAnimationName:
ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
case CSSPropertyWebkitAnimationName: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- const CSSAnimationDataList* t = style->animations();
- if (t) {
- for (size_t i = 0; i < t->size(); ++i)
- list->append(cssValuePool().createValue(t->animation(i)->name(), CSSPrimitiveValue::CSS_STRING));
- } else
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
+ for (size_t i = 0; i < animationData->nameList().size(); ++i)
+ list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::CSS_STRING));
+ } else {
list->append(cssValuePool().createIdentifierValue(CSSValueNone));
+ }
return list.release();
}
case CSSPropertyAnimationPlayState:
ASSERT(RuntimeEnabledFeatures::cssAnimationUnprefixedEnabled());
case CSSPropertyWebkitAnimationPlayState: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- const CSSAnimationDataList* t = style->animations();
- if (t) {
- for (size_t i = 0; i < t->size(); ++i) {
- int prop = t->animation(i)->playState();
- if (prop == AnimPlayStatePlaying)
- list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
- else
- list->append(cssValuePool().createIdentifierValue(CSSValuePaused));
- }
- } else
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
+ for (size_t i = 0; i < animationData->playStateList().size(); ++i)
+ list->append(valueForAnimationPlayState(animationData->playStateList()[i]));
+ } else {
list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
+ }
return list.release();
}
case CSSPropertyAnimationTimingFunction:
return valueForAnimationTimingFunction(style->animations());
case CSSPropertyAnimation:
case CSSPropertyWebkitAnimation: {
- const CSSAnimationDataList* animations = style->animations();
- if (animations) {
+ const CSSAnimationData* animationData = style->animations();
+ if (animationData) {
RefPtrWillBeRawPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
- for (size_t i = 0; i < animations->size(); ++i) {
+ for (size_t i = 0; i < animationData->nameList().size(); ++i) {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
- const CSSAnimationData* animation = animations->animation(i);
- list->append(cssValuePool().createValue(animation->name(), CSSPrimitiveValue::CSS_STRING));
- list->append(cssValuePool().createValue(animation->duration(), CSSPrimitiveValue::CSS_S));
- list->append(createTimingFunctionValue(animation->timingFunction()));
- list->append(cssValuePool().createValue(animation->delay(), CSSPrimitiveValue::CSS_S));
- if (animation->iterationCount() == CSSAnimationData::IterationCountInfinite)
- list->append(cssValuePool().createIdentifierValue(CSSValueInfinite));
- else
- list->append(cssValuePool().createValue(animation->iterationCount(), CSSPrimitiveValue::CSS_NUMBER));
- list->append(valueForAnimationDirection(animation->direction()));
- list->append(valueForAnimationFillMode(animation->fillMode()));
- if (animation->playState() == AnimPlayStatePaused)
- list->append(cssValuePool().createIdentifierValue(CSSValuePaused));
- else
- list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
+ list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::CSS_STRING));
+ list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::CSS_S));
+ list->append(createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
+ list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->delayList(), i), CSSPrimitiveValue::CSS_S));
+ list->append(valueForAnimationIterationCount(CSSTimingData::getRepeated(animationData->iterationCountList(), i)));
+ list->append(valueForAnimationDirection(CSSTimingData::getRepeated(animationData->directionList(), i)));
+ list->append(valueForAnimationFillMode(CSSTimingData::getRepeated(animationData->fillModeList(), i)));
+ list->append(valueForAnimationPlayState(CSSTimingData::getRepeated(animationData->playStateList(), i)));
animationsList->append(list);
}
return animationsList.release();
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
// animation-name default value.
list->append(cssValuePool().createIdentifierValue(CSSValueNone));
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
- list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
- list->append(valueForAnimationDirection(CSSAnimationData::initialAnimationDirection()));
- list->append(valueForAnimationFillMode(CSSAnimationData::initialAnimationFillMode()));
+ list->append(cssValuePool().createValue(CSSAnimationData::initialDuration(), CSSPrimitiveValue::CSS_S));
+ list->append(createTimingFunctionValue(CSSAnimationData::initialTimingFunction().get()));
+ list->append(cssValuePool().createValue(CSSAnimationData::initialDelay(), CSSPrimitiveValue::CSS_S));
+ list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::CSS_NUMBER));
+ list->append(valueForAnimationDirection(CSSAnimationData::initialDirection()));
+ list->append(valueForAnimationFillMode(CSSAnimationData::initialFillMode()));
// Initial animation-play-state.
list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
return list.release();
if (!style->hasAspectRatio())
return cssValuePool().createIdentifierValue(CSSValueNone);
return CSSAspectRatioValue::create(style->aspectRatioNumerator(), style->aspectRatioDenominator());
+ case CSSPropertyBackfaceVisibility:
case CSSPropertyWebkitBackfaceVisibility:
return cssValuePool().createIdentifierValue((style->backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
case CSSPropertyWebkitBorderImage:
case CSSPropertyWebkitMarginTopCollapse:
case CSSPropertyWebkitMarginBeforeCollapse:
return cssValuePool().createValue(style->marginBeforeCollapse());
+ case CSSPropertyPerspective:
case CSSPropertyWebkitPerspective:
if (!style->hasPerspective())
return cssValuePool().createIdentifierValue(CSSValueNone);
return zoomAdjustedPixelValue(style->perspective(), *style);
+ case CSSPropertyPerspectiveOrigin:
case CSSPropertyWebkitPerspectiveOrigin: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
if (renderer) {
case CSSPropertyBorderTopRightRadius:
return valueForBorderRadiusCorner(style->borderTopRightRadius(), *style);
case CSSPropertyClip: {
- if (!style->hasClip())
+ if (style->hasAutoClip())
return cssValuePool().createIdentifierValue(CSSValueAuto);
RefPtrWillBeRawPtr<Rect> rect = Rect::create();
rect->setTop(zoomAdjustedPixelValue(style->clip().top().value(), *style));
}
case CSSPropertySpeak:
return cssValuePool().createValue(style->speak());
+ case CSSPropertyTransform:
case CSSPropertyWebkitTransform:
return computedTransform(renderer, *style);
+ case CSSPropertyTransformOrigin:
case CSSPropertyWebkitTransformOrigin: {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
if (renderer) {
return valueForAnimationTimingFunction(style->transitions());
case CSSPropertyTransition:
case CSSPropertyWebkitTransition: {
- const CSSAnimationDataList* animList = style->transitions();
- if (animList) {
+ const CSSTransitionData* transitionData = style->transitions();
+ if (transitionData) {
RefPtrWillBeRawPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();
- for (size_t i = 0; i < animList->size(); ++i) {
+ for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
- const CSSAnimationData* animation = animList->animation(i);
- list->append(createTransitionPropertyValue(animation));
- list->append(cssValuePool().createValue(animation->duration(), CSSPrimitiveValue::CSS_S));
- list->append(createTimingFunctionValue(animation->timingFunction()));
- list->append(cssValuePool().createValue(animation->delay(), CSSPrimitiveValue::CSS_S));
+ list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
+ list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->durationList(), i), CSSPrimitiveValue::CSS_S));
+ list->append(createTimingFunctionValue(CSSTimingData::getRepeated(transitionData->timingFunctionList(), i).get()));
+ list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->delayList(), i), CSSPrimitiveValue::CSS_S));
transitionsList->append(list);
}
return transitionsList.release();
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
// transition-property default value.
list->append(cssValuePool().createIdentifierValue(CSSValueAll));
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDuration(), CSSPrimitiveValue::CSS_S));
- list->append(createTimingFunctionValue(CSSAnimationData::initialAnimationTimingFunction().get()));
- list->append(cssValuePool().createValue(CSSAnimationData::initialAnimationDelay(), CSSPrimitiveValue::CSS_S));
+ list->append(cssValuePool().createValue(CSSTransitionData::initialDuration(), CSSPrimitiveValue::CSS_S));
+ list->append(createTimingFunctionValue(CSSTransitionData::initialTimingFunction().get()));
+ list->append(cssValuePool().createValue(CSSTransitionData::initialDelay(), CSSPrimitiveValue::CSS_S));
return list.release();
}
case CSSPropertyPointerEvents:
return CSSPrimitiveValue::create(toReferenceClipPathOperation(operation)->url(), CSSPrimitiveValue::CSS_URI);
}
return cssValuePool().createIdentifierValue(CSSValueNone);
- case CSSPropertyWebkitWrapFlow:
- return cssValuePool().createValue(style->wrapFlow());
case CSSPropertyShapeMargin:
- return cssValuePool().createValue(style->shapeMargin());
- case CSSPropertyShapePadding:
- return cssValuePool().createValue(style->shapePadding());
+ return cssValuePool().createValue(style->shapeMargin(), *style);
case CSSPropertyShapeImageThreshold:
return cssValuePool().createValue(style->shapeImageThreshold(), CSSPrimitiveValue::CSS_NUMBER);
case CSSPropertyShapeOutside:
return valueForShape(*style, style->shapeOutside());
- case CSSPropertyWebkitWrapThrough:
- return cssValuePool().createValue(style->wrapThrough());
case CSSPropertyWebkitFilter:
return valueForFilter(renderer, *style);
case CSSPropertyMixBlendMode:
return cssValuePool().createValue(style->blendMode());
case CSSPropertyBackgroundBlendMode: {
- const FillLayer* layers = style->backgroundLayers();
- if (!layers->next())
- return cssValuePool().createValue(layers->blendMode());
-
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
- for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next())
+ for (const FillLayer* currLayer = &style->backgroundLayers(); currLayer; currLayer = currLayer->next())
list->append(cssValuePool().createValue(currLayer->blendMode()));
-
return list.release();
}
case CSSPropertyBackground:
case CSSPropertyBackgroundRepeatX:
case CSSPropertyBackgroundRepeatY:
break;
- case CSSPropertyInternalCallback:
- // This property is hidden from the web.
- return nullptr;
/* Unimplemented CSS 3 properties (including CSS3 shorthand properties) */
case CSSPropertyWebkitTextEmphasis:
- case CSSPropertyTextLineThroughColor:
- case CSSPropertyTextLineThroughMode:
- case CSSPropertyTextLineThroughStyle:
- case CSSPropertyTextLineThroughWidth:
- case CSSPropertyTextOverlineColor:
- case CSSPropertyTextOverlineMode:
- case CSSPropertyTextOverlineStyle:
- case CSSPropertyTextOverlineWidth:
- case CSSPropertyTextUnderlineColor:
- case CSSPropertyTextUnderlineMode:
- case CSSPropertyTextUnderlineStyle:
- case CSSPropertyTextUnderlineWidth:
break;
/* Directional properties are resolved by resolveDirectionAwareProperty() before the switch. */
ASSERT_NOT_REACHED();
break;
- // FIXME: crbug.com/154772 Unimplemented css-transforms properties
- case CSSPropertyBackfaceVisibility:
- case CSSPropertyPerspective:
- case CSSPropertyPerspectiveOrigin:
- case CSSPropertyTransform:
- case CSSPropertyTransformOrigin:
- break;
-
/* Unimplemented @font-face properties */
- case CSSPropertyFontStretch:
case CSSPropertySrc:
case CSSPropertyUnicodeRange:
break;
case CSSPropertyStopOpacity:
case CSSPropertyColorInterpolation:
case CSSPropertyColorInterpolationFilters:
- case CSSPropertyColorProfile:
case CSSPropertyColorRendering:
case CSSPropertyFill:
case CSSPropertyFillOpacity:
case CSSPropertyDominantBaseline:
case CSSPropertyGlyphOrientationHorizontal:
case CSSPropertyGlyphOrientationVertical:
- case CSSPropertyKerning:
case CSSPropertyTextAnchor:
case CSSPropertyVectorEffect:
case CSSPropertyPaintOrder:
case CSSPropertyWritingMode:
return getSVGPropertyCSSValue(propertyID, DoNotUpdateLayout);
+
+ case CSSPropertyAll:
+ return nullptr;
}
logUnimplementedPropertyID(propertyID);
unsigned CSSComputedStyleDeclaration::length() const
{
- Node* node = m_node.get();
- if (!node)
+ if (!m_node || !m_node->inActiveDocument())
return 0;
-
- RenderStyle* style = node->computedStyle(m_pseudoElementSpecifier);
- if (!style)
- return 0;
-
return computableProperties().size();
}
String CSSComputedStyleDeclaration::getPropertyValue(const String& propertyName)
{
CSSPropertyID propertyID = cssPropertyID(propertyName);
- if (!propertyID || !RuntimeCSSEnabled::isCSSPropertyEnabled(propertyID))
+ if (!propertyID)
return String();
+ ASSERT(CSSPropertyMetadata::isEnabledProperty(propertyID));
return getPropertyValue(propertyID);
}
return list.release();
}
-} // namespace WebCore
+void CSSComputedStyleDeclaration::trace(Visitor* visitor)
+{
+ visitor->trace(m_node);
+ CSSStyleDeclaration::trace(visitor);
+}
+
+} // namespace blink
projects / platform / framework / web / crosswalk.git / blobdiff