Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 626 insertions, 0 deletions

diff --git a/gfx/thebes/gfxUtils.h b/gfx/thebes/gfxUtils.h
new file mode 100644
index 0000000000..a7b9f067eb
--- /dev/null
+++ b/gfx/thebes/gfxUtils.h
@@ -0,0 +1,626 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 GFX_UTILS_H
+#define GFX_UTILS_H
+
+#include "gfxMatrix.h"
+#include "gfxRect.h"
+#include "gfxTypes.h"
+#include "ImageTypes.h"
+#include "imgIContainer.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "nsColor.h"
+#include "nsContentUtils.h"
+#include "nsPrintfCString.h"
+#include "nsRegionFwd.h"
+#include "mozilla/gfx/Rect.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/webrender/WebRenderTypes.h"
+#include "qcms.h"
+
+class gfxASurface;
+class gfxDrawable;
+class gfxTextRun;
+struct gfxQuad;
+class nsICookieJarSettings;
+class nsIInputStream;
+class nsIGfxInfo;
+
+namespace mozilla {
+namespace dom {
+class Element;
+}  // namespace dom
+namespace layers {
+class WebRenderBridgeChild;
+class GlyphArray;
+struct PlanarYCbCrData;
+class WebRenderCommand;
+}  // namespace layers
+namespace image {
+class ImageRegion;
+}  // namespace image
+namespace wr {
+class DisplayListBuilder;
+}  // namespace wr
+}  // namespace mozilla
+
+enum class ImageType {
+  BMP,
+  ICO,
+  JPEG,
+  PNG,
+};
+
+class gfxUtils {
+ public:
+  typedef mozilla::gfx::DataSourceSurface DataSourceSurface;
+  typedef mozilla::gfx::DrawTarget DrawTarget;
+  typedef mozilla::gfx::IntPoint IntPoint;
+  typedef mozilla::gfx::Matrix Matrix;
+  typedef mozilla::gfx::Matrix4x4 Matrix4x4;
+  typedef mozilla::gfx::SourceSurface SourceSurface;
+  typedef mozilla::gfx::SurfaceFormat SurfaceFormat;
+  typedef mozilla::image::ImageRegion ImageRegion;
+
+  /*
+   * Premultiply or Unpremultiply aSourceSurface, writing the result
+   * to aDestSurface or back into aSourceSurface if aDestSurface is null.
+   *
+   * If aDestSurface is given, it must have identical format, dimensions, and
+   * stride as the source.
+   *
+   * If the source is not SurfaceFormat::A8R8G8B8_UINT32, no operation is
+   * performed.  If aDestSurface is given, the data is copied over.
+   */
+  static bool PremultiplyDataSurface(DataSourceSurface* srcSurf,
+                                     DataSourceSurface* destSurf);
+  static bool UnpremultiplyDataSurface(DataSourceSurface* srcSurf,
+                                       DataSourceSurface* destSurf);
+
+  static already_AddRefed<DataSourceSurface> CreatePremultipliedDataSurface(
+      DataSourceSurface* srcSurf);
+  static already_AddRefed<DataSourceSurface> CreateUnpremultipliedDataSurface(
+      DataSourceSurface* srcSurf);
+
+  static void ConvertBGRAtoRGBA(uint8_t* aData, uint32_t aLength);
+
+  /**
+   * Draw something drawable while working around limitations like bad support
+   * for EXTEND_PAD, lack of source-clipping, or cairo / pixman bugs with
+   * extreme user-space-to-image-space transforms.
+   *
+   * The input parameters here usually come from the output of our image
+   * snapping algorithm in nsLayoutUtils.cpp.
+   * This method is split from nsLayoutUtils::DrawPixelSnapped to allow for
+   * adjusting the parameters. For example, certain images with transparent
+   * margins only have a drawable subimage. For those images, imgFrame::Draw
+   * will tweak the rects and transforms that it gets from the pixel snapping
+   * algorithm before passing them on to this method.
+   */
+  static void DrawPixelSnapped(gfxContext* aContext, gfxDrawable* aDrawable,
+                               const gfxSize& aImageSize,
+                               const ImageRegion& aRegion,
+                               const mozilla::gfx::SurfaceFormat aFormat,
+                               mozilla::gfx::SamplingFilter aSamplingFilter,
+                               uint32_t aImageFlags = imgIContainer::FLAG_NONE,
+                               gfxFloat aOpacity = 1.0,
+                               bool aUseOptimalFillOp = true);
+
+  /**
+   * Clip aContext to the region aRegion.
+   */
+  static void ClipToRegion(gfxContext* aContext, const nsIntRegion& aRegion);
+
+  /**
+   * Clip aTarget to the region aRegion.
+   */
+  static void ClipToRegion(mozilla::gfx::DrawTarget* aTarget,
+                           const nsIntRegion& aRegion);
+
+  /*
+   * Convert image format to depth value
+   */
+  static int ImageFormatToDepth(gfxImageFormat aFormat);
+
+  /**
+   * Return the transform matrix that maps aFrom to the rectangle defined by
+   * aToTopLeft/aToTopRight/aToBottomRight. aFrom must be
+   * nonempty and the destination rectangle must be axis-aligned.
+   */
+  static gfxMatrix TransformRectToRect(const gfxRect& aFrom,
+                                       const gfxPoint& aToTopLeft,
+                                       const gfxPoint& aToTopRight,
+                                       const gfxPoint& aToBottomRight);
+
+  static Matrix TransformRectToRect(const gfxRect& aFrom,
+                                    const IntPoint& aToTopLeft,
+                                    const IntPoint& aToTopRight,
+                                    const IntPoint& aToBottomRight);
+
+  /**
+   * If aIn can be represented exactly using an gfx::IntRect (i.e.
+   * integer-aligned edges and coordinates in the int32_t range) then we
+   * set aOut to that rectangle, otherwise return failure.
+   */
+  static bool GfxRectToIntRect(const gfxRect& aIn, mozilla::gfx::IntRect* aOut);
+
+  /* Conditions this border to Cairo's max coordinate space.
+   * The caller can check IsEmpty() after Condition() -- if it's TRUE,
+   * the caller can possibly avoid doing any extra rendering.
+   */
+  static void ConditionRect(gfxRect& aRect);
+
+  /*
+   * Transform this rectangle with aMatrix, resulting in a gfxQuad.
+   */
+  static gfxQuad TransformToQuad(const gfxRect& aRect,
+                                 const mozilla::gfx::Matrix4x4& aMatrix);
+
+  /**
+   * Return the smallest power of kScaleResolution (2) greater than or equal to
+   * aVal. If aRoundDown is specified, the power of 2 will rather be less than
+   * or equal to aVal.
+   */
+  static float ClampToScaleFactor(float aVal, bool aRoundDown = false);
+
+  /**
+   * We can snap layer transforms for two reasons:
+   * 1) To avoid unnecessary resampling when a transform is a translation
+   * by a non-integer number of pixels.
+   * Snapping the translation to an integer number of pixels avoids
+   * blurring the layer and can be faster to composite.
+   * 2) When a layer is used to render a rectangular object, we need to
+   * emulate the rendering of rectangular inactive content and snap the
+   * edges of the rectangle to pixel boundaries. This is both to ensure
+   * layer rendering is consistent with inactive content rendering, and to
+   * avoid seams.
+   * This function implements type 1 snapping. If aTransform is a 2D
+   * translation, and this layer's layer manager has enabled snapping
+   * (which is the default), return aTransform with the translation snapped
+   * to nearest pixels. Otherwise just return aTransform. Call this when the
+   * layer does not correspond to a single rectangular content object.
+   * This function does not try to snap if aTransform has a scale, because in
+   * that case resampling is inevitable and there's no point in trying to
+   * avoid it. In fact snapping can cause problems because pixel edges in the
+   * layer's content can be rendered unpredictably (jiggling) as the scale
+   * interacts with the snapping of the translation, especially with animated
+   * transforms.
+   * @param aResidualTransform a transform to apply before the result transform
+   * in order to get the results to completely match aTransform.
+   */
+  static Matrix4x4 SnapTransformTranslation(const Matrix4x4& aTransform,
+                                            Matrix* aResidualTransform);
+  static Matrix SnapTransformTranslation(const Matrix& aTransform,
+                                         Matrix* aResidualTransform);
+  static Matrix4x4 SnapTransformTranslation3D(const Matrix4x4& aTransform,
+                                              Matrix* aResidualTransform);
+  /**
+   * See comment for SnapTransformTranslation.
+   * This function implements type 2 snapping. If aTransform is a translation
+   * and/or scale, transform aSnapRect by aTransform, snap to pixel boundaries,
+   * and return the transform that maps aSnapRect to that rect. Otherwise
+   * just return aTransform.
+   * @param aSnapRect a rectangle whose edges should be snapped to pixel
+   * boundaries in the destination surface.
+   * @param aResidualTransform a transform to apply before the result transform
+   * in order to get the results to completely match aTransform.
+   */
+  static Matrix4x4 SnapTransform(const Matrix4x4& aTransform,
+                                 const gfxRect& aSnapRect,
+                                 Matrix* aResidualTransform);
+  static Matrix SnapTransform(const Matrix& aTransform,
+                              const gfxRect& aSnapRect,
+                              Matrix* aResidualTransform);
+
+  /**
+   * Clears surface to aColor (which defaults to transparent black).
+   */
+  static void ClearThebesSurface(gfxASurface* aSurface);
+
+  static const float* YuvToRgbMatrix4x3RowMajor(
+      mozilla::gfx::YUVColorSpace aYUVColorSpace);
+  static const float* YuvToRgbMatrix3x3ColumnMajor(
+      mozilla::gfx::YUVColorSpace aYUVColorSpace);
+  static const float* YuvToRgbMatrix4x4ColumnMajor(
+      mozilla::gfx::YUVColorSpace aYUVColorSpace);
+
+  static mozilla::Maybe<mozilla::gfx::YUVColorSpace> CicpToColorSpace(
+      const mozilla::gfx::CICP::MatrixCoefficients,
+      const mozilla::gfx::CICP::ColourPrimaries,
+      mozilla::LazyLogModule& aLogger);
+
+  static mozilla::Maybe<mozilla::gfx::ColorSpace2> CicpToColorPrimaries(
+      const mozilla::gfx::CICP::ColourPrimaries,
+      mozilla::LazyLogModule& aLogger);
+
+  static mozilla::Maybe<mozilla::gfx::TransferFunction> CicpToTransferFunction(
+      const mozilla::gfx::CICP::TransferCharacteristics);
+
+  /**
+   * Creates a copy of aSurface, but having the SurfaceFormat aFormat.
+   *
+   * This function always creates a new surface. Do not call it if aSurface's
+   * format is the same as aFormat. Such a non-conversion would just be an
+   * unnecessary and wasteful copy (this function asserts to prevent that).
+   *
+   * This function is intended to be called by code that needs to access the
+   * pixel data of the surface, but doesn't want to have lots of branches
+   * to handle different pixel data formats (code which would become out of
+   * date if and when new formats are added). Callers can use this function
+   * to copy the surface to a specified format so that they only have to
+   * handle pixel data in that one format.
+   *
+   * WARNING: There are format conversions that will not be supported by this
+   * function. It very much depends on what the Moz2D backends support. If
+   * the temporary B8G8R8A8 DrawTarget that this function creates has a
+   * backend that supports DrawSurface() calls passing a surface with
+   * aSurface's format it will work. Otherwise it will not.
+   *
+   *                      *** IMPORTANT PERF NOTE ***
+   *
+   * This function exists partly because format conversion is fraught with
+   * non-obvious performance hazards, so we don't want Moz2D consumers to be
+   * doing their own format conversion. Do not try to do so, or at least read
+   * the comments in this functions implemtation. That said, the copy that
+   * this function carries out has a cost and, although this function tries
+   * to avoid perf hazards such as expensive uploads to/readbacks from the
+   * GPU, it can't guarantee that it always successfully does so. Perf
+   * critical code that can directly handle the common formats that it
+   * encounters in a way that is cheaper than a copy-with-format-conversion
+   * should consider doing so, and only use this function as a fallback to
+   * handle other formats.
+   *
+   * XXXjwatt it would be nice if SourceSurface::GetDataSurface took a
+   * SurfaceFormat argument (with a default argument meaning "use the
+   * existing surface's format") and returned a DataSourceSurface in that
+   * format. (There would then be an issue of callers maybe failing to
+   * realize format conversion may involve expensive copying/uploading/
+   * readback.)
+   */
+  static already_AddRefed<DataSourceSurface>
+  CopySurfaceToDataSourceSurfaceWithFormat(SourceSurface* aSurface,
+                                           SurfaceFormat aFormat);
+
+  /**
+   * Return a color that can be used to identify a frame with a given frame
+   * number. The colors will cycle after sNumFrameColors.  You can query colors
+   * 0 .. sNumFrameColors-1 to get all the colors back.
+   */
+  static const mozilla::gfx::DeviceColor& GetColorForFrameNumber(
+      uint64_t aFrameNumber);
+  static const uint32_t sNumFrameColors;
+
+  enum BinaryOrData { eBinaryEncode, eDataURIEncode };
+
+  /**
+   * Encodes the given surface to PNG/JPEG/BMP/etc. using imgIEncoder.
+   * If both aFile and aString are null, the encoded data is copied to the
+   * clipboard.
+   *
+   * @param aImageType The image type that the surface is to be encoded to.
+   *   Used to create an appropriate imgIEncoder instance to do the encoding.
+   *
+   * @param aOutputOptions Passed directly to imgIEncoder::InitFromData as
+   *   the value of the |outputOptions| parameter. Callers are responsible
+   *   for making sure that this is a reasonable value for the passed MIME-type
+   *   (i.e. for the type of encoder that will be created).
+   *
+   * @aBinaryOrData Flag used to determine if the surface is simply encoded
+   *   to the requested binary image format, or if the binary image is
+   *   further converted to base-64 and written out as a 'data:' URI.
+   *
+   * @aFile If specified, the encoded data is written out to aFile.
+   *
+   * @aString If specified, the encoded data is written out to aString.
+   *
+   * TODO: Copying to the clipboard as a binary file is not currently
+   * supported.
+   */
+  static nsresult EncodeSourceSurface(SourceSurface* aSurface,
+                                      const ImageType aImageType,
+                                      const nsAString& aOutputOptions,
+                                      BinaryOrData aBinaryOrData, FILE* aFile,
+                                      nsACString* aString = nullptr);
+
+  /**
+   * Encodes the given surface to PNG/JPEG/BMP/etc. using imgIEncoder
+   * and returns the result as an nsIInputStream.
+   *
+   * @param aSurface The source surface to encode
+   *
+   * @param aImageType The image type that the surface is to be encoded to.
+   *   Used to create an appropriate imgIEncoder instance to do the encoding.
+   *
+   * @param aOutputOptions Passed directly to imgIEncoder::InitFromData as
+   *   the value of the |outputOptions| parameter. Callers are responsible
+   *   for making sure that this is a reasonable value for the passed MIME-type
+   *   (i.e. for the type of encoder that will be created).
+   *
+   * @param aOutStream pointer to the output stream
+   *
+   */
+  static nsresult EncodeSourceSurfaceAsStream(SourceSurface* aSurface,
+                                              const ImageType aImageType,
+                                              const nsAString& aOutputOptions,
+                                              nsIInputStream** aOutStream);
+
+  /**
+   * Encodes the given surface to PNG/JPEG/BMP/etc. using imgIEncoder
+   * and returns the result as a vector of bytes
+   *
+   * @param aImageType The image type that the surface is to be encoded to.
+   *   Used to create an appropriate imgIEncoder instance to do the encoding.
+   *
+   * @param aOutputOptions Passed directly to imgIEncoder::InitFromData as
+   *   the value of the |outputOptions| parameter. Callers are responsible
+   *   for making sure that this is a reasonable value for the passed MIME-type
+   *   (i.e. for the type of encoder that will be created).
+   *
+   */
+  static mozilla::Maybe<nsTArray<uint8_t>> EncodeSourceSurfaceAsBytes(
+      SourceSurface* aSurface, const ImageType aImageType,
+      const nsAString& aOutputOptions);
+
+  /**
+   * Write as a PNG file to the path aFile.
+   */
+  static void WriteAsPNG(SourceSurface* aSurface, const nsAString& aFile);
+  static void WriteAsPNG(SourceSurface* aSurface, const char* aFile);
+  static void WriteAsPNG(DrawTarget* aDT, const nsAString& aFile);
+  static void WriteAsPNG(DrawTarget* aDT, const char* aFile);
+
+  /**
+   * Dump as a PNG encoded Data URL to a FILE stream (using stdout by
+   * default).
+   *
+   * Rather than giving aFile a default argument we have separate functions
+   * to make them easier to use from a debugger.
+   */
+  static void DumpAsDataURI(SourceSurface* aSourceSurface, FILE* aFile);
+  static inline void DumpAsDataURI(SourceSurface* aSourceSurface) {
+    DumpAsDataURI(aSourceSurface, stdout);
+  }
+  static void DumpAsDataURI(DrawTarget* aDT, FILE* aFile);
+  static inline void DumpAsDataURI(DrawTarget* aDT) {
+    DumpAsDataURI(aDT, stdout);
+  }
+  static nsCString GetAsDataURI(SourceSurface* aSourceSurface);
+  static nsCString GetAsDataURI(DrawTarget* aDT);
+  static nsCString GetAsLZ4Base64Str(DataSourceSurface* aSourceSurface);
+
+  static mozilla::UniquePtr<uint8_t[]> GetImageBuffer(
+      DataSourceSurface* aSurface, bool aIsAlphaPremultiplied,
+      int32_t* outFormat);
+
+  static mozilla::UniquePtr<uint8_t[]> GetImageBufferWithRandomNoise(
+      DataSourceSurface* aSurface, bool aIsAlphaPremultiplied,
+      nsICookieJarSettings* aCookieJarSettings, int32_t* outFormat);
+
+  static nsresult GetInputStream(DataSourceSurface* aSurface,
+                                 bool aIsAlphaPremultiplied,
+                                 const char* aMimeType,
+                                 const nsAString& aEncoderOptions,
+                                 nsIInputStream** outStream);
+
+  static nsresult GetInputStreamWithRandomNoise(
+      DataSourceSurface* aSurface, bool aIsAlphaPremultiplied,
+      const char* aMimeType, const nsAString& aEncoderOptions,
+      nsICookieJarSettings* aCookieJarSettings, nsIInputStream** outStream);
+
+  static void RemoveShaderCacheFromDiskIfNecessary();
+
+  /**
+   * Copy to the clipboard as a PNG encoded Data URL.
+   */
+  static void CopyAsDataURI(SourceSurface* aSourceSurface);
+  static void CopyAsDataURI(DrawTarget* aDT);
+
+  static bool DumpDisplayList();
+
+  static FILE* sDumpPaintFile;
+};
+
+namespace mozilla {
+
+// Container for either a single element of type T, or an nsTArray<T>.
+// Provides a minimal subset of nsTArray's API, just enough to support use
+// by ContextState for the clipsAndTransforms list, and by gfxTextRun for
+// its mGlyphRuns.
+// Using this instead of a simple nsTArray avoids an extra allocation in the
+// common case where no more than one element is ever added to the list.
+// Unlike an AutoTArray<..., 1>, this class is memmovable and therefore can
+// be used in ContextState without breaking its movability.
+template <typename T>
+class ElementOrArray {
+  union {
+    T mElement;
+    nsTArray<T> mArray;
+  };
+  enum class Tag : uint8_t {
+    Element,
+    Array,
+  } mTag;
+
+  // gfxTextRun::SortGlyphRuns and SanitizeGlyphRuns directly access the array.
+  friend class ::gfxTextRun;
+  nsTArray<T>& Array() {
+    MOZ_DIAGNOSTIC_ASSERT(mTag == Tag::Array);
+    return mArray;
+  }
+
+ public:
+  // Construct as an empty array.
+  ElementOrArray() : mTag(Tag::Array) { new (&mArray) nsTArray<T>(); }
+
+  // For now, don't support copy/move.
+  ElementOrArray(const ElementOrArray&) = delete;
+  ElementOrArray(ElementOrArray&&) = delete;
+
+  ElementOrArray& operator=(const ElementOrArray&) = delete;
+  ElementOrArray& operator=(ElementOrArray&&) = delete;
+
+  // Destroy the appropriate variant.
+  ~ElementOrArray() {
+    switch (mTag) {
+      case Tag::Element:
+        mElement.~T();
+        break;
+      case Tag::Array:
+        mArray.~nsTArray();
+        break;
+    }
+  }
+
+  size_t Length() const { return mTag == Tag::Element ? 1 : mArray.Length(); }
+
+  T* AppendElement(const T& aElement) {
+    switch (mTag) {
+      case Tag::Element: {
+        // Move the existing element into an array, then append the new one.
+        T temp = std::move(mElement);
+        mElement.~T();
+        mTag = Tag::Array;
+        new (&mArray) nsTArray<T>();
+        mArray.AppendElement(std::move(temp));
+        return mArray.AppendElement(aElement);
+      }
+      case Tag::Array: {
+        // If currently empty, just store the element directly.
+        if (mArray.IsEmpty()) {
+          mArray.~nsTArray();
+          mTag = Tag::Element;
+          new (&mElement) T(aElement);
+          return &mElement;
+        }
+        // Otherwise, append it to the array.
+        return mArray.AppendElement(aElement);
+      }
+      default:
+        MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("invalid tag");
+    }
+  }
+
+  const T& LastElement() const {
+    return mTag == Tag::Element ? mElement : mArray.LastElement();
+  }
+
+  T& LastElement() {
+    return mTag == Tag::Element ? mElement : mArray.LastElement();
+  }
+
+  bool IsEmpty() const {
+    return mTag == Tag::Element ? false : mArray.IsEmpty();
+  }
+
+  void TruncateLength(uint32_t aLength = 0) {
+    MOZ_DIAGNOSTIC_ASSERT(aLength <= Length());
+    switch (mTag) {
+      case Tag::Element:
+        if (aLength == 0) {
+          // Destroy the single element, and convert to an empty array.
+          mElement.~T();
+          mTag = Tag::Array;
+          new (&mArray) nsTArray<T>();
+        }
+        break;
+      case Tag::Array:
+        mArray.TruncateLength(aLength);
+        break;
+    }
+  }
+
+  void Clear() {
+    switch (mTag) {
+      case Tag::Element:
+        mElement.~T();
+        mTag = Tag::Array;
+        new (&mArray) nsTArray<T>();
+        break;
+      case Tag::Array:
+        mArray.Clear();
+        break;
+    }
+  }
+
+  // Convert from Array to Element storage. Only to be used when the current
+  // state is a single-element array!
+  void ConvertToElement() {
+    MOZ_DIAGNOSTIC_ASSERT(mTag == Tag::Array && mArray.Length() == 1);
+    T temp = std::move(mArray[0]);
+    mArray.~nsTArray();
+    mTag = Tag::Element;
+    new (&mElement) T(std::move(temp));
+  }
+
+  const T& operator[](uint32_t aIndex) const {
+    MOZ_DIAGNOSTIC_ASSERT(aIndex < Length());
+    return mTag == Tag::Element ? mElement : mArray[aIndex];
+  }
+  T& operator[](uint32_t aIndex) {
+    MOZ_DIAGNOSTIC_ASSERT(aIndex < Length());
+    return mTag == Tag::Element ? mElement : mArray[aIndex];
+  }
+
+  // Simple iterators to support range-for loops.
+  const T* begin() const {
+    return mTag == Tag::Array ? mArray.IsEmpty() ? nullptr : &*mArray.begin()
+                              : &mElement;
+  }
+  T* begin() {
+    return mTag == Tag::Array ? mArray.IsEmpty() ? nullptr : &*mArray.begin()
+                              : &mElement;
+  }
+
+  const T* end() const {
+    return mTag == Tag::Array ? begin() + mArray.Length() : &mElement + 1;
+  }
+  T* end() {
+    return mTag == Tag::Array ? begin() + mArray.Length() : &mElement + 1;
+  }
+
+  size_t ShallowSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) {
+    return mTag == Tag::Array ? mArray.ShallowSizeOfExcludingThis(aMallocSizeOf)
+                              : 0;
+  }
+};
+
+struct StyleAbsoluteColor;
+
+namespace gfx {
+
+/**
+ * If the CMS mode is CMSMode::All, these functions transform the passed
+ * color to a device color using the transform returned by
+ * gfxPlatform::GetCMSRGBTransform().  If the CMS mode is some other value, the
+ * color is returned unchanged (other than a type change to Moz2D Color, if
+ * applicable).
+ */
+DeviceColor ToDeviceColor(const sRGBColor&);
+DeviceColor ToDeviceColor(const StyleAbsoluteColor&);
+DeviceColor ToDeviceColor(nscolor);
+
+sRGBColor ToSRGBColor(const StyleAbsoluteColor&);
+
+/**
+ * Performs a checked multiply of the given width, height, and bytes-per-pixel
+ * values.
+ */
+static inline CheckedInt<uint32_t> SafeBytesForBitmap(uint32_t aWidth,
+                                                      uint32_t aHeight,
+                                                      unsigned aBytesPerPixel) {
+  MOZ_ASSERT(aBytesPerPixel > 0);
+  CheckedInt<uint32_t> width = uint32_t(aWidth);
+  CheckedInt<uint32_t> height = uint32_t(aHeight);
+  return width * height * aBytesPerPixel;
+}
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif