mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-24 13:21:05 +00:00
86d050de4e
The change is a preparation for Bug 1865984, Bug 1863474 and Bug 1861605. FenceD3D11 is going to be used by Bug 1865984 and Bug 1863474. And FileHandleWrapper is going to be added for wrapping shared handle of ID3D11Fence and ID3D11Texture2D(Bug 1861605). For now, FenceInfo is expected to be delivered just during creating TextureHost. It works for WebGL and WebGPU. Differential Revision: https://phabricator.services.mozilla.com/D194612
1304 lines
38 KiB
C++
1304 lines
38 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef __GFXMESSAGEUTILS_H__
|
|
#define __GFXMESSAGEUTILS_H__
|
|
|
|
#include "FilterSupport.h"
|
|
#include "ImageTypes.h"
|
|
#include "RegionBuilder.h"
|
|
#include "chrome/common/ipc_message_utils.h"
|
|
#include "gfxFeature.h"
|
|
#include "gfxFontUtils.h"
|
|
#include "gfxFallback.h"
|
|
#include "gfxPoint.h"
|
|
#include "gfxRect.h"
|
|
#include "gfxTelemetry.h"
|
|
#include "gfxTypes.h"
|
|
#include "ipc/EnumSerializer.h"
|
|
#include "ipc/IPCMessageUtilsSpecializations.h"
|
|
#include "mozilla/gfx/CrossProcessPaint.h"
|
|
#include "mozilla/gfx/FileHandleWrapper.h"
|
|
#include "mozilla/gfx/Matrix.h"
|
|
#include "mozilla/gfx/ScaleFactor.h"
|
|
#include "mozilla/gfx/ScaleFactors2D.h"
|
|
#include "SharedFontList.h"
|
|
#include "nsRect.h"
|
|
#include "nsRegion.h"
|
|
#include "mozilla/Array.h"
|
|
#include "mozilla/ipc/FileDescriptor.h"
|
|
#include "mozilla/ipc/IPDLParamTraits.h"
|
|
#include "mozilla/ipc/ProtocolMessageUtils.h"
|
|
#include "mozilla/ipc/ProtocolUtils.h"
|
|
#include "mozilla/ipc/ShmemMessageUtils.h"
|
|
|
|
#include <stdint.h>
|
|
|
|
#ifdef _MSC_VER
|
|
# pragma warning(disable : 4800)
|
|
#endif
|
|
|
|
namespace mozilla {
|
|
|
|
typedef gfxImageFormat PixelFormat;
|
|
|
|
} // namespace mozilla
|
|
|
|
namespace IPC {
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Matrix> {
|
|
typedef mozilla::gfx::Matrix paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam._11);
|
|
WriteParam(aWriter, aParam._12);
|
|
WriteParam(aWriter, aParam._21);
|
|
WriteParam(aWriter, aParam._22);
|
|
WriteParam(aWriter, aParam._31);
|
|
WriteParam(aWriter, aParam._32);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (ReadParam(aReader, &aResult->_11) &&
|
|
ReadParam(aReader, &aResult->_12) &&
|
|
ReadParam(aReader, &aResult->_21) &&
|
|
ReadParam(aReader, &aResult->_22) &&
|
|
ReadParam(aReader, &aResult->_31) && ReadParam(aReader, &aResult->_32))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template <class SourceUnits, class TargetUnits, class T>
|
|
struct ParamTraits<mozilla::gfx::Matrix4x4Typed<SourceUnits, TargetUnits, T>> {
|
|
typedef mozilla::gfx::Matrix4x4Typed<SourceUnits, TargetUnits, T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
#define Wr(_f) WriteParam(writer, param._f)
|
|
Wr(_11);
|
|
Wr(_12);
|
|
Wr(_13);
|
|
Wr(_14);
|
|
Wr(_21);
|
|
Wr(_22);
|
|
Wr(_23);
|
|
Wr(_24);
|
|
Wr(_31);
|
|
Wr(_32);
|
|
Wr(_33);
|
|
Wr(_34);
|
|
Wr(_41);
|
|
Wr(_42);
|
|
Wr(_43);
|
|
Wr(_44);
|
|
#undef Wr
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
#define Rd(_f) ReadParam(reader, &result->_f)
|
|
return (Rd(_11) && Rd(_12) && Rd(_13) && Rd(_14) && Rd(_21) && Rd(_22) &&
|
|
Rd(_23) && Rd(_24) && Rd(_31) && Rd(_32) && Rd(_33) && Rd(_34) &&
|
|
Rd(_41) && Rd(_42) && Rd(_43) && Rd(_44));
|
|
#undef Rd
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Matrix5x4> {
|
|
typedef mozilla::gfx::Matrix5x4 paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
#define Wr(_f) WriteParam(writer, param._f)
|
|
Wr(_11);
|
|
Wr(_12);
|
|
Wr(_13);
|
|
Wr(_14);
|
|
Wr(_21);
|
|
Wr(_22);
|
|
Wr(_23);
|
|
Wr(_24);
|
|
Wr(_31);
|
|
Wr(_32);
|
|
Wr(_33);
|
|
Wr(_34);
|
|
Wr(_41);
|
|
Wr(_42);
|
|
Wr(_43);
|
|
Wr(_44);
|
|
Wr(_51);
|
|
Wr(_52);
|
|
Wr(_53);
|
|
Wr(_54);
|
|
#undef Wr
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
#define Rd(_f) ReadParam(reader, &result->_f)
|
|
return (Rd(_11) && Rd(_12) && Rd(_13) && Rd(_14) && Rd(_21) && Rd(_22) &&
|
|
Rd(_23) && Rd(_24) && Rd(_31) && Rd(_32) && Rd(_33) && Rd(_34) &&
|
|
Rd(_41) && Rd(_42) && Rd(_43) && Rd(_44) && Rd(_51) && Rd(_52) &&
|
|
Rd(_53) && Rd(_54));
|
|
#undef Rd
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxPoint> {
|
|
typedef gfxPoint paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.x.value);
|
|
WriteParam(aWriter, aParam.y.value);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
return (ReadParam(aReader, &aResult->x.value) &&
|
|
ReadParam(aReader, &aResult->y.value));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxSize> {
|
|
typedef gfxSize paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.width);
|
|
WriteParam(aWriter, aParam.height);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (ReadParam(aReader, &aResult->width) &&
|
|
ReadParam(aReader, &aResult->height))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxRect> {
|
|
typedef gfxRect paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.X());
|
|
WriteParam(aWriter, aParam.Y());
|
|
WriteParam(aWriter, aParam.Width());
|
|
WriteParam(aWriter, aParam.Height());
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
auto x = aResult->X();
|
|
auto y = aResult->Y();
|
|
auto w = aResult->Width();
|
|
auto h = aResult->Height();
|
|
|
|
bool retVal = (ReadParam(aReader, &x) && ReadParam(aReader, &y) &&
|
|
ReadParam(aReader, &w) && ReadParam(aReader, &h));
|
|
aResult->SetRect(x, y, w, h);
|
|
return retVal;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxContentType>
|
|
: public ContiguousEnumSerializer<gfxContentType, gfxContentType::COLOR,
|
|
gfxContentType::SENTINEL> {};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxSurfaceType>
|
|
: public ContiguousEnumSerializer<gfxSurfaceType, gfxSurfaceType::Image,
|
|
gfxSurfaceType::Max> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::SamplingFilter>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::SamplingFilter,
|
|
mozilla::gfx::SamplingFilter::GOOD,
|
|
mozilla::gfx::SamplingFilter::SENTINEL> {
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::BackendType>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::BackendType,
|
|
mozilla::gfx::BackendType::NONE,
|
|
mozilla::gfx::BackendType::BACKEND_LAST> {
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Feature>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::Feature,
|
|
mozilla::gfx::Feature::HW_COMPOSITING,
|
|
mozilla::gfx::Feature::NumValues> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Fallback>
|
|
: public ContiguousEnumSerializer<
|
|
mozilla::gfx::Fallback,
|
|
mozilla::gfx::Fallback::NO_CONSTANT_BUFFER_OFFSETTING,
|
|
mozilla::gfx::Fallback::NumValues> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::FeatureStatus>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::FeatureStatus,
|
|
mozilla::gfx::FeatureStatus::Unused,
|
|
mozilla::gfx::FeatureStatus::LAST> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::LightType>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::LightType,
|
|
mozilla::gfx::LightType::None,
|
|
mozilla::gfx::LightType::Max> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ColorSpace>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::ColorSpace,
|
|
mozilla::gfx::ColorSpace::SRGB,
|
|
mozilla::gfx::ColorSpace::Max> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::CompositionOp>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::CompositionOp, mozilla::gfx::CompositionOp::OP_OVER,
|
|
mozilla::gfx::CompositionOp::OP_COUNT> {};
|
|
|
|
/*
|
|
template <>
|
|
struct ParamTraits<mozilla::PixelFormat>
|
|
: public EnumSerializer<mozilla::PixelFormat,
|
|
SurfaceFormat::A8R8G8B8_UINT32,
|
|
SurfaceFormat::UNKNOWN>
|
|
{};
|
|
*/
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::sRGBColor> {
|
|
typedef mozilla::gfx::sRGBColor paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.r);
|
|
WriteParam(writer, param.g);
|
|
WriteParam(writer, param.b);
|
|
WriteParam(writer, param.a);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->r) && ReadParam(reader, &result->g) &&
|
|
ReadParam(reader, &result->b) && ReadParam(reader, &result->a));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::DeviceColor> {
|
|
typedef mozilla::gfx::DeviceColor paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.r);
|
|
WriteParam(writer, param.g);
|
|
WriteParam(writer, param.b);
|
|
WriteParam(writer, param.a);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->r) && ReadParam(reader, &result->g) &&
|
|
ReadParam(reader, &result->b) && ReadParam(reader, &result->a));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<nsPoint> {
|
|
typedef nsPoint paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.x);
|
|
WriteParam(writer, param.y);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->x) && ReadParam(reader, &result->y));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<nsIntPoint> {
|
|
typedef nsIntPoint paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.x);
|
|
WriteParam(writer, param.y);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->x) && ReadParam(reader, &result->y));
|
|
}
|
|
};
|
|
|
|
template <typename T>
|
|
struct ParamTraits<mozilla::gfx::IntSizeTyped<T>> {
|
|
typedef mozilla::gfx::IntSizeTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.width);
|
|
WriteParam(writer, param.height);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->width) &&
|
|
ReadParam(reader, &result->height));
|
|
}
|
|
};
|
|
|
|
template <typename Region, typename Rect, typename Iter>
|
|
struct RegionParamTraits {
|
|
typedef Region paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
for (auto iter = param.RectIter(); !iter.Done(); iter.Next()) {
|
|
const Rect& r = iter.Get();
|
|
MOZ_RELEASE_ASSERT(!r.IsEmpty(), "GFX: rect is empty.");
|
|
WriteParam(writer, r);
|
|
}
|
|
// empty rects are sentinel values because nsRegions will never
|
|
// contain them
|
|
WriteParam(writer, Rect());
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
RegionBuilder<Region> builder;
|
|
Rect rect;
|
|
while (ReadParam(reader, &rect)) {
|
|
if (rect.IsEmpty()) {
|
|
*result = builder.ToRegion();
|
|
return true;
|
|
}
|
|
builder.OrWith(rect);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template <class Units>
|
|
struct ParamTraits<mozilla::gfx::IntRegionTyped<Units>>
|
|
: RegionParamTraits<
|
|
mozilla::gfx::IntRegionTyped<Units>,
|
|
mozilla::gfx::IntRectTyped<Units>,
|
|
typename mozilla::gfx::IntRegionTyped<Units>::RectIterator> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::IntSize> {
|
|
typedef mozilla::gfx::IntSize paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.width);
|
|
WriteParam(writer, param.height);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->width) &&
|
|
ReadParam(reader, &result->height));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::CoordTyped<T>> {
|
|
typedef mozilla::gfx::CoordTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.value);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->value));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::IntCoordTyped<T>> {
|
|
typedef mozilla::gfx::IntCoordTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.value);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->value));
|
|
}
|
|
};
|
|
|
|
template <class T, class U>
|
|
struct ParamTraits<mozilla::gfx::ScaleFactor<T, U>> {
|
|
typedef mozilla::gfx::ScaleFactor<T, U> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.scale);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->scale));
|
|
}
|
|
};
|
|
|
|
template <class T, class U>
|
|
struct ParamTraits<mozilla::gfx::ScaleFactors2D<T, U>> {
|
|
typedef mozilla::gfx::ScaleFactors2D<T, U> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.xScale);
|
|
WriteParam(writer, param.yScale);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->xScale) &&
|
|
ReadParam(reader, &result->yScale));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::PointTyped<T>> {
|
|
typedef mozilla::gfx::PointTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.x);
|
|
WriteParam(writer, param.y);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->x) && ReadParam(reader, &result->y));
|
|
}
|
|
};
|
|
|
|
template <class F, class T>
|
|
struct ParamTraits<mozilla::gfx::Point3DTyped<F, T>> {
|
|
typedef mozilla::gfx::Point3DTyped<F, T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.x);
|
|
WriteParam(writer, param.y);
|
|
WriteParam(writer, param.z);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->x) && ReadParam(reader, &result->y) &&
|
|
ReadParam(reader, &result->z));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::IntPointTyped<T>> {
|
|
typedef mozilla::gfx::IntPointTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.x);
|
|
WriteParam(writer, param.y);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->x) && ReadParam(reader, &result->y));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::SizeTyped<T>> {
|
|
typedef mozilla::gfx::SizeTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.width);
|
|
WriteParam(writer, param.height);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (ReadParam(reader, &result->width) &&
|
|
ReadParam(reader, &result->height));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::RectTyped<T>> {
|
|
typedef mozilla::gfx::RectTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.X());
|
|
WriteParam(writer, param.Y());
|
|
WriteParam(writer, param.Width());
|
|
WriteParam(writer, param.Height());
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
auto x = result->X();
|
|
auto y = result->Y();
|
|
auto w = result->Width();
|
|
auto h = result->Height();
|
|
|
|
bool retVal = (ReadParam(reader, &x) && ReadParam(reader, &y) &&
|
|
ReadParam(reader, &w) && ReadParam(reader, &h));
|
|
result->SetRect(x, y, w, h);
|
|
return retVal;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::RectAbsoluteTyped<T>> {
|
|
typedef mozilla::gfx::RectAbsoluteTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.Left());
|
|
WriteParam(writer, param.Top());
|
|
WriteParam(writer, param.Right());
|
|
WriteParam(writer, param.Bottom());
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
auto l = result->Left();
|
|
auto t = result->Top();
|
|
auto r = result->Right();
|
|
auto b = result->Bottom();
|
|
|
|
bool retVal = (ReadParam(reader, &l) && ReadParam(reader, &t) &&
|
|
ReadParam(reader, &r) && ReadParam(reader, &b));
|
|
result->SetBox(l, t, r, b);
|
|
return retVal;
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::IntRectTyped<T>> {
|
|
typedef mozilla::gfx::IntRectTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.X());
|
|
WriteParam(writer, param.Y());
|
|
WriteParam(writer, param.Width());
|
|
WriteParam(writer, param.Height());
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
auto x = result->X();
|
|
auto y = result->Y();
|
|
auto w = result->Width();
|
|
auto h = result->Height();
|
|
|
|
bool retVal = (ReadParam(reader, &x) && ReadParam(reader, &y) &&
|
|
ReadParam(reader, &w) && ReadParam(reader, &h));
|
|
result->SetRect(x, y, w, h);
|
|
return retVal;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Margin> {
|
|
typedef mozilla::gfx::Margin paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.top);
|
|
WriteParam(writer, param.right);
|
|
WriteParam(writer, param.bottom);
|
|
WriteParam(writer, param.left);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (
|
|
ReadParam(reader, &result->top) && ReadParam(reader, &result->right) &&
|
|
ReadParam(reader, &result->bottom) && ReadParam(reader, &result->left));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::MarginTyped<T>> {
|
|
typedef mozilla::gfx::MarginTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.top);
|
|
WriteParam(writer, param.right);
|
|
WriteParam(writer, param.bottom);
|
|
WriteParam(writer, param.left);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (
|
|
ReadParam(reader, &result->top) && ReadParam(reader, &result->right) &&
|
|
ReadParam(reader, &result->bottom) && ReadParam(reader, &result->left));
|
|
}
|
|
};
|
|
|
|
template <class T>
|
|
struct ParamTraits<mozilla::gfx::IntMarginTyped<T>> {
|
|
typedef mozilla::gfx::IntMarginTyped<T> paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.top);
|
|
WriteParam(writer, param.right);
|
|
WriteParam(writer, param.bottom);
|
|
WriteParam(writer, param.left);
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
return (
|
|
ReadParam(reader, &result->top) && ReadParam(reader, &result->right) &&
|
|
ReadParam(reader, &result->bottom) && ReadParam(reader, &result->left));
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<nsRect> {
|
|
typedef nsRect paramType;
|
|
|
|
static void Write(MessageWriter* writer, const paramType& param) {
|
|
WriteParam(writer, param.X());
|
|
WriteParam(writer, param.Y());
|
|
WriteParam(writer, param.Width());
|
|
WriteParam(writer, param.Height());
|
|
}
|
|
|
|
static bool Read(MessageReader* reader, paramType* result) {
|
|
auto x = result->X();
|
|
auto y = result->Y();
|
|
auto w = result->Width();
|
|
auto h = result->Height();
|
|
bool retVal = (ReadParam(reader, &x) && ReadParam(reader, &y) &&
|
|
ReadParam(reader, &w) && ReadParam(reader, &h));
|
|
result->SetRect(x, y, w, h);
|
|
return retVal;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<nsRegion>
|
|
: RegionParamTraits<nsRegion, nsRect, nsRegion::RectIterator> {};
|
|
|
|
template <>
|
|
struct ParamTraits<GeckoProcessType>
|
|
: public ContiguousEnumSerializer<
|
|
GeckoProcessType, GeckoProcessType_Default, GeckoProcessType_End> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::SurfaceFormat>
|
|
: public ContiguousEnumSerializer<mozilla::gfx::SurfaceFormat,
|
|
mozilla::gfx::SurfaceFormat::B8G8R8A8,
|
|
mozilla::gfx::SurfaceFormat::UNKNOWN> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ColorDepth>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::ColorDepth, mozilla::gfx::ColorDepth::_First,
|
|
mozilla::gfx::ColorDepth::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::TransferFunction>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::TransferFunction,
|
|
mozilla::gfx::TransferFunction::_First,
|
|
mozilla::gfx::TransferFunction::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ColorRange>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::ColorRange, mozilla::gfx::ColorRange::_First,
|
|
mozilla::gfx::ColorRange::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::YUVColorSpace>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::YUVColorSpace, mozilla::gfx::YUVColorSpace::_First,
|
|
mozilla::gfx::YUVColorSpace::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::YUVRangedColorSpace>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::YUVRangedColorSpace,
|
|
mozilla::gfx::YUVRangedColorSpace::_First,
|
|
mozilla::gfx::YUVRangedColorSpace::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ColorSpace2>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::ColorSpace2, mozilla::gfx::ColorSpace2::_First,
|
|
mozilla::gfx::ColorSpace2::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::StereoMode>
|
|
: public ContiguousEnumSerializer<mozilla::StereoMode,
|
|
mozilla::StereoMode::MONO,
|
|
mozilla::StereoMode::MAX> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ChromaSubsampling>
|
|
: public ContiguousEnumSerializerInclusive<
|
|
mozilla::gfx::ChromaSubsampling,
|
|
mozilla::gfx::ChromaSubsampling::_First,
|
|
mozilla::gfx::ChromaSubsampling::_Last> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ImplicitlyCopyableFloatArray>
|
|
: public ParamTraits<nsTArray<float>> {
|
|
typedef mozilla::gfx::ImplicitlyCopyableFloatArray paramType;
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::EmptyAttributes> {
|
|
typedef mozilla::gfx::EmptyAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) { return true; }
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::MergeAttributes> {
|
|
typedef mozilla::gfx::MergeAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) { return true; }
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ToAlphaAttributes> {
|
|
typedef mozilla::gfx::ToAlphaAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) { return true; }
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::TileAttributes> {
|
|
typedef mozilla::gfx::TileAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) { return true; }
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::BlendAttributes> {
|
|
typedef mozilla::gfx::BlendAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mBlendMode);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
return ReadParam(aReader, &aResult->mBlendMode);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::MorphologyAttributes> {
|
|
typedef mozilla::gfx::MorphologyAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mOperator);
|
|
WriteParam(aWriter, aParam.mRadii);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mOperator) ||
|
|
!ReadParam(aReader, &aResult->mRadii)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::FloodAttributes> {
|
|
typedef mozilla::gfx::FloodAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mColor);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mColor)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::OpacityAttributes> {
|
|
typedef mozilla::gfx::OpacityAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mOpacity);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mOpacity)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::OffsetAttributes> {
|
|
typedef mozilla::gfx::OffsetAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mValue);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mValue)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::DisplacementMapAttributes> {
|
|
typedef mozilla::gfx::DisplacementMapAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mScale);
|
|
WriteParam(aWriter, aParam.mXChannel);
|
|
WriteParam(aWriter, aParam.mYChannel);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mScale) ||
|
|
!ReadParam(aReader, &aResult->mXChannel) ||
|
|
!ReadParam(aReader, &aResult->mYChannel)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::TurbulenceAttributes> {
|
|
typedef mozilla::gfx::TurbulenceAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mOffset);
|
|
WriteParam(aWriter, aParam.mBaseFrequency);
|
|
WriteParam(aWriter, aParam.mSeed);
|
|
WriteParam(aWriter, aParam.mOctaves);
|
|
WriteParam(aWriter, aParam.mStitchable);
|
|
WriteParam(aWriter, aParam.mType);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mOffset) ||
|
|
!ReadParam(aReader, &aResult->mBaseFrequency) ||
|
|
!ReadParam(aReader, &aResult->mSeed) ||
|
|
!ReadParam(aReader, &aResult->mOctaves) ||
|
|
!ReadParam(aReader, &aResult->mStitchable) ||
|
|
!ReadParam(aReader, &aResult->mType)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ImageAttributes> {
|
|
typedef mozilla::gfx::ImageAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mFilter);
|
|
WriteParam(aWriter, aParam.mInputIndex);
|
|
WriteParam(aWriter, aParam.mTransform);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mFilter) ||
|
|
!ReadParam(aReader, &aResult->mInputIndex) ||
|
|
!ReadParam(aReader, &aResult->mTransform)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::GaussianBlurAttributes> {
|
|
typedef mozilla::gfx::GaussianBlurAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mStdDeviation);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mStdDeviation)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::DropShadowAttributes> {
|
|
typedef mozilla::gfx::DropShadowAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mStdDeviation);
|
|
WriteParam(aWriter, aParam.mOffset);
|
|
WriteParam(aWriter, aParam.mColor);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mStdDeviation) ||
|
|
!ReadParam(aReader, &aResult->mOffset) ||
|
|
!ReadParam(aReader, &aResult->mColor)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ColorMatrixAttributes> {
|
|
typedef mozilla::gfx::ColorMatrixAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mType);
|
|
WriteParam(aWriter, aParam.mValues);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mType) ||
|
|
!ReadParam(aReader, &aResult->mValues)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ComponentTransferAttributes> {
|
|
typedef mozilla::gfx::ComponentTransferAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
WriteParam(aWriter, aParam.mTypes[i]);
|
|
}
|
|
for (int i = 0; i < 4; ++i) {
|
|
WriteParam(aWriter, aParam.mValues[i]);
|
|
}
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
for (int i = 0; i < 4; ++i) {
|
|
if (!ReadParam(aReader, &aResult->mTypes[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
for (int i = 0; i < 4; ++i) {
|
|
if (!ReadParam(aReader, &aResult->mValues[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::ConvolveMatrixAttributes> {
|
|
typedef mozilla::gfx::ConvolveMatrixAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mKernelSize);
|
|
WriteParam(aWriter, aParam.mKernelMatrix);
|
|
WriteParam(aWriter, aParam.mDivisor);
|
|
WriteParam(aWriter, aParam.mBias);
|
|
WriteParam(aWriter, aParam.mTarget);
|
|
WriteParam(aWriter, aParam.mEdgeMode);
|
|
WriteParam(aWriter, aParam.mKernelUnitLength);
|
|
WriteParam(aWriter, aParam.mPreserveAlpha);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mKernelSize) ||
|
|
!ReadParam(aReader, &aResult->mKernelMatrix) ||
|
|
!ReadParam(aReader, &aResult->mDivisor) ||
|
|
!ReadParam(aReader, &aResult->mBias) ||
|
|
!ReadParam(aReader, &aResult->mTarget) ||
|
|
!ReadParam(aReader, &aResult->mEdgeMode) ||
|
|
!ReadParam(aReader, &aResult->mKernelUnitLength) ||
|
|
!ReadParam(aReader, &aResult->mPreserveAlpha)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::DiffuseLightingAttributes> {
|
|
typedef mozilla::gfx::DiffuseLightingAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mLightType);
|
|
WriteParam(aWriter, aParam.mLightValues);
|
|
WriteParam(aWriter, aParam.mSurfaceScale);
|
|
WriteParam(aWriter, aParam.mKernelUnitLength);
|
|
WriteParam(aWriter, aParam.mColor);
|
|
WriteParam(aWriter, aParam.mLightingConstant);
|
|
WriteParam(aWriter, aParam.mSpecularExponent);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mLightType) ||
|
|
!ReadParam(aReader, &aResult->mLightValues) ||
|
|
!ReadParam(aReader, &aResult->mSurfaceScale) ||
|
|
!ReadParam(aReader, &aResult->mKernelUnitLength) ||
|
|
!ReadParam(aReader, &aResult->mColor) ||
|
|
!ReadParam(aReader, &aResult->mLightingConstant) ||
|
|
!ReadParam(aReader, &aResult->mSpecularExponent)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::SpecularLightingAttributes> {
|
|
typedef mozilla::gfx::SpecularLightingAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mLightType);
|
|
WriteParam(aWriter, aParam.mLightValues);
|
|
WriteParam(aWriter, aParam.mSurfaceScale);
|
|
WriteParam(aWriter, aParam.mKernelUnitLength);
|
|
WriteParam(aWriter, aParam.mColor);
|
|
WriteParam(aWriter, aParam.mLightingConstant);
|
|
WriteParam(aWriter, aParam.mSpecularExponent);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mLightType) ||
|
|
!ReadParam(aReader, &aResult->mLightValues) ||
|
|
!ReadParam(aReader, &aResult->mSurfaceScale) ||
|
|
!ReadParam(aReader, &aResult->mKernelUnitLength) ||
|
|
!ReadParam(aReader, &aResult->mColor) ||
|
|
!ReadParam(aReader, &aResult->mLightingConstant) ||
|
|
!ReadParam(aReader, &aResult->mSpecularExponent)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::CompositeAttributes> {
|
|
typedef mozilla::gfx::CompositeAttributes paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mOperator);
|
|
WriteParam(aWriter, aParam.mCoefficients);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mOperator) ||
|
|
!ReadParam(aReader, &aResult->mCoefficients)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::Glyph> {
|
|
typedef mozilla::gfx::Glyph paramType;
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mIndex);
|
|
WriteParam(aWriter, aParam.mPosition);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
return (ReadParam(aReader, &aResult->mIndex) &&
|
|
ReadParam(aReader, &aResult->mPosition));
|
|
}
|
|
};
|
|
|
|
template <typename T, size_t Length>
|
|
struct ParamTraits<mozilla::Array<T, Length>> {
|
|
typedef mozilla::Array<T, Length> paramType;
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
for (size_t i = 0; i < Length; i++) {
|
|
WriteParam(aWriter, aParam[i]);
|
|
}
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
for (size_t i = 0; i < Length; i++) {
|
|
if (!ReadParam<T>(aReader, &aResult->operator[](i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::SideBits>
|
|
: public BitFlagsEnumSerializer<mozilla::SideBits,
|
|
mozilla::SideBits::eAll> {};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxSparseBitSet> {
|
|
typedef gfxSparseBitSet paramType;
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mBlockIndex);
|
|
WriteParam(aWriter, aParam.mBlocks);
|
|
}
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
return ReadParam(aReader, &aResult->mBlockIndex) &&
|
|
ReadParam(aReader, &aResult->mBlocks);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<gfxSparseBitSet::Block> {
|
|
typedef gfxSparseBitSet::Block paramType;
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
aWriter->WriteBytes(&aParam, sizeof(aParam));
|
|
}
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
return aReader->ReadBytesInto(aResult, sizeof(*aResult));
|
|
}
|
|
};
|
|
|
|
// The actual FontVisibility enum is defined in gfxTypes.h
|
|
template <>
|
|
struct ParamTraits<FontVisibility>
|
|
: public ContiguousEnumSerializer<FontVisibility, FontVisibility::Unknown,
|
|
FontVisibility::Count> {};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::fontlist::Pointer> {
|
|
typedef mozilla::fontlist::Pointer paramType;
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
uint32_t v = aParam.mBlockAndOffset;
|
|
WriteParam(aWriter, v);
|
|
}
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
uint32_t v;
|
|
if (ReadParam(aReader, &v)) {
|
|
aResult->mBlockAndOffset.store(v);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct ParamTraits<mozilla::gfx::FenceInfo> {
|
|
typedef mozilla::gfx::FenceInfo paramType;
|
|
|
|
static void Write(MessageWriter* aWriter, const paramType& aParam) {
|
|
WriteParam(aWriter, aParam.mFenceHandle);
|
|
WriteParam(aWriter, aParam.mFenceValue);
|
|
}
|
|
|
|
static bool Read(MessageReader* aReader, paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mFenceHandle) ||
|
|
!ReadParam(aReader, &aResult->mFenceValue)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace IPC
|
|
|
|
namespace mozilla {
|
|
namespace ipc {
|
|
|
|
template <>
|
|
struct IPDLParamTraits<gfx::PaintFragment> {
|
|
typedef mozilla::gfx::PaintFragment paramType;
|
|
static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
|
|
paramType&& aParam) {
|
|
Shmem shmem;
|
|
if (aParam.mSize.IsEmpty() ||
|
|
!aActor->AllocShmem(aParam.mRecording.mLen, &shmem)) {
|
|
WriteParam(aWriter, gfx::IntSize(0, 0));
|
|
return;
|
|
}
|
|
|
|
memcpy(shmem.get<uint8_t>(), aParam.mRecording.mData,
|
|
aParam.mRecording.mLen);
|
|
|
|
WriteParam(aWriter, aParam.mSize);
|
|
WriteIPDLParam(aWriter, aActor, std::move(shmem));
|
|
WriteParam(aWriter, aParam.mDependencies);
|
|
}
|
|
|
|
static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
|
|
paramType* aResult) {
|
|
if (!ReadParam(aReader, &aResult->mSize)) {
|
|
return false;
|
|
}
|
|
if (aResult->mSize.IsEmpty()) {
|
|
return true;
|
|
}
|
|
Shmem shmem;
|
|
if (!ReadIPDLParam(aReader, aActor, &shmem) ||
|
|
!ReadParam(aReader, &aResult->mDependencies)) {
|
|
aActor->DeallocShmem(shmem);
|
|
return false;
|
|
}
|
|
|
|
if (!aResult->mRecording.Allocate(shmem.Size<uint8_t>())) {
|
|
aResult->mSize.SizeTo(0, 0);
|
|
aActor->DeallocShmem(shmem);
|
|
return true;
|
|
}
|
|
|
|
memcpy(aResult->mRecording.mData, shmem.get<uint8_t>(),
|
|
shmem.Size<uint8_t>());
|
|
aActor->DeallocShmem(shmem);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct IPDLParamTraits<gfx::FileHandleWrapper*> {
|
|
static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
|
|
gfx::FileHandleWrapper* aParam) {
|
|
if (!aParam) {
|
|
WriteIPDLParam(aWriter, aActor, false);
|
|
return;
|
|
}
|
|
WriteIPDLParam(aWriter, aActor, true);
|
|
|
|
mozilla::ipc::FileDescriptor desc(aParam->GetHandle());
|
|
WriteIPDLParam(aWriter, aActor, desc);
|
|
}
|
|
|
|
static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
|
|
RefPtr<gfx::FileHandleWrapper>* aResult) {
|
|
*aResult = nullptr;
|
|
bool notnull = false;
|
|
if (!ReadIPDLParam(aReader, aActor, ¬null)) {
|
|
return false;
|
|
}
|
|
|
|
if (!notnull) {
|
|
return true;
|
|
}
|
|
|
|
mozilla::ipc::FileDescriptor desc;
|
|
if (!ReadIPDLParam(aReader, aActor, &desc)) {
|
|
return false;
|
|
}
|
|
auto wrapper =
|
|
MakeRefPtr<gfx::FileHandleWrapper>(desc.TakePlatformHandle());
|
|
*aResult = std::move(wrapper);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace ipc
|
|
} // namespace mozilla
|
|
|
|
#endif /* __GFXMESSAGEUTILS_H__ */
|