static void encodeTimingFunction(ArgumentEncoder& encoder, const TimingFunction* timingFunction)
{
if (!timingFunction) {
encoder.encodeEnum(TimingFunction::TimingFunctionType(-1));
return;
}
TimingFunction::TimingFunctionType type = timingFunction ? timingFunction->type() : TimingFunction::LinearFunction;
encoder.encodeEnum(type);
switch (type) {
case TimingFunction::LinearFunction:
break;
case TimingFunction::CubicBezierFunction: {
const CubicBezierTimingFunction* cubic = static_cast<const CubicBezierTimingFunction*>(timingFunction);
encoder << cubic->x1();
encoder << cubic->y1();
encoder << cubic->x2();
encoder << cubic->y2();
break;
}
case TimingFunction::StepsFunction: {
const StepsTimingFunction* steps = static_cast<const StepsTimingFunction*>(timingFunction);
encoder << static_cast<uint32_t>(steps->numberOfSteps());
encoder << steps->stepAtStart();
break;
}
}
}
void ArgumentCoder<WebCore::UserScript>::encode(ArgumentEncoder& encoder, const WebCore::UserScript& userScript)
{
encoder << userScript.source();
encoder << userScript.url();
encoder << userScript.whitelist();
encoder << userScript.blacklist();
encoder.encodeEnum(userScript.injectionTime());
encoder.encodeEnum(userScript.injectedFrames());
}
void ArgumentCoder<WebCore::UserStyleSheet>::encode(ArgumentEncoder& encoder, const WebCore::UserStyleSheet& userStyleSheet)
{
encoder << userStyleSheet.source();
encoder << userStyleSheet.url();
encoder << userStyleSheet.whitelist();
encoder << userStyleSheet.blacklist();
encoder.encodeEnum(userStyleSheet.injectedFrames());
encoder.encodeEnum(userStyleSheet.level());
}
void ArgumentCoder<WebCore::CustomFilterProgramInfo>::encode(ArgumentEncoder& encoder, const CustomFilterProgramInfo& programInfo)
{
encoder << programInfo.vertexShaderString();
encoder << programInfo.fragmentShaderString();
encoder.encodeEnum(programInfo.programType());
encoder.encodeEnum(programInfo.meshType());
const CustomFilterProgramMixSettings& mixSettings = programInfo.mixSettings();
encoder.encodeEnum(mixSettings.blendMode);
encoder.encodeEnum(mixSettings.compositeOperator);
}
void ArgumentCoder<TextCheckingRequestData>::encode(ArgumentEncoder& encoder, const TextCheckingRequestData& request)
{
encoder << request.sequence();
encoder << request.text();
encoder << request.mask();
encoder.encodeEnum(request.processType());
}
void ArgumentCoder<TextCheckingResult>::encode(ArgumentEncoder& encoder, const TextCheckingResult& result)
{
encoder.encodeEnum(result.type);
encoder << result.location;
encoder << result.length;
encoder << result.details;
encoder << result.replacement;
}
void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder& encoder, const TransformOperations& transformOperations)
{
encoder << static_cast<uint32_t>(transformOperations.size());
for (size_t i = 0; i < transformOperations.size(); ++i) {
const TransformOperation* operation = transformOperations.at(i);
encoder.encodeEnum(operation->getOperationType());
switch (operation->getOperationType()) {
case TransformOperation::SCALE_X:
case TransformOperation::SCALE_Y:
case TransformOperation::SCALE:
case TransformOperation::SCALE_Z:
case TransformOperation::SCALE_3D:
encoder << static_cast<const ScaleTransformOperation*>(operation)->x();
encoder << static_cast<const ScaleTransformOperation*>(operation)->y();
encoder << static_cast<const ScaleTransformOperation*>(operation)->z();
break;
case TransformOperation::TRANSLATE_X:
case TransformOperation::TRANSLATE_Y:
case TransformOperation::TRANSLATE:
case TransformOperation::TRANSLATE_Z:
case TransformOperation::TRANSLATE_3D:
ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->x());
ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->y());
ArgumentCoder<Length>::encode(encoder, static_cast<const TranslateTransformOperation*>(operation)->z());
break;
case TransformOperation::ROTATE:
case TransformOperation::ROTATE_X:
case TransformOperation::ROTATE_Y:
case TransformOperation::ROTATE_3D:
encoder << static_cast<const RotateTransformOperation*>(operation)->x();
encoder << static_cast<const RotateTransformOperation*>(operation)->y();
encoder << static_cast<const RotateTransformOperation*>(operation)->z();
encoder << static_cast<const RotateTransformOperation*>(operation)->angle();
break;
case TransformOperation::SKEW_X:
case TransformOperation::SKEW_Y:
case TransformOperation::SKEW:
encoder << static_cast<const SkewTransformOperation*>(operation)->angleX();
encoder << static_cast<const SkewTransformOperation*>(operation)->angleY();
break;
case TransformOperation::MATRIX:
ArgumentCoder<TransformationMatrix>::encode(encoder, static_cast<const MatrixTransformOperation*>(operation)->matrix());
break;
case TransformOperation::MATRIX_3D:
ArgumentCoder<TransformationMatrix>::encode(encoder, static_cast<const Matrix3DTransformOperation*>(operation)->matrix());
break;
case TransformOperation::PERSPECTIVE:
ArgumentCoder<Length>::encode(encoder, static_cast<const PerspectiveTransformOperation*>(operation)->perspective());
break;
case TransformOperation::IDENTITY:
break;
case TransformOperation::NONE:
ASSERT_NOT_REACHED();
break;
}
}
}
void encode(ArgumentEncoder& encoder, CFTypeRef typeRef)
{
CFType type = typeFromCFTypeRef(typeRef);
encoder.encodeEnum(type);
switch (type) {
case CFArray:
encode(encoder, static_cast<CFArrayRef>(typeRef));
return;
case CFBoolean:
encode(encoder, static_cast<CFBooleanRef>(typeRef));
return;
case CFData:
encode(encoder, static_cast<CFDataRef>(typeRef));
return;
case CFDate:
encode(encoder, static_cast<CFDateRef>(typeRef));
return;
case CFDictionary:
encode(encoder, static_cast<CFDictionaryRef>(typeRef));
return;
case CFNull:
return;
case CFNumber:
encode(encoder, static_cast<CFNumberRef>(typeRef));
return;
case CFString:
encode(encoder, static_cast<CFStringRef>(typeRef));
return;
case CFURL:
encode(encoder, static_cast<CFURLRef>(typeRef));
return;
case SecCertificate:
encode(encoder, (SecCertificateRef)typeRef);
return;
#if PLATFORM(IOS)
case SecIdentity:
encode(encoder, (SecIdentityRef)(typeRef));
return;
#endif
#if HAVE(SEC_KEYCHAIN)
case SecKeychainItem:
encode(encoder, (SecKeychainItemRef)typeRef);
return;
#endif
#if HAVE(SEC_ACCESS_CONTROL)
case SecAccessControl:
encode(encoder, (SecAccessControlRef)typeRef);
return;
#endif
case Null:
return;
case Unknown:
break;
}
ASSERT_NOT_REACHED();
}
void ArgumentCoder<String>::encode(ArgumentEncoder& encoder, const String& string)
{
// Special case the null string.
if (string.isNull()) {
encoder << std::numeric_limits<uint32_t>::max();
return;
}
uint32_t length = string.length();
bool is8Bit = string.is8Bit();
encoder << length << is8Bit;
if (is8Bit)
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters8()), length * sizeof(LChar), alignof(LChar));
else
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.characters16()), length * sizeof(UChar), alignof(UChar));
}
void ArgumentCoder<ScrollingStateNode>::encode(ArgumentEncoder& encoder, const ScrollingStateNode& node)
{
encoder.encodeEnum(node.nodeType());
encoder << node.scrollingNodeID();
encoder << node.parentNodeID();
encoder << node.changedProperties();
if (node.hasChangedProperty(ScrollingStateNode::ScrollLayer))
encoder << static_cast<GraphicsLayer::PlatformLayerID>(node.layer());
}
void encode(ArgumentEncoder& encoder, CFNumberRef number)
{
CFNumberType numberType = CFNumberGetType(number);
Vector<uint8_t> buffer(CFNumberGetByteSize(number));
bool result = CFNumberGetValue(number, numberType, buffer.data());
ASSERT_UNUSED(result, result);
encoder.encodeEnum(numberType);
encoder << IPC::DataReference(buffer);
}
void ArgumentCoder<CString>::encode(ArgumentEncoder& encoder, const CString& string)
{
// Special case the null string.
if (string.isNull()) {
encoder << std::numeric_limits<uint32_t>::max();
return;
}
uint32_t length = string.length();
encoder << length;
encoder.encodeFixedLengthData(reinterpret_cast<const uint8_t*>(string.data()), length, 1);
}
void ArgumentCoder<GraphicsLayerAnimation>::encode(ArgumentEncoder& encoder, const GraphicsLayerAnimation& animation)
{
encoder << animation.name();
encoder << animation.boxSize();
encoder.encodeEnum(animation.state());
encoder << animation.startTime();
encoder << animation.pauseTime();
encoder << animation.listsMatch();
RefPtr<Animation> animationObject = animation.animation();
encoder.encodeEnum(animationObject->direction());
encoder << static_cast<uint32_t>(animationObject->fillMode());
encoder << animationObject->duration();
encoder << animationObject->iterationCount();
encodeTimingFunction(encoder, animationObject->timingFunction().get());
const KeyframeValueList& keyframes = animation.keyframes();
encoder.encodeEnum(keyframes.property());
encoder << static_cast<uint32_t>(keyframes.size());
for (size_t i = 0; i < keyframes.size(); ++i) {
const AnimationValue* value = keyframes.at(i);
encoder << value->keyTime();
encodeTimingFunction(encoder, value->timingFunction());
switch (keyframes.property()) {
case AnimatedPropertyOpacity:
encoder << static_cast<const FloatAnimationValue*>(value)->value();
break;
case AnimatedPropertyWebkitTransform:
encoder << *static_cast<const TransformAnimationValue*>(value)->value();
break;
#if ENABLE(CSS_FILTERS)
case AnimatedPropertyWebkitFilter:
encoder << *static_cast<const FilterAnimationValue*>(value)->value();
break;
#endif
default:
break;
}
}
}
void ArgumentCoder<ResourceRequest>::encodePlatformData(ArgumentEncoder& encoder, const ResourceRequest& resourceRequest)
{
encoder << resourceRequest.url().string();
encoder << resourceRequest.httpMethod();
encoder << resourceRequest.httpHeaderFields();
encoder << resourceRequest.timeoutInterval();
// FIXME: Do not encode HTTP message body.
// 1. It can be large and thus costly to send across.
// 2. It is misleading to provide a body with some requests, while others use body streams, which cannot be serialized at all.
FormData* httpBody = resourceRequest.httpBody();
encoder << static_cast<bool>(httpBody);
if (httpBody)
encoder << httpBody->flattenToString();
encoder << resourceRequest.firstPartyForCookies().string();
encoder << resourceRequest.allowCookies();
encoder.encodeEnum(resourceRequest.priority());
encoder.encodeEnum(resourceRequest.cachePolicy());
encoder.encodeEnum(resourceRequest.requester());
encoder << static_cast<uint32_t>(resourceRequest.soupMessageFlags());
encoder << resourceRequest.initiatingPageID();
}
void ArgumentCoder<Cursor>::encode(ArgumentEncoder& encoder, const Cursor& cursor)
{
encoder.encodeEnum(cursor.type());
if (cursor.type() != Cursor::Custom)
return;
if (cursor.image()->isNull()) {
encoder << false; // There is no valid image being encoded.
return;
}
encoder << true;
encodeImage(encoder, cursor.image());
encoder << cursor.hotSpot();
}
void ArgumentCoder<IDBKeyPath>::encode(ArgumentEncoder& encoder, const IDBKeyPath& keyPath)
{
encoder.encodeEnum(keyPath.type());
switch (keyPath.type()) {
case IDBKeyPath::NullType:
break;
case IDBKeyPath::StringType:
encoder << keyPath.string();
break;
case IDBKeyPath::ArrayType:
encoder << keyPath.array();
break;
default:
ASSERT_NOT_REACHED();
}
}
void encode(ArgumentEncoder& encoder, CFStringRef string)
{
CFIndex length = CFStringGetLength(string);
CFStringEncoding encoding = CFStringGetFastestEncoding(string);
CFRange range = CFRangeMake(0, length);
CFIndex bufferLength = 0;
CFIndex numConvertedBytes = CFStringGetBytes(string, range, encoding, 0, false, 0, 0, &bufferLength);
ASSERT(numConvertedBytes == length);
Vector<UInt8, 128> buffer(bufferLength);
numConvertedBytes = CFStringGetBytes(string, range, encoding, 0, false, buffer.data(), buffer.size(), &bufferLength);
ASSERT(numConvertedBytes == length);
encoder.encodeEnum(encoding);
encoder << IPC::DataReference(buffer);
}
static void encodeFilterOperation(ArgumentEncoder& encoder, const FilterOperation& filter)
{
encoder.encodeEnum(filter.type());
switch (filter.type()) {
case FilterOperation::REFERENCE: {
const auto& referenceFilter = static_cast<const ReferenceFilterOperation&>(filter);
encoder << referenceFilter.url();
encoder << referenceFilter.fragment();
break;
}
case FilterOperation::GRAYSCALE:
case FilterOperation::SEPIA:
case FilterOperation::SATURATE:
case FilterOperation::HUE_ROTATE:
encoder << static_cast<const BasicColorMatrixFilterOperation&>(filter).amount();
break;
case FilterOperation::INVERT:
case FilterOperation::OPACITY:
case FilterOperation::BRIGHTNESS:
case FilterOperation::CONTRAST:
encoder << static_cast<const BasicComponentTransferFilterOperation&>(filter).amount();
break;
case FilterOperation::BLUR:
encoder << static_cast<const BlurFilterOperation&>(filter).stdDeviation();
break;
case FilterOperation::DROP_SHADOW: {
const auto& dropShadowFilter = static_cast<const DropShadowFilterOperation&>(filter);
encoder << dropShadowFilter.location();
encoder << dropShadowFilter.stdDeviation();
encoder << dropShadowFilter.color();
break;
}
#if ENABLE(CSS_SHADERS)
case FilterOperation::CUSTOM:
case FilterOperation::VALIDATED_CUSTOM:
ASSERT_NOT_REACHED();
break;
#endif
case FilterOperation::PASSTHROUGH:
case FilterOperation::NONE:
break;
};
}
void ArgumentCoder<CertificateInfo>::encode(ArgumentEncoder& encoder, const CertificateInfo& certificateInfo)
{
if (!certificateInfo.certificate()) {
encoder << false;
return;
}
GByteArray* certificateData = 0;
g_object_get(G_OBJECT(certificateInfo.certificate()), "certificate", &certificateData, NULL);
if (!certificateData) {
encoder << false;
return;
}
encoder << true;
GRefPtr<GByteArray> certificate = adoptGRef(certificateData);
encoder.encodeVariableLengthByteArray(IPC::DataReference(certificate->data, certificate->len));
encoder << static_cast<uint32_t>(certificateInfo.tlsErrors());
}
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;
}
}
}
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;
}
}
}
void DataReference::encode(ArgumentEncoder& encoder) const
{
encoder.encodeVariableLengthByteArray(*this);
}
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;
}
}
}
void Attachment::encode(ArgumentEncoder& encoder) const
{
encoder.addAttachment(*this);
}
void ArgumentCoder<ProtectionSpace>::encode(ArgumentEncoder& encoder, const ProtectionSpace& space)
{
encoder << space.host() << space.port() << space.realm();
encoder.encodeEnum(space.authenticationScheme());
encoder.encodeEnum(space.serverType());
}
void ArgumentCoder<Credential>::encode(ArgumentEncoder& encoder, const Credential& credential)
{
encoder << credential.user() << credential.password();
encoder.encodeEnum(credential.persistence());
}
void ArgumentCoder<TransformOperations>::encode(ArgumentEncoder& encoder, const TransformOperations& transformOperations)
{
encoder << static_cast<uint32_t>(transformOperations.size());
for (const auto& operation : transformOperations.operations()) {
encoder.encodeEnum(operation->type());
switch (operation->type()) {
case TransformOperation::SCALE_X:
case TransformOperation::SCALE_Y:
case TransformOperation::SCALE:
case TransformOperation::SCALE_Z:
case TransformOperation::SCALE_3D: {
const auto& scaleOperation = downcast<ScaleTransformOperation>(*operation);
encoder << scaleOperation.x();
encoder << scaleOperation.y();
encoder << scaleOperation.z();
break;
}
case TransformOperation::TRANSLATE_X:
case TransformOperation::TRANSLATE_Y:
case TransformOperation::TRANSLATE:
case TransformOperation::TRANSLATE_Z:
case TransformOperation::TRANSLATE_3D: {
const auto& translateOperation = downcast<TranslateTransformOperation>(*operation);
ArgumentCoder<Length>::encode(encoder, translateOperation.x());
ArgumentCoder<Length>::encode(encoder, translateOperation.y());
ArgumentCoder<Length>::encode(encoder, translateOperation.z());
break;
}
case TransformOperation::ROTATE:
case TransformOperation::ROTATE_X:
case TransformOperation::ROTATE_Y:
case TransformOperation::ROTATE_3D: {
const auto& rotateOperation = downcast<RotateTransformOperation>(*operation);
encoder << rotateOperation.x();
encoder << rotateOperation.y();
encoder << rotateOperation.z();
encoder << rotateOperation.angle();
break;
}
case TransformOperation::SKEW_X:
case TransformOperation::SKEW_Y:
case TransformOperation::SKEW: {
const auto& skewOperation = downcast<SkewTransformOperation>(*operation);
encoder << skewOperation.angleX();
encoder << skewOperation.angleY();
break;
}
case TransformOperation::MATRIX:
ArgumentCoder<TransformationMatrix>::encode(encoder, downcast<MatrixTransformOperation>(*operation).matrix());
break;
case TransformOperation::MATRIX_3D:
ArgumentCoder<TransformationMatrix>::encode(encoder, downcast<Matrix3DTransformOperation>(*operation).matrix());
break;
case TransformOperation::PERSPECTIVE:
ArgumentCoder<Length>::encode(encoder, downcast<PerspectiveTransformOperation>(*operation).perspective());
break;
case TransformOperation::IDENTITY:
break;
case TransformOperation::NONE:
ASSERT_NOT_REACHED();
break;
}
}
}
void ArgumentCoder<DragSession>::encode(ArgumentEncoder& encoder, const DragSession& result)
{
encoder.encodeEnum(result.operation);
encoder << result.mouseIsOverFileInput;
encoder << result.numberOfItemsToBeAccepted;
}
