Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1245 insertions, 0 deletions

diff --git a/gfx/ipc/GfxMessageUtils.h b/gfx/ipc/GfxMessageUtils.h
new file mode 100644
index 0000000000..e9b7b43e5a
--- /dev/null
+++ b/gfx/ipc/GfxMessageUtils.h
@@ -0,0 +1,1245 @@
+/* -*- 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/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/IPDLParamTraits.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 <>
+struct ParamTraits<mozilla::gfx::Matrix4x4> {
+  typedef mozilla::gfx::Matrix4x4 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;
+  }
+};
+
+}  // 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;
+  }
+};
+
+}  // namespace ipc
+}  // namespace mozilla
+
+#endif /* __GFXMESSAGEUTILS_H__ */