PassRefPtrWillBeRawPtr<CSSFunctionValue> FilterStyleInterpolation::fromInterpolableValue(const InterpolableValue& value, CSSValueID functionType, InterpolationRange)
{
const InterpolableList& list = toInterpolableList(value);
size_t length = list.length();
RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(functionType);
for (size_t i = 0; i < length; ++i) {
switch (functionType) {
case CSSValueGrayscale:
case CSSValueInvert:
case CSSValueOpacity:
case CSSValueSepia:
result->append(CSSPrimitiveValue::create(clampTo<double>(toInterpolableNumber(list.get(i))->value(), 0, 1), CSSPrimitiveValue::UnitType::Number));
break;
case CSSValueBrightness:
case CSSValueContrast:
case CSSValueSaturate:
result->append(CSSPrimitiveValue::create(clampTo<double>(toInterpolableNumber(list.get(i))->value(), 0), CSSPrimitiveValue::UnitType::Number));
break;
case CSSValueHueRotate:
result->append(CSSPrimitiveValue::create(toInterpolableNumber(list.get(i))->value(), CSSPrimitiveValue::UnitType::Degrees));
break;
case CSSValueBlur:
result->append(LengthStyleInterpolation::fromInterpolableValue(*list.get(i), RangeNonNegative));
break;
case CSSValueDropShadow:
case CSSValueUrl:
default:
ASSERT_NOT_REACHED();
break;
}
}
return result.release();
}
TEST_F(AnimationDoubleStyleInterpolationTest, ValueAutoMotionRotation)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
list->append(CSSPrimitiveValue::createIdentifier(CSSValueAuto));
list->append(CSSPrimitiveValue::create(90, CSSPrimitiveValue::CSS_DEG));
RefPtrWillBeRawPtr<CSSValue> value = roundTripMotionRotation(list.release(), true);
testValueListMotionRotation(value, 90, true);
}
PassRefPtrWillBeRawPtr<CSSValue> DoubleStyleInterpolation::interpolableValueToMotionRotation(InterpolableValue* value, bool flag)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
if (flag)
list->append(CSSPrimitiveValue::createIdentifier(CSSValueAuto));
ASSERT(value->isNumber());
list->append(CSSPrimitiveValue::create(toInterpolableNumber(value)->value(), CSSPrimitiveValue::UnitType::Degrees));
return list.release();
}
PassRefPtrWillBeRawPtr<CSSFunctionValue> ScaleTransformComponent::toCSSValue() const
{
RefPtrWillBeRawPtr<CSSFunctionValue> result = CSSFunctionValue::create(m_is2D ? CSSValueScale : CSSValueScale3d);
result->append(cssValuePool().createValue(m_x, CSSPrimitiveValue::UnitType::Number));
result->append(cssValuePool().createValue(m_y, CSSPrimitiveValue::UnitType::Number));
if (!m_is2D)
result->append(cssValuePool().createValue(m_z, CSSPrimitiveValue::UnitType::Number));
return result.release();
}
String CSSContentDistributionValue::customCSSText() const
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
if (m_distribution != CSSValueInvalid)
list->append(distribution());
if (m_position != CSSValueInvalid)
list->append(position());
if (m_overflow != CSSValueInvalid)
list->append(overflow());
return list.release()->customCSSText();
}
TEST_F(AnimationDoubleStyleInterpolationTest, ZeroValueFixedMotionRotation)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
list->append(CSSPrimitiveValue::create(0, CSSPrimitiveValue::CSS_DEG));
RefPtrWillBeRawPtr<CSSValue> value = roundTripMotionRotation(list.release(), false);
testValueListMotionRotation(value, 0, false);
}
PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGNumberListInterpolationType::appliedSVGValue(const InterpolableValue& interpolableValue, const NonInterpolableValue*) const
{
RefPtrWillBeRawPtr<SVGNumberList> result = SVGNumberList::create();
const InterpolableList& list = toInterpolableList(interpolableValue);
for (size_t i = 0; i < list.length(); i++)
result->append(SVGNumber::create(toInterpolableNumber(list.get(i))->value()));
return result.release();
}
PassRefPtrWillBeRawPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
RefPtrWillBeRawPtr<DOMStringList> objectStoreNames = DOMStringList::create(DOMStringList::IndexedDB);
for (const auto& it : m_metadata.objectStores)
objectStoreNames->append(it.value.name);
objectStoreNames->sort();
return objectStoreNames.release();
}
PassRefPtrWillBeRawPtr<DOMStringList> IDBDatabase::objectStoreNames() const
{
RefPtrWillBeRawPtr<DOMStringList> objectStoreNames = DOMStringList::create(DOMStringList::IndexedDB);
for (IDBDatabaseMetadata::ObjectStoreMap::const_iterator it = m_metadata.objectStores.begin(); it != m_metadata.objectStores.end(); ++it)
objectStoreNames->append(it->value.name);
objectStoreNames->sort();
return objectStoreNames.release();
}
PassRefPtrWillBeRawPtr<CSSValue> TransformValue::toCSSValue() const
{
RefPtrWillBeRawPtr<CSSValueList> transformCSSValue = CSSValueList::createSpaceSeparated();
for (size_t i = 0; i < m_transformComponents.size(); i++) {
transformCSSValue->append(m_transformComponents[i]->toCSSValue());
}
return transformCSSValue;
}
PassRefPtrWillBeRawPtr<DOMStringList> IDBObjectStore::indexNames() const
{
IDB_TRACE("IDBObjectStore::indexNames");
RefPtrWillBeRawPtr<DOMStringList> indexNames = DOMStringList::create();
for (IDBObjectStoreMetadata::IndexMap::const_iterator it = m_metadata.indexes.begin(); it != m_metadata.indexes.end(); ++it)
indexNames->append(it->value.name);
indexNames->sort();
return indexNames.release();
}
PassRefPtrWillBeRawPtr<SVGPropertyBase> PathSVGInterpolation::fromInterpolableValue(const InterpolableValue& value, const Vector<SVGPathSegType>& pathSegTypes, SVGPathElement* element)
{
const InterpolableList& listValue = toInterpolableList(value);
RefPtrWillBeRawPtr<SVGPathSegList> result = SVGPathSegList::create(element);
SubPathCoordinates coordinates;
for (size_t i = 0; i < listValue.length(); i++)
result->append(pathSegFromInterpolableValue(*listValue.get(i), pathSegTypes.at(i), coordinates, element));
return result.release();
}
PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGTransformListInterpolationType::appliedSVGValue(const InterpolableValue& interpolableValue, const NonInterpolableValue* nonInterpolableValue) const
{
RefPtrWillBeRawPtr<SVGTransformList> result = SVGTransformList::create();
const InterpolableList& list = toInterpolableList(interpolableValue);
const Vector<SVGTransformType>& transformTypes = toSVGTransformNonInterpolableValue(nonInterpolableValue)->transformTypes();
for (size_t i = 0; i < list.length(); ++i)
result->append(fromInterpolableValue(*list.get(i), transformTypes.at(i)));
return result.release();
}
PassRefPtrWillBeRawPtr<DOMStringList> IDBObjectStore::indexNames() const
{
IDB_TRACE("IDBObjectStore::indexNames");
RefPtrWillBeRawPtr<DOMStringList> indexNames = DOMStringList::create(DOMStringList::IndexedDB);
for (const auto& it : m_metadata.indexes)
indexNames->append(it.value.name);
indexNames->sort();
return indexNames.release();
}
PassRefPtrWillBeRawPtr<DOMStringList> Location::ancestorOrigins() const
{
RefPtrWillBeRawPtr<DOMStringList> origins = DOMStringList::create();
if (!m_frame)
return origins.release();
for (LocalFrame* frame = m_frame->tree().parent(); frame; frame = frame->tree().parent())
origins->append(frame->document()->securityOrigin()->toString());
return origins.release();
}
TEST_F(ListStyleInterpolationTest, ShadowListMultipleValuesTest)
{
RefPtrWillBeRawPtr<CSSValueList> expectedList = CSSValueList::createCommaSeparated();
RefPtrWillBeRawPtr<CSSShadowValue> shadowValue = createShadowValue();
for (size_t i = 0; i < 10; i++) {
expectedList->append(shadowValue);
}
compareShadowList(expectedList, shadowRoundTrip(expectedList));
}
TEST_F(ListStyleInterpolationTest, LengthListMultipleValuesTest)
{
RefPtrWillBeRawPtr<CSSValueList> expectedList = CSSValueList::createCommaSeparated();
for (size_t i = 0; i < 10; i++) {
RefPtrWillBeRawPtr<CSSPrimitiveValue> lengthValue = CSSPrimitiveValue::create(static_cast<double>(i), CSSPrimitiveValue::UnitType::Pixels);
expectedList->append(lengthValue);
}
compareLengthLists(expectedList, lengthRoundTrip(expectedList, RangeNonNegative));
}
PassRefPtrWillBeRawPtr<DOMStringList> IDBTransaction::objectStoreNames() const
{
if (m_mode == WebIDBTransactionModeVersionChange)
return m_database->objectStoreNames();
RefPtrWillBeRawPtr<DOMStringList> objectStoreNames = DOMStringList::create(DOMStringList::IndexedDB);
for (const String& name : m_objectStoreNames)
objectStoreNames->append(name);
objectStoreNames->sort();
return objectStoreNames.release();
}
void IDBRequest::onSuccess(const Vector<String>& stringList)
{
IDB_TRACE("IDBRequest::onSuccess(StringList)");
if (!shouldEnqueueEvent())
return;
RefPtrWillBeRawPtr<DOMStringList> domStringList = DOMStringList::create();
for (size_t i = 0; i < stringList.size(); ++i)
domStringList->append(stringList[i]);
onSuccessInternal(IDBAny::create(domStringList.release()));
}
PassRefPtrWillBeRawPtr<DOMStringList> Location::ancestorOrigins() const
{
RefPtrWillBeRawPtr<DOMStringList> origins = DOMStringList::create();
if (!m_frame)
return origins.release();
// FIXME: We do not yet have access to remote frame's origin.
for (Frame* frame = m_frame->tree().parent(); frame; frame = frame->tree().parent()) {
if (frame->isLocalFrame())
origins->append(toLocalFrame(frame)->document()->securityOrigin()->toString());
}
return origins.release();
}
PassRefPtrWillBeRawPtr<CSSValueList> SVGFontFaceSrcElement::srcValue() const
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
for (SVGElement* element = Traversal<SVGElement>::firstChild(*this); element; element = Traversal<SVGElement>::nextSibling(*element)) {
RefPtrWillBeRawPtr<CSSFontFaceSrcValue> srcValue = nullptr;
if (isSVGFontFaceUriElement(*element))
srcValue = toSVGFontFaceUriElement(*element).srcValue();
else if (isSVGFontFaceNameElement(*element))
srcValue = toSVGFontFaceNameElement(*element).srcValue();
if (srcValue && srcValue->resource().length())
list->append(srcValue);
}
return list;
}
static v8::Handle<v8::Value> toV8(const IDBKeyPath& value, v8::Handle<v8::Object> creationContext, v8::Isolate* isolate)
{
switch (value.type()) {
case IDBKeyPath::NullType:
return v8::Null(isolate);
case IDBKeyPath::StringType:
return v8String(isolate, value.string());
case IDBKeyPath::ArrayType:
RefPtrWillBeRawPtr<DOMStringList> keyPaths = DOMStringList::create();
for (Vector<String>::const_iterator it = value.array().begin(); it != value.array().end(); ++it)
keyPaths->append(*it);
return toV8(keyPaths.release(), creationContext, isolate);
}
ASSERT_NOT_REACHED();
return v8::Undefined(isolate);
}
PassRefPtrWillBeRawPtr<FileList> Clipboard::files() const
{
RefPtrWillBeRawPtr<FileList> files = FileList::create();
if (!canReadData())
return files.release();
for (size_t i = 0; i < m_dataObject->length(); ++i) {
if (m_dataObject->item(i)->kind() == DataObjectItem::FileKind) {
RefPtrWillBeRawPtr<Blob> blob = m_dataObject->item(i)->getAsFile();
if (blob && blob->isFile())
files->append(toFile(blob.get()));
}
}
return files.release();
}
void SVGFontFaceElement::rebuildFontFace()
{
if (!inDocument()) {
ASSERT(!m_fontElement);
return;
}
bool describesParentFont = parentNode()->hasTagName(SVGNames::fontTag);
RefPtrWillBeRawPtr<CSSValueList> list;
if (describesParentFont) {
m_fontElement = toSVGFontElement(parentNode());
list = CSSValueList::createCommaSeparated();
list->append(CSSFontFaceSrcValue::createLocal(fontFamily()));
} else {
m_fontElement = 0;
// we currently ignore all but the last src element, alternatively we could concat them
for (Node* child = lastChild(); child && !list; child = child->previousSibling()) {
if (child->hasTagName(font_face_srcTag)) {
list = toSVGFontFaceSrcElement(child)->srcValue();
break;
}
}
}
if (!list || !list->length())
return;
// Parse in-memory CSS rules
m_fontFaceRule->mutableProperties()->addParsedProperty(CSSProperty(CSSPropertySrc, list));
if (describesParentFont) {
// Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
RefPtrWillBeRawPtr<CSSValue> src = m_fontFaceRule->properties()->getPropertyCSSValue(CSSPropertySrc);
CSSValueList* srcList = toCSSValueList(src.get());
unsigned srcLength = srcList ? srcList->length() : 0;
for (unsigned i = 0; i < srcLength; i++) {
if (CSSFontFaceSrcValue* item = toCSSFontFaceSrcValue(srcList->itemWithoutBoundsCheck(i)))
item->setSVGFontFaceElement(this);
}
}
document().styleResolverChanged(RecalcStyleDeferred);
}
static PassRefPtrWillBeRawPtr<CSSValueList> parseSimpleTransformList(CharType*& pos, CharType* end)
{
RefPtrWillBeRawPtr<CSSValueList> transformList = nullptr;
while (pos < end) {
while (pos < end && isCSSSpace(*pos))
++pos;
RefPtrWillBeRawPtr<CSSFunctionValue> transformValue = parseSimpleTransformValue(pos, end);
if (!transformValue)
return nullptr;
if (!transformList)
transformList = CSSValueList::createSpaceSeparated();
transformList->append(transformValue.release());
if (pos < end) {
if (isCSSSpace(*pos))
return nullptr;
}
}
return transformList.release();
}
PassRefPtrWillBeRawPtr<SVGTransformList> SVGTransformList::create(SVGTransformType transformType, const String& value)
{
RefPtrWillBeRawPtr<SVGTransform> transform = nullptr;
if (value.isEmpty()) {
} else if (value.is8Bit()) {
const LChar* ptr = value.characters8();
const LChar* end = ptr + value.length();
transform = parseTransformOfType(transformType, ptr, end);
} else {
const UChar* ptr = value.characters16();
const UChar* end = ptr + value.length();
transform = parseTransformOfType(transformType, ptr, end);
}
RefPtrWillBeRawPtr<SVGTransformList> svgTransformList = SVGTransformList::create();
if (transform)
svgTransformList->append(transform);
return svgTransformList.release();
}
void SVGFontFaceElement::rebuildFontFace()
{
if (!inDocument()) {
ASSERT(!m_fontElement);
return;
}
bool describesParentFont = isSVGFontElement(*parentNode());
RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
if (describesParentFont) {
m_fontElement = toSVGFontElement(parentNode());
list = CSSValueList::createCommaSeparated();
list->append(CSSFontFaceSrcValue::createLocal(fontFamily()));
} else {
m_fontElement = nullptr;
// we currently ignore all but the last src element, alternatively we could concat them
if (SVGFontFaceSrcElement* element = Traversal<SVGFontFaceSrcElement>::lastChild(*this))
list = element->srcValue();
}
if (!list || !list->length())
return;
// Parse in-memory CSS rules
m_fontFaceRule->mutableProperties().addParsedProperty(CSSProperty(CSSPropertySrc, list));
if (describesParentFont) {
// Traverse parsed CSS values and associate CSSFontFaceSrcValue elements with ourselves.
RefPtrWillBeRawPtr<CSSValue> src = m_fontFaceRule->properties().getPropertyCSSValue(CSSPropertySrc);
CSSValueList* srcList = toCSSValueList(src.get());
unsigned srcLength = srcList ? srcList->length() : 0;
for (unsigned i = 0; i < srcLength; i++) {
if (CSSFontFaceSrcValue* item = toCSSFontFaceSrcValue(srcList->item(i)))
item->setSVGFontFaceElement(this);
}
}
document().styleResolverChanged();
}
PassRefPtrWillBeRawPtr<CSSValueList> CSSValueList::copy()
{
RefPtrWillBeRawPtr<CSSValueList> newList = nullptr;
switch (m_valueListSeparator) {
case SpaceSeparator:
newList = createSpaceSeparated();
break;
case CommaSeparator:
newList = createCommaSeparated();
break;
case SlashSeparator:
newList = createSlashSeparated();
break;
default:
ASSERT_NOT_REACHED();
}
for (size_t index = 0; index < m_values.size(); index++)
newList->append(m_values[index]);
return newList.release();
}
static PassRefPtrWillBeRawPtr<CSSValue> paintOrderToCSSValueList(EPaintOrder paintorder)
{
RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
do {
EPaintOrderType paintOrderType = (EPaintOrderType)(paintorder & ((1 << kPaintOrderBitwidth) - 1));
switch (paintOrderType) {
case PT_FILL:
case PT_STROKE:
case PT_MARKERS:
list->append(CSSPrimitiveValue::create(paintOrderType));
break;
case PT_NONE:
default:
ASSERT_NOT_REACHED();
break;
}
} while (paintorder >>= kPaintOrderBitwidth);
return list.release();
}
PassOwnPtr<InterpolationValue> CSSImageListInterpolationType::maybeConvertValue(const CSSValue& value, const StyleResolverState&, ConversionCheckers&) const
{
if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueNone)
return nullptr;
RefPtrWillBeRawPtr<CSSValueList> tempList = nullptr;
if (!value.isBaseValueList()) {
tempList = CSSValueList::createCommaSeparated();
tempList->append(const_cast<CSSValue*>(&value)); // Take ref.
}
const CSSValueList& valueList = tempList ? *tempList : toCSSValueList(value);
const size_t length = valueList.length();
OwnPtr<InterpolableList> interpolableList = InterpolableList::create(length);
Vector<RefPtr<NonInterpolableValue>> nonInterpolableValues(length);
for (size_t i = 0; i < length; i++) {
InterpolationComponent component = CSSImageInterpolationType::maybeConvertCSSValue(*valueList.item(i), false);
if (!component)
return nullptr;
interpolableList->set(i, component.interpolableValue.release());
nonInterpolableValues[i] = component.nonInterpolableValue.release();
}
return InterpolationValue::create(*this, interpolableList.release(), NonInterpolableList::create(nonInterpolableValues));
}
