summaryrefslogtreecommitdiffstats
path: root/gfx/ipc/GfxMessageUtils.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/ipc/GfxMessageUtils.h')
-rw-r--r--gfx/ipc/GfxMessageUtils.h1273
1 files changed, 1273 insertions, 0 deletions
diff --git a/gfx/ipc/GfxMessageUtils.h b/gfx/ipc/GfxMessageUtils.h
new file mode 100644
index 000000000..e45aa7040
--- /dev/null
+++ b/gfx/ipc/GfxMessageUtils.h
@@ -0,0 +1,1273 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et 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 "FrameMetrics.h"
+#include "ImageTypes.h"
+#include "RegionBuilder.h"
+#include "base/process_util.h"
+#include "chrome/common/ipc_message_utils.h"
+#include "gfxPoint.h"
+#include "gfxRect.h"
+#include "gfxTelemetry.h"
+#include "gfxTypes.h"
+#include "ipc/IPCMessageUtils.h"
+#include "mozilla/gfx/Matrix.h"
+#include "mozilla/layers/AsyncDragMetrics.h"
+#include "mozilla/layers/CompositorTypes.h"
+#include "mozilla/layers/GeckoContentController.h"
+#include "mozilla/layers/LayersTypes.h"
+#include "nsRect.h"
+#include "nsRegion.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(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam._11);
+ WriteParam(aMsg, aParam._12);
+ WriteParam(aMsg, aParam._21);
+ WriteParam(aMsg, aParam._22);
+ WriteParam(aMsg, aParam._31);
+ WriteParam(aMsg, aParam._32);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ if (ReadParam(aMsg, aIter, &aResult->_11) &&
+ ReadParam(aMsg, aIter, &aResult->_12) &&
+ ReadParam(aMsg, aIter, &aResult->_21) &&
+ ReadParam(aMsg, aIter, &aResult->_22) &&
+ ReadParam(aMsg, aIter, &aResult->_31) &&
+ ReadParam(aMsg, aIter, &aResult->_32))
+ return true;
+
+ return false;
+ }
+
+ static void Log(const paramType& aParam, std::wstring* aLog)
+ {
+ aLog->append(StringPrintf(L"[[%g %g] [%g %g] [%g %g]]", aParam._11, aParam._12, aParam._21, aParam._22,
+ aParam._31, aParam._32));
+ }
+};
+
+template<>
+struct ParamTraits<mozilla::gfx::Matrix4x4>
+{
+ typedef mozilla::gfx::Matrix4x4 paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+#define Wr(_f) WriteParam(msg, 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(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+#define Rd(_f) ReadParam(msg, iter, &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(Message* msg, const paramType& param)
+ {
+#define Wr(_f) WriteParam(msg, 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(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+#define Rd(_f) ReadParam(msg, iter, &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(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.x);
+ WriteParam(aMsg, aParam.y);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->x) &&
+ ReadParam(aMsg, aIter, &aResult->y));
+ }
+};
+
+template<>
+struct ParamTraits<gfxSize>
+{
+ typedef gfxSize paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.width);
+ WriteParam(aMsg, aParam.height);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ if (ReadParam(aMsg, aIter, &aResult->width) &&
+ ReadParam(aMsg, aIter, &aResult->height))
+ return true;
+
+ return false;
+ }
+};
+
+template<>
+struct ParamTraits<gfxRect>
+{
+ typedef gfxRect paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.x);
+ WriteParam(aMsg, aParam.y);
+ WriteParam(aMsg, aParam.width);
+ WriteParam(aMsg, aParam.height);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return ReadParam(aMsg, aIter, &aResult->x) &&
+ ReadParam(aMsg, aIter, &aResult->y) &&
+ ReadParam(aMsg, aIter, &aResult->width) &&
+ ReadParam(aMsg, aIter, &aResult->height);
+ }
+};
+
+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::layers::LayersBackend>
+ : public ContiguousEnumSerializer<
+ mozilla::layers::LayersBackend,
+ mozilla::layers::LayersBackend::LAYERS_NONE,
+ mozilla::layers::LayersBackend::LAYERS_LAST>
+{};
+
+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::FeatureStatus>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::FeatureStatus,
+ mozilla::gfx::FeatureStatus::Unused,
+ mozilla::gfx::FeatureStatus::LAST>
+{};
+
+template <>
+struct ParamTraits<mozilla::layers::ScaleMode>
+ : public ContiguousEnumSerializer<
+ mozilla::layers::ScaleMode,
+ mozilla::layers::ScaleMode::SCALE_NONE,
+ mozilla::layers::ScaleMode::SENTINEL>
+{};
+
+template <>
+struct ParamTraits<mozilla::gfx::AttributeName>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::AttributeName,
+ mozilla::gfx::eBlendBlendmode,
+ mozilla::gfx::eLastAttributeName>
+{};
+
+template <>
+struct ParamTraits<mozilla::gfx::AttributeType>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::AttributeType,
+ mozilla::gfx::AttributeType::eBool,
+ mozilla::gfx::AttributeType::Max>
+{};
+
+template <>
+struct ParamTraits<mozilla::gfx::PrimitiveType>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::PrimitiveType,
+ mozilla::gfx::PrimitiveType::Empty,
+ mozilla::gfx::PrimitiveType::Max>
+{};
+
+template <>
+struct ParamTraits<mozilla::gfx::ColorSpace>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::ColorSpace,
+ mozilla::gfx::ColorSpace::SRGB,
+ mozilla::gfx::ColorSpace::Max>
+{};
+
+template <>
+struct ParamTraits<mozilla::layers::TextureFlags>
+ : public BitFlagsEnumSerializer<
+ mozilla::layers::TextureFlags,
+ mozilla::layers::TextureFlags::ALL_BITS>
+{};
+
+template <>
+struct ParamTraits<mozilla::layers::DiagnosticTypes>
+ : public BitFlagsEnumSerializer<
+ mozilla::layers::DiagnosticTypes,
+ mozilla::layers::DiagnosticTypes::ALL_BITS>
+{};
+
+/*
+template <>
+struct ParamTraits<mozilla::PixelFormat>
+ : public EnumSerializer<mozilla::PixelFormat,
+ SurfaceFormat::A8R8G8B8_UINT32,
+ SurfaceFormat::UNKNOWN>
+{};
+*/
+
+template<>
+struct ParamTraits<mozilla::gfx::Color>
+{
+ typedef mozilla::gfx::Color paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.r);
+ WriteParam(msg, param.g);
+ WriteParam(msg, param.b);
+ WriteParam(msg, param.a);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->r) &&
+ ReadParam(msg, iter, &result->g) &&
+ ReadParam(msg, iter, &result->b) &&
+ ReadParam(msg, iter, &result->a));
+ }
+};
+
+template<>
+struct ParamTraits<nsPoint>
+{
+ typedef nsPoint paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y));
+ }
+};
+
+template<>
+struct ParamTraits<nsIntPoint>
+{
+ typedef nsIntPoint paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y));
+ }
+};
+
+template<typename T>
+struct ParamTraits<mozilla::gfx::IntSizeTyped<T> >
+{
+ typedef mozilla::gfx::IntSizeTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<typename Region, typename Rect, typename Iter>
+struct RegionParamTraits
+{
+ typedef Region paramType;
+
+ static void Write(Message* msg, 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(msg, r);
+ }
+ // empty rects are sentinel values because nsRegions will never
+ // contain them
+ WriteParam(msg, Rect());
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ RegionBuilder<Region> builder;
+ Rect rect;
+ while (ReadParam(msg, iter, &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(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::CoordTyped<T> >
+{
+ typedef mozilla::gfx::CoordTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.value);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->value));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::IntCoordTyped<T> >
+{
+ typedef mozilla::gfx::IntCoordTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.value);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->value));
+ }
+};
+
+template<class T, class U>
+struct ParamTraits< mozilla::gfx::ScaleFactor<T, U> >
+{
+ typedef mozilla::gfx::ScaleFactor<T, U> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.scale);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->scale));
+ }
+};
+
+template<class T, class U>
+struct ParamTraits< mozilla::gfx::ScaleFactors2D<T, U> >
+{
+ typedef mozilla::gfx::ScaleFactors2D<T, U> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.xScale);
+ WriteParam(msg, param.yScale);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->xScale) &&
+ ReadParam(msg, iter, &result->yScale));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::PointTyped<T> >
+{
+ typedef mozilla::gfx::PointTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y));
+ }
+};
+
+template<class F, class T>
+struct ParamTraits< mozilla::gfx::Point3DTyped<F, T> >
+{
+ typedef mozilla::gfx::Point3DTyped<F, T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ WriteParam(msg, param.z);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y) &&
+ ReadParam(msg, iter, &result->z));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::IntPointTyped<T> >
+{
+ typedef mozilla::gfx::IntPointTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::SizeTyped<T> >
+{
+ typedef mozilla::gfx::SizeTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::RectTyped<T> >
+{
+ typedef mozilla::gfx::RectTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y) &&
+ ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::IntRectTyped<T> >
+{
+ typedef mozilla::gfx::IntRectTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y) &&
+ ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<>
+struct ParamTraits<mozilla::gfx::Margin>
+{
+ typedef mozilla::gfx::Margin paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.top);
+ WriteParam(msg, param.right);
+ WriteParam(msg, param.bottom);
+ WriteParam(msg, param.left);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->top) &&
+ ReadParam(msg, iter, &result->right) &&
+ ReadParam(msg, iter, &result->bottom) &&
+ ReadParam(msg, iter, &result->left));
+ }
+};
+
+template<class T>
+struct ParamTraits< mozilla::gfx::MarginTyped<T> >
+{
+ typedef mozilla::gfx::MarginTyped<T> paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.top);
+ WriteParam(msg, param.right);
+ WriteParam(msg, param.bottom);
+ WriteParam(msg, param.left);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->top) &&
+ ReadParam(msg, iter, &result->right) &&
+ ReadParam(msg, iter, &result->bottom) &&
+ ReadParam(msg, iter, &result->left));
+ }
+};
+
+template<>
+struct ParamTraits<nsRect>
+{
+ typedef nsRect paramType;
+
+ static void Write(Message* msg, const paramType& param)
+ {
+ WriteParam(msg, param.x);
+ WriteParam(msg, param.y);
+ WriteParam(msg, param.width);
+ WriteParam(msg, param.height);
+ }
+
+ static bool Read(const Message* msg, PickleIterator* iter, paramType* result)
+ {
+ return (ReadParam(msg, iter, &result->x) &&
+ ReadParam(msg, iter, &result->y) &&
+ ReadParam(msg, iter, &result->width) &&
+ ReadParam(msg, iter, &result->height));
+ }
+};
+
+template<>
+struct ParamTraits<nsRegion>
+ : RegionParamTraits<nsRegion, nsRect, nsRegion::RectIterator>
+{};
+
+template<>
+struct ParamTraits<mozilla::layers::FrameMetrics::ScrollOffsetUpdateType>
+ : public ContiguousEnumSerializer<
+ mozilla::layers::FrameMetrics::ScrollOffsetUpdateType,
+ mozilla::layers::FrameMetrics::ScrollOffsetUpdateType::eNone,
+ mozilla::layers::FrameMetrics::ScrollOffsetUpdateType::eSentinel>
+{};
+
+// Helper class for reading bitfields.
+// If T has bitfields members, derive ParamTraits<T> from BitfieldHelper<T>.
+template <typename ParamType>
+struct BitfieldHelper
+{
+ // We need this helper because we can't get the address of a bitfield to
+ // pass directly to ReadParam. So instead we read it into a temporary bool
+ // and set the bitfield using a setter function
+ static bool ReadBoolForBitfield(const Message* aMsg, PickleIterator* aIter,
+ ParamType* aResult, void (ParamType::*aSetter)(bool))
+ {
+ bool value;
+ if (ReadParam(aMsg, aIter, &value)) {
+ (aResult->*aSetter)(value);
+ return true;
+ }
+ return false;
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::FrameMetrics>
+ : BitfieldHelper<mozilla::layers::FrameMetrics>
+{
+ typedef mozilla::layers::FrameMetrics paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mScrollId);
+ WriteParam(aMsg, aParam.mPresShellResolution);
+ WriteParam(aMsg, aParam.mCompositionBounds);
+ WriteParam(aMsg, aParam.mDisplayPort);
+ WriteParam(aMsg, aParam.mCriticalDisplayPort);
+ WriteParam(aMsg, aParam.mScrollableRect);
+ WriteParam(aMsg, aParam.mCumulativeResolution);
+ WriteParam(aMsg, aParam.mDevPixelsPerCSSPixel);
+ WriteParam(aMsg, aParam.mScrollOffset);
+ WriteParam(aMsg, aParam.mZoom);
+ WriteParam(aMsg, aParam.mScrollGeneration);
+ WriteParam(aMsg, aParam.mSmoothScrollOffset);
+ WriteParam(aMsg, aParam.mRootCompositionSize);
+ WriteParam(aMsg, aParam.mDisplayPortMargins);
+ WriteParam(aMsg, aParam.mPresShellId);
+ WriteParam(aMsg, aParam.mViewport);
+ WriteParam(aMsg, aParam.mExtraResolution);
+ WriteParam(aMsg, aParam.mPaintRequestTime);
+ WriteParam(aMsg, aParam.mScrollUpdateType);
+ WriteParam(aMsg, aParam.mIsRootContent);
+ WriteParam(aMsg, aParam.mDoSmoothScroll);
+ WriteParam(aMsg, aParam.mUseDisplayPortMargins);
+ WriteParam(aMsg, aParam.mIsScrollInfoLayer);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mScrollId) &&
+ ReadParam(aMsg, aIter, &aResult->mPresShellResolution) &&
+ ReadParam(aMsg, aIter, &aResult->mCompositionBounds) &&
+ ReadParam(aMsg, aIter, &aResult->mDisplayPort) &&
+ ReadParam(aMsg, aIter, &aResult->mCriticalDisplayPort) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollableRect) &&
+ ReadParam(aMsg, aIter, &aResult->mCumulativeResolution) &&
+ ReadParam(aMsg, aIter, &aResult->mDevPixelsPerCSSPixel) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollOffset) &&
+ ReadParam(aMsg, aIter, &aResult->mZoom) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollGeneration) &&
+ ReadParam(aMsg, aIter, &aResult->mSmoothScrollOffset) &&
+ ReadParam(aMsg, aIter, &aResult->mRootCompositionSize) &&
+ ReadParam(aMsg, aIter, &aResult->mDisplayPortMargins) &&
+ ReadParam(aMsg, aIter, &aResult->mPresShellId) &&
+ ReadParam(aMsg, aIter, &aResult->mViewport) &&
+ ReadParam(aMsg, aIter, &aResult->mExtraResolution) &&
+ ReadParam(aMsg, aIter, &aResult->mPaintRequestTime) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollUpdateType) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetIsRootContent) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetDoSmoothScroll) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetUseDisplayPortMargins) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetIsScrollInfoLayer));
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::ScrollSnapInfo>
+{
+ typedef mozilla::layers::ScrollSnapInfo paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mScrollSnapTypeX);
+ WriteParam(aMsg, aParam.mScrollSnapTypeY);
+ WriteParam(aMsg, aParam.mScrollSnapIntervalX);
+ WriteParam(aMsg, aParam.mScrollSnapIntervalY);
+ WriteParam(aMsg, aParam.mScrollSnapDestination);
+ WriteParam(aMsg, aParam.mScrollSnapCoordinates);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mScrollSnapTypeX) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollSnapTypeY) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollSnapIntervalX) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollSnapIntervalY) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollSnapDestination) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollSnapCoordinates));
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::LayerClip>
+{
+ typedef mozilla::layers::LayerClip paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mClipRect);
+ WriteParam(aMsg, aParam.mMaskLayerIndex);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mClipRect) &&
+ ReadParam(aMsg, aIter, &aResult->mMaskLayerIndex));
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::ScrollMetadata>
+ : BitfieldHelper<mozilla::layers::ScrollMetadata>
+{
+ typedef mozilla::layers::ScrollMetadata paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mMetrics);
+ WriteParam(aMsg, aParam.mSnapInfo);
+ WriteParam(aMsg, aParam.mScrollParentId);
+ WriteParam(aMsg, aParam.mBackgroundColor);
+ WriteParam(aMsg, aParam.GetContentDescription());
+ WriteParam(aMsg, aParam.mLineScrollAmount);
+ WriteParam(aMsg, aParam.mPageScrollAmount);
+ WriteParam(aMsg, aParam.mScrollClip);
+ WriteParam(aMsg, aParam.mHasScrollgrab);
+ WriteParam(aMsg, aParam.mAllowVerticalScrollWithWheel);
+ WriteParam(aMsg, aParam.mIsLayersIdRoot);
+ WriteParam(aMsg, aParam.mUsesContainerScrolling);
+ WriteParam(aMsg, aParam.mForceDisableApz);
+ }
+
+ static bool ReadContentDescription(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ nsCString str;
+ if (!ReadParam(aMsg, aIter, &str)) {
+ return false;
+ }
+ aResult->SetContentDescription(str);
+ return true;
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mMetrics) &&
+ ReadParam(aMsg, aIter, &aResult->mSnapInfo) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollParentId) &&
+ ReadParam(aMsg, aIter, &aResult->mBackgroundColor) &&
+ ReadContentDescription(aMsg, aIter, aResult) &&
+ ReadParam(aMsg, aIter, &aResult->mLineScrollAmount) &&
+ ReadParam(aMsg, aIter, &aResult->mPageScrollAmount) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollClip) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetHasScrollgrab) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetAllowVerticalScrollWithWheel) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetIsLayersIdRoot) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetUsesContainerScrolling) &&
+ ReadBoolForBitfield(aMsg, aIter, aResult, &paramType::SetForceDisableApz));
+ }
+};
+
+template<>
+struct ParamTraits<GeckoProcessType>
+ : public ContiguousEnumSerializer<
+ GeckoProcessType,
+ GeckoProcessType_Default,
+ GeckoProcessType_End>
+{};
+
+template<>
+struct ParamTraits<mozilla::layers::TextureFactoryIdentifier>
+{
+ typedef mozilla::layers::TextureFactoryIdentifier paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mParentBackend);
+ WriteParam(aMsg, aParam.mParentProcessType);
+ WriteParam(aMsg, aParam.mMaxTextureSize);
+ WriteParam(aMsg, aParam.mSupportsTextureBlitting);
+ WriteParam(aMsg, aParam.mSupportsPartialUploads);
+ WriteParam(aMsg, aParam.mSupportsComponentAlpha);
+ WriteParam(aMsg, aParam.mSyncHandle);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ bool result = ReadParam(aMsg, aIter, &aResult->mParentBackend) &&
+ ReadParam(aMsg, aIter, &aResult->mParentProcessType) &&
+ ReadParam(aMsg, aIter, &aResult->mMaxTextureSize) &&
+ ReadParam(aMsg, aIter, &aResult->mSupportsTextureBlitting) &&
+ ReadParam(aMsg, aIter, &aResult->mSupportsPartialUploads) &&
+ ReadParam(aMsg, aIter, &aResult->mSupportsComponentAlpha) &&
+ ReadParam(aMsg, aIter, &aResult->mSyncHandle);
+ return result;
+ }
+};
+
+template<>
+struct ParamTraits<mozilla::layers::TextureInfo>
+{
+ typedef mozilla::layers::TextureInfo paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mCompositableType);
+ WriteParam(aMsg, aParam.mTextureFlags);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return ReadParam(aMsg, aIter, &aResult->mCompositableType) &&
+ ReadParam(aMsg, aIter, &aResult->mTextureFlags);
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::CompositableType>
+ : public ContiguousEnumSerializer<
+ mozilla::layers::CompositableType,
+ mozilla::layers::CompositableType::UNKNOWN,
+ mozilla::layers::CompositableType::COUNT>
+{};
+
+template <>
+struct ParamTraits<mozilla::gfx::SurfaceFormat>
+ : public ContiguousEnumSerializer<
+ mozilla::gfx::SurfaceFormat,
+ mozilla::gfx::SurfaceFormat::B8G8R8A8,
+ mozilla::gfx::SurfaceFormat::UNKNOWN>
+{};
+
+template <>
+struct ParamTraits<mozilla::StereoMode>
+ : public ContiguousEnumSerializer<
+ mozilla::StereoMode,
+ mozilla::StereoMode::MONO,
+ mozilla::StereoMode::MAX>
+{};
+
+template <>
+struct ParamTraits<mozilla::YUVColorSpace>
+ : public ContiguousEnumSerializer<
+ mozilla::YUVColorSpace,
+ mozilla::YUVColorSpace::BT601,
+ mozilla::YUVColorSpace::UNKNOWN>
+{};
+
+template <>
+struct ParamTraits<mozilla::layers::ScrollableLayerGuid>
+{
+ typedef mozilla::layers::ScrollableLayerGuid paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mLayersId);
+ WriteParam(aMsg, aParam.mPresShellId);
+ WriteParam(aMsg, aParam.mScrollId);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mLayersId) &&
+ ReadParam(aMsg, aIter, &aResult->mPresShellId) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollId));
+ }
+};
+
+
+template <>
+struct ParamTraits<mozilla::layers::ZoomConstraints>
+{
+ typedef mozilla::layers::ZoomConstraints paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mAllowZoom);
+ WriteParam(aMsg, aParam.mAllowDoubleTapZoom);
+ WriteParam(aMsg, aParam.mMinZoom);
+ WriteParam(aMsg, aParam.mMaxZoom);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mAllowZoom) &&
+ ReadParam(aMsg, aIter, &aResult->mAllowDoubleTapZoom) &&
+ ReadParam(aMsg, aIter, &aResult->mMinZoom) &&
+ ReadParam(aMsg, aIter, &aResult->mMaxZoom));
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::layers::EventRegions>
+{
+ typedef mozilla::layers::EventRegions paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mHitRegion);
+ WriteParam(aMsg, aParam.mDispatchToContentHitRegion);
+ WriteParam(aMsg, aParam.mNoActionRegion);
+ WriteParam(aMsg, aParam.mHorizontalPanRegion);
+ WriteParam(aMsg, aParam.mVerticalPanRegion);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mHitRegion) &&
+ ReadParam(aMsg, aIter, &aResult->mDispatchToContentHitRegion) &&
+ ReadParam(aMsg, aIter, &aResult->mNoActionRegion) &&
+ ReadParam(aMsg, aIter, &aResult->mHorizontalPanRegion) &&
+ ReadParam(aMsg, aIter, &aResult->mVerticalPanRegion));
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::gfx::AttributeMap>
+{
+ typedef mozilla::gfx::AttributeMap paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.Count());
+ for (auto iter = aParam.ConstIter(); !iter.Done(); iter.Next()) {
+ mozilla::gfx::AttributeName name =
+ mozilla::gfx::AttributeName(iter.Key());
+ mozilla::gfx::AttributeType type =
+ mozilla::gfx::AttributeMap::GetType(iter.UserData());
+
+ WriteParam(aMsg, type);
+ WriteParam(aMsg, name);
+
+ switch (type) {
+
+#define CASE_TYPE(typeName) \
+ case mozilla::gfx::AttributeType::e##typeName: \
+ WriteParam(aMsg, aParam.Get##typeName(name)); \
+ break;
+
+ CASE_TYPE(Bool)
+ CASE_TYPE(Uint)
+ CASE_TYPE(Float)
+ CASE_TYPE(Size)
+ CASE_TYPE(IntSize)
+ CASE_TYPE(IntPoint)
+ CASE_TYPE(Matrix)
+ CASE_TYPE(Matrix5x4)
+ CASE_TYPE(Point3D)
+ CASE_TYPE(Color)
+ CASE_TYPE(AttributeMap)
+ CASE_TYPE(Floats)
+
+#undef CASE_TYPE
+
+ default:
+ MOZ_CRASH("GFX: unhandled attribute type");
+ }
+ }
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ uint32_t count;
+ if (!ReadParam(aMsg, aIter, &count)) {
+ return false;
+ }
+ for (uint32_t i = 0; i < count; i++) {
+ mozilla::gfx::AttributeType type;
+ if (!ReadParam(aMsg, aIter, &type)) {
+ return false;
+ }
+ mozilla::gfx::AttributeName name;
+ if (!ReadParam(aMsg, aIter, &name)) {
+ return false;
+ }
+ switch (type) {
+
+#define HANDLE_TYPE(type, typeName) \
+ case mozilla::gfx::AttributeType::e##typeName: \
+ { \
+ type value; \
+ if (!ReadParam(aMsg, aIter, &value)) { \
+ return false; \
+ } \
+ aResult->Set(name, value); \
+ break; \
+ }
+
+ HANDLE_TYPE(bool, Bool)
+ HANDLE_TYPE(uint32_t, Uint)
+ HANDLE_TYPE(float, Float)
+ HANDLE_TYPE(mozilla::gfx::Size, Size)
+ HANDLE_TYPE(mozilla::gfx::IntSize, IntSize)
+ HANDLE_TYPE(mozilla::gfx::IntPoint, IntPoint)
+ HANDLE_TYPE(mozilla::gfx::Matrix, Matrix)
+ HANDLE_TYPE(mozilla::gfx::Matrix5x4, Matrix5x4)
+ HANDLE_TYPE(mozilla::gfx::Point3D, Point3D)
+ HANDLE_TYPE(mozilla::gfx::Color, Color)
+ HANDLE_TYPE(mozilla::gfx::AttributeMap, AttributeMap)
+
+#undef HANDLE_TYPE
+
+ case mozilla::gfx::AttributeType::eFloats:
+ {
+ nsTArray<float> value;
+ if (!ReadParam(aMsg, aIter, &value)) {
+ return false;
+ }
+ aResult->Set(name, &value[0], value.Length());
+ break;
+ }
+ default:
+ MOZ_CRASH("GFX: unhandled attribute type");
+ }
+ }
+ return true;
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::gfx::FilterPrimitiveDescription>
+{
+ typedef mozilla::gfx::FilterPrimitiveDescription paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.Type());
+ WriteParam(aMsg, aParam.PrimitiveSubregion());
+ WriteParam(aMsg, aParam.FilterSpaceBounds());
+ WriteParam(aMsg, aParam.IsTainted());
+ WriteParam(aMsg, aParam.OutputColorSpace());
+ WriteParam(aMsg, aParam.NumberOfInputs());
+ for (size_t i = 0; i < aParam.NumberOfInputs(); i++) {
+ WriteParam(aMsg, aParam.InputPrimitiveIndex(i));
+ WriteParam(aMsg, aParam.InputColorSpace(i));
+ }
+ WriteParam(aMsg, aParam.Attributes());
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ mozilla::gfx::PrimitiveType type;
+ mozilla::gfx::IntRect primitiveSubregion;
+ mozilla::gfx::IntRect filterSpaceBounds;
+ bool isTainted = false;
+ mozilla::gfx::ColorSpace outputColorSpace;
+ size_t numberOfInputs = 0;
+ if (!ReadParam(aMsg, aIter, &type) ||
+ !ReadParam(aMsg, aIter, &primitiveSubregion) ||
+ !ReadParam(aMsg, aIter, &filterSpaceBounds) ||
+ !ReadParam(aMsg, aIter, &isTainted) ||
+ !ReadParam(aMsg, aIter, &outputColorSpace) ||
+ !ReadParam(aMsg, aIter, &numberOfInputs)) {
+ return false;
+ }
+
+ aResult->SetType(type);
+ aResult->SetPrimitiveSubregion(primitiveSubregion);
+ aResult->SetFilterSpaceBounds(filterSpaceBounds);
+ aResult->SetIsTainted(isTainted);
+ aResult->SetOutputColorSpace(outputColorSpace);
+
+ for (size_t i = 0; i < numberOfInputs; i++) {
+ int32_t inputPrimitiveIndex = 0;
+ mozilla::gfx::ColorSpace inputColorSpace;
+ if (!ReadParam(aMsg, aIter, &inputPrimitiveIndex) ||
+ !ReadParam(aMsg, aIter, &inputColorSpace)) {
+ return false;
+ }
+ aResult->SetInputPrimitive(i, inputPrimitiveIndex);
+ aResult->SetInputColorSpace(i, inputColorSpace);
+ }
+
+ return ReadParam(aMsg, aIter, &aResult->Attributes());
+ }
+};
+
+template <>
+struct ParamTraits<mozilla::gfx::FilterDescription>
+{
+ typedef mozilla::gfx::FilterDescription paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mPrimitives);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mPrimitives));
+ }
+};
+
+typedef mozilla::layers::GeckoContentController::TapType TapType;
+
+template <>
+struct ParamTraits<TapType>
+ : public ContiguousEnumSerializer<
+ TapType,
+ TapType::eSingleTap,
+ TapType::eSentinel>
+{};
+
+typedef mozilla::layers::GeckoContentController::APZStateChange APZStateChange;
+
+template <>
+struct ParamTraits<APZStateChange>
+ : public ContiguousEnumSerializer<
+ APZStateChange,
+ APZStateChange::eTransformBegin,
+ APZStateChange::eSentinel>
+{};
+
+template<>
+struct ParamTraits<mozilla::layers::EventRegionsOverride>
+ : public BitFlagsEnumSerializer<
+ mozilla::layers::EventRegionsOverride,
+ mozilla::layers::EventRegionsOverride::ALL_BITS>
+{};
+
+template<>
+struct ParamTraits<mozilla::layers::AsyncDragMetrics::DragDirection>
+ : public ContiguousEnumSerializer<
+ mozilla::layers::AsyncDragMetrics::DragDirection,
+ mozilla::layers::AsyncDragMetrics::DragDirection::NONE,
+ mozilla::layers::AsyncDragMetrics::DragDirection::SENTINEL>
+{};
+
+template<>
+struct ParamTraits<mozilla::layers::AsyncDragMetrics>
+{
+ typedef mozilla::layers::AsyncDragMetrics paramType;
+
+ static void Write(Message* aMsg, const paramType& aParam)
+ {
+ WriteParam(aMsg, aParam.mViewId);
+ WriteParam(aMsg, aParam.mPresShellId);
+ WriteParam(aMsg, aParam.mDragStartSequenceNumber);
+ WriteParam(aMsg, aParam.mScrollbarDragOffset);
+ WriteParam(aMsg, aParam.mScrollTrack);
+ WriteParam(aMsg, aParam.mDirection);
+ }
+
+ static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+ {
+ return (ReadParam(aMsg, aIter, &aResult->mViewId) &&
+ ReadParam(aMsg, aIter, &aResult->mPresShellId) &&
+ ReadParam(aMsg, aIter, &aResult->mDragStartSequenceNumber) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollbarDragOffset) &&
+ ReadParam(aMsg, aIter, &aResult->mScrollTrack) &&
+ ReadParam(aMsg, aIter, &aResult->mDirection));
+ }
+};
+
+} /* namespace IPC */
+
+#endif /* __GFXMESSAGEUTILS_H__ */