void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder, const WebCore::FilterOperations& filters)
{
encoder << static_cast<uint32_t>(filters.size());
for (size_t i = 0; i < filters.size(); ++i) {
const FilterOperation& filter = *filters.at(i);
FilterOperation::OperationType type = filter.type();
encoder.encodeEnum(type);
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE:
encoder << static_cast<double>(downcast<BasicColorMatrixFilterOperation>(filter).amount());
break;
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY:
encoder << static_cast<double>(downcast<BasicComponentTransferFilterOperation>(filter).amount());
break;
case FilterOperation::BLUR:
ArgumentCoder<Length>::encode(encoder, downcast<BlurFilterOperation>(filter).stdDeviation());
break;
case FilterOperation::DROP_SHADOW: {
const DropShadowFilterOperation& shadow = downcast<DropShadowFilterOperation>(filter);
ArgumentCoder<IntPoint>::encode(encoder, shadow.location());
encoder << static_cast<int32_t>(shadow.stdDeviation());
ArgumentCoder<Color>::encode(encoder, shadow.color());
break;
}
case FilterOperation::REFERENCE:
case FilterOperation::PASSTHROUGH:
case FilterOperation::DEFAULT:
case FilterOperation::NONE:
break;
}
}
}
bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
{
uint32_t size;
if (!decoder->decodeUInt32(size))
return false;
Vector<RefPtr<FilterOperation> >& operations = filters.operations();
for (size_t i = 0; i < size; ++i) {
FilterOperation::OperationType type;
RefPtr<FilterOperation> filter;
if (!decoder->decodeEnum(type))
return false;
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicColorMatrixFilterOperation::create(value, type);
break;
}
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicComponentTransferFilterOperation::create(value, type);
break;
}
case FilterOperation::BLUR: {
Length length;
if (!ArgumentCoder<Length>::decode(decoder, length))
return false;
filter = BlurFilterOperation::create(length, type);
break;
}
case FilterOperation::DROP_SHADOW: {
IntPoint location;
int32_t stdDeviation;
Color color;
if (!ArgumentCoder<IntPoint>::decode(decoder, location))
return false;
if (!decoder->decodeInt32(stdDeviation))
return false;
if (!ArgumentCoder<Color>::decode(decoder, color))
return false;
filter = DropShadowFilterOperation::create(location, stdDeviation, color, type);
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM:
// Custom Filters are converted to VALIDATED_CUSTOM before reaching this point.
ASSERT_NOT_REACHED();
break;
case FilterOperation::VALIDATED_CUSTOM: {
// FIXME: CustomFilterOperation should not need the meshType.
// https://bugs.webkit.org/show_bug.cgi?id=102529
CustomFilterMeshType meshType;
if (!decoder->decodeEnum(meshType))
return false;
int programID = 0;
if (!decoder->decode(programID))
return false;
uint32_t parametersSize;
if (!decoder->decodeUInt32(parametersSize))
return false;
CustomFilterParameterList parameters(parametersSize);
for (size_t i = 0; i < parametersSize; ++i) {
String name;
CustomFilterParameter::ParameterType parameterType;
if (!decoder->decode(name))
return false;
if (!decoder->decodeEnum(parameterType))
return false;
switch (parameterType) {
case CustomFilterParameter::ARRAY: {
RefPtr<CustomFilterArrayParameter> arrayParameter = CustomFilterArrayParameter::create(name);
uint32_t arrayParameterSize;
if (!decoder->decodeUInt32(arrayParameterSize))
return false;
double arrayParameterValue;
for (size_t j = 0; j < arrayParameterSize; ++j) {
if (!decoder->decode(arrayParameterValue))
return false;
arrayParameter->addValue(arrayParameterValue);
}
parameters[i] = arrayParameter.release();
break;
}
case CustomFilterParameter::NUMBER: {
RefPtr<CustomFilterNumberParameter> numberParameter = CustomFilterNumberParameter::create(name);
uint32_t numberParameterSize;
if (!decoder->decodeUInt32(numberParameterSize))
return false;
double numberParameterValue;
for (size_t j = 0; j < numberParameterSize; ++j) {
if (!decoder->decode(numberParameterValue))
return false;
numberParameter->addValue(numberParameterValue);
}
parameters[i] = numberParameter.release();
break;
}
case CustomFilterParameter::TRANSFORM: {
RefPtr<CustomFilterTransformParameter> transformParameter = CustomFilterTransformParameter::create(name);
TransformOperations operations;
if (!ArgumentCoder<TransformOperations>::decode(decoder, operations))
return false;
transformParameter->setOperations(operations);
parameters[i] = transformParameter.release();
break;
}
}
}
unsigned meshRows;
unsigned meshColumns;
if (!decoder->decode(meshRows))
return false;
if (!decoder->decode(meshColumns))
return false;
// At this point the Shaders are already validated, so we just use WebCustomFilterOperation for transportation.
filter = WebCustomFilterOperation::create(0, programID, parameters, meshRows, meshColumns, meshType);
break;
}
#endif
default:
break;
}
if (filter)
operations.append(filter);
}
return true;
}
void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder, const WebCore::FilterOperations& filters)
{
encoder << static_cast<uint32_t>(filters.size());
for (size_t i = 0; i < filters.size(); ++i) {
const FilterOperation* filter = filters.at(i);
FilterOperation::OperationType type = filter->getOperationType();
encoder.encodeEnum(type);
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE:
encoder << static_cast<double>(static_cast<const BasicColorMatrixFilterOperation*>(filter)->amount());
break;
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY:
encoder << static_cast<double>(static_cast<const BasicComponentTransferFilterOperation*>(filter)->amount());
break;
case FilterOperation::BLUR:
ArgumentCoder<Length>::encode(encoder, static_cast<const BlurFilterOperation*>(filter)->stdDeviation());
break;
case FilterOperation::DROP_SHADOW: {
const DropShadowFilterOperation* shadow = static_cast<const DropShadowFilterOperation*>(filter);
ArgumentCoder<IntPoint>::encode(encoder, shadow->location());
encoder << static_cast<int32_t>(shadow->stdDeviation());
ArgumentCoder<Color>::encode(encoder, shadow->color());
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM:
// Custom Filters are converted to VALIDATED_CUSTOM before reaching this point.
ASSERT_NOT_REACHED();
break;
case FilterOperation::VALIDATED_CUSTOM: {
const ValidatedCustomFilterOperation* customOperation = static_cast<const ValidatedCustomFilterOperation*>(filter);
ASSERT(customOperation->validatedProgram());
RefPtr<CustomFilterValidatedProgram> program = customOperation->validatedProgram();
ASSERT(program->isInitialized());
ASSERT(program->platformCompiledProgram());
ASSERT(program->platformCompiledProgram()->client());
WebCustomFilterProgramProxy* customFilterProgramProxy = static_cast<WebCustomFilterProgramProxy*>(program->platformCompiledProgram()->client());
const CustomFilterProgramInfo& programInfo = program->programInfo();
// FIXME: CustomFilterOperation should not need the meshType, it should just be encoded in the program itself.
// https://bugs.webkit.org/show_bug.cgi?id=102529
encoder.encodeEnum(programInfo.meshType());
encoder << customFilterProgramProxy->id();
CustomFilterParameterList parameters = customOperation->parameters();
encoder << static_cast<uint32_t>(parameters.size());
for (size_t i = 0; i < parameters.size(); ++i) {
RefPtr<CustomFilterParameter> parameter = parameters[i];
encoder << parameter->name();
encoder.encodeEnum(parameter->parameterType());
switch (parameter->parameterType()) {
case CustomFilterParameter::ARRAY: {
CustomFilterArrayParameter* arrayParameter = static_cast<CustomFilterArrayParameter*>(parameter.get());
encoder << static_cast<uint32_t>(arrayParameter->size());
for (size_t j = 0; j < arrayParameter->size(); ++j)
encoder << arrayParameter->valueAt(j);
break;
}
case CustomFilterParameter::NUMBER: {
CustomFilterNumberParameter* nubmerParameter = static_cast<CustomFilterNumberParameter*>(parameter.get());
encoder << static_cast<uint32_t>(nubmerParameter->size());
for (size_t j = 0; j < nubmerParameter->size(); ++j)
encoder << nubmerParameter->valueAt(j);
break;
}
case CustomFilterParameter::TRANSFORM: {
CustomFilterTransformParameter* transformParameter = static_cast<CustomFilterTransformParameter*>(parameter.get());
ArgumentCoder<TransformOperations>::encode(encoder, transformParameter->operations());
break;
}
}
}
encoder << customOperation->meshRows();
encoder << customOperation->meshColumns();
break;
}
#endif
default:
break;
}
}
}
bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder& decoder, WebCore::FilterOperations& filters)
{
uint32_t size;
if (!decoder.decode(size))
return false;
Vector<RefPtr<FilterOperation> >& operations = filters.operations();
for (size_t i = 0; i < size; ++i) {
FilterOperation::OperationType type;
RefPtr<FilterOperation> filter;
if (!decoder.decodeEnum(type))
return false;
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE: {
double value;
if (!decoder.decode(value))
return false;
filter = BasicColorMatrixFilterOperation::create(value, type);
break;
}
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY: {
double value;
if (!decoder.decode(value))
return false;
filter = BasicComponentTransferFilterOperation::create(value, type);
break;
}
case FilterOperation::BLUR: {
Length length;
if (!ArgumentCoder<Length>::decode(decoder, length))
return false;
filter = BlurFilterOperation::create(length);
break;
}
case FilterOperation::DROP_SHADOW: {
IntPoint location;
int32_t stdDeviation;
Color color;
if (!ArgumentCoder<IntPoint>::decode(decoder, location))
return false;
if (!decoder.decode(stdDeviation))
return false;
if (!ArgumentCoder<Color>::decode(decoder, color))
return false;
filter = DropShadowFilterOperation::create(location, stdDeviation, color);
break;
}
case FilterOperation::REFERENCE:
case FilterOperation::PASSTHROUGH:
case FilterOperation::DEFAULT:
case FilterOperation::NONE:
break;
}
if (filter)
operations.append(filter);
}
return true;
}
bool ArgumentCoder<WebCore::FilterOperations>::decode(ArgumentDecoder* decoder, WebCore::FilterOperations& filters)
{
uint32_t size;
if (!decoder->decodeUInt32(size))
return false;
Vector<RefPtr<FilterOperation> >& operations = filters.operations();
for (size_t i = 0; i < size; ++i) {
FilterOperation::OperationType type;
RefPtr<FilterOperation> filter;
if (!decoder->decodeEnum(type))
return false;
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicColorMatrixFilterOperation::create(value, type);
break;
}
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY: {
double value;
if (!decoder->decodeDouble(value))
return false;
filter = BasicComponentTransferFilterOperation::create(value, type);
break;
}
case FilterOperation::BLUR: {
Length length;
if (!ArgumentCoder<Length>::decode(decoder, length))
return false;
filter = BlurFilterOperation::create(length, type);
break;
}
case FilterOperation::DROP_SHADOW: {
IntPoint location;
int32_t stdDeviation;
Color color;
if (!ArgumentCoder<IntPoint>::decode(decoder, location))
return false;
if (!decoder->decodeInt32(stdDeviation))
return false;
if (!ArgumentCoder<Color>::decode(decoder, color))
return false;
filter = DropShadowFilterOperation::create(location, stdDeviation, color, type);
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM: {
String vertexShaderString;
String fragmentShaderString;
CustomFilterProgramType programType;
CustomFilterProgramMixSettings mixSettings;
CustomFilterMeshType meshType;
if (!decoder->decode(vertexShaderString))
return false;
if (!decoder->decode(fragmentShaderString))
return false;
if (!decoder->decodeEnum(programType))
return false;
if (!decoder->decodeEnum(mixSettings.blendMode))
return false;
if (!decoder->decodeEnum(mixSettings.compositeOperator))
return false;
if (!decoder->decodeEnum(meshType))
return false;
RefPtr<CustomFilterProgram> program = WebCustomFilterProgram::create(vertexShaderString, fragmentShaderString, programType, mixSettings, meshType);
uint32_t parametersSize;
if (!decoder->decodeUInt32(parametersSize))
return false;
CustomFilterParameterList parameters(parametersSize);
for (size_t i = 0; i < parametersSize; ++i) {
String name;
CustomFilterParameter::ParameterType parameterType;
if (!decoder->decode(name))
return false;
if (!decoder->decodeEnum(parameterType))
return false;
switch (parameterType) {
case CustomFilterParameter::ARRAY: {
RefPtr<CustomFilterArrayParameter> arrayParameter = CustomFilterArrayParameter::create(name);
uint32_t arrayParameterSize;
if (!decoder->decodeUInt32(arrayParameterSize))
return false;
double arrayParameterValue;
for (size_t j = 0; j < arrayParameterSize; ++j) {
if (!decoder->decode(arrayParameterValue))
return false;
arrayParameter->addValue(arrayParameterValue);
}
parameters[i] = arrayParameter.release();
break;
}
case CustomFilterParameter::NUMBER: {
RefPtr<CustomFilterNumberParameter> numberParameter = CustomFilterNumberParameter::create(name);
uint32_t numberParameterSize;
if (!decoder->decodeUInt32(numberParameterSize))
return false;
double numberParameterValue;
for (size_t j = 0; j < numberParameterSize; ++j) {
if (!decoder->decode(numberParameterValue))
return false;
numberParameter->addValue(numberParameterValue);
}
parameters[i] = numberParameter.release();
break;
}
case CustomFilterParameter::TRANSFORM: {
RefPtr<CustomFilterTransformParameter> transformParameter = CustomFilterTransformParameter::create(name);
TransformOperations operations;
if (!ArgumentCoder<TransformOperations>::decode(decoder, operations))
return false;
transformParameter->setOperations(operations);
parameters[i] = transformParameter.release();
break;
}
}
}
unsigned meshRows;
unsigned meshColumns;
CustomFilterMeshBoxType meshBoxType;
if (!decoder->decode(meshRows))
return false;
if (!decoder->decode(meshColumns))
return false;
if (!decoder->decodeEnum(meshBoxType))
return false;
filter = CustomFilterOperation::create(program, parameters, meshRows, meshColumns, meshBoxType, meshType);
break;
}
#endif
default:
break;
}
if (filter)
operations.append(filter);
}
return true;
}
void ArgumentCoder<WebCore::FilterOperations>::encode(ArgumentEncoder& encoder, const WebCore::FilterOperations& filters)
{
encoder << static_cast<uint32_t>(filters.size());
for (size_t i = 0; i < filters.size(); ++i) {
const FilterOperation* filter = filters.at(i);
FilterOperation::OperationType type = filter->getOperationType();
encoder.encodeEnum(type);
switch (type) {
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE:
encoder << static_cast<double>(static_cast<const BasicColorMatrixFilterOperation*>(filter)->amount());
break;
case FilterOperation::INVERT:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
case FilterOperation::OPACITY:
encoder << static_cast<double>(static_cast<const BasicComponentTransferFilterOperation*>(filter)->amount());
break;
case FilterOperation::BLUR:
ArgumentCoder<Length>::encode(encoder, static_cast<const BlurFilterOperation*>(filter)->stdDeviation());
break;
case FilterOperation::DROP_SHADOW: {
const DropShadowFilterOperation* shadow = static_cast<const DropShadowFilterOperation*>(filter);
ArgumentCoder<IntPoint>::encode(encoder, shadow->location());
encoder << static_cast<int32_t>(shadow->stdDeviation());
ArgumentCoder<Color>::encode(encoder, shadow->color());
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM: {
const CustomFilterOperation* customOperation = static_cast<const CustomFilterOperation*>(filter);
ASSERT(customOperation->program());
RefPtr<CustomFilterProgram> program = customOperation->program();
ASSERT(program->isLoaded());
encoder << program->vertexShaderString();
encoder << program->fragmentShaderString();
encoder.encodeEnum(program->programType());
CustomFilterProgramMixSettings mixSettings = program->mixSettings();
encoder.encodeEnum(mixSettings.blendMode);
encoder.encodeEnum(mixSettings.compositeOperator);
encoder.encodeEnum(program->meshType());
CustomFilterParameterList parameters = customOperation->parameters();
encoder << static_cast<uint32_t>(parameters.size());
for (size_t i = 0; i < parameters.size(); ++i) {
RefPtr<CustomFilterParameter> parameter = parameters[i];
encoder << parameter->name();
encoder.encodeEnum(parameter->parameterType());
switch (parameter->parameterType()) {
case CustomFilterParameter::ARRAY: {
CustomFilterArrayParameter* arrayParameter = static_cast<CustomFilterArrayParameter*>(parameter.get());
encoder << static_cast<uint32_t>(arrayParameter->size());
for (size_t j = 0; j < arrayParameter->size(); ++j)
encoder << arrayParameter->valueAt(j);
break;
}
case CustomFilterParameter::NUMBER: {
CustomFilterNumberParameter* nubmerParameter = static_cast<CustomFilterNumberParameter*>(parameter.get());
encoder << static_cast<uint32_t>(nubmerParameter->size());
for (size_t j = 0; j < nubmerParameter->size(); ++j)
encoder << nubmerParameter->valueAt(j);
break;
}
case CustomFilterParameter::TRANSFORM: {
CustomFilterTransformParameter* transformParameter = static_cast<CustomFilterTransformParameter*>(parameter.get());
ArgumentCoder<TransformOperations>::encode(encoder, transformParameter->operations());
break;
}
}
}
encoder << customOperation->meshRows();
encoder << customOperation->meshColumns();
encoder.encodeEnum(customOperation->meshBoxType());
break;
}
#endif
default:
break;
}
}
}
