DrawTargetWebgl.h - mozsearch

mozilla-central/dom/canvas/DrawTargetWebgl.h (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 _MOZILLA_GFX_DRAWTARGETWEBGL_H

#define _MOZILLA_GFX_DRAWTARGETWEBGL_H

#include "GLTypes.h"

#include "mozilla/Array.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/gfx/PathSkia.h"

#include "mozilla/LinkedList.h"

#include "mozilla/WeakPtr.h"

#include "mozilla/ThreadLocal.h"

#include "mozilla/ipc/SharedMemoryBasic.h"

#include "mozilla/layers/LayersTypes.h"

#include <vector>

namespace WGR {

struct OutputVertex;

struct PathBuilder;

}  // namespace WGR

namespace mozilla {

class WebGLContext;

class WebGLBuffer;

class WebGLFramebuffer;

class WebGLProgram;

class WebGLRenderbuffer;

class WebGLTexture;

class WebGLUniformLocation;

class WebGLVertexArray;

namespace gl {

class GLContext;

}  // namespace gl

namespace layers {

class RemoteTextureOwnerClient;

}  // namespace layers

namespace gfx {

class DataSourceSurface;

class DrawTargetSkia;

class DrawTargetWebgl;

class PathSkia;

class SourceSurfaceSkia;

class SourceSurfaceWebgl;

class TextureHandle;

class SharedTexture;

class SharedTextureHandle;

class StandaloneTexture;

class GlyphCache;

class PathCache;

struct PathVertexRange;

// SharedContextWebgl stores most of the actual WebGL state that may be used by

// any number of DrawTargetWebgl's that use it. Foremost, it holds the actual

// WebGL client context, programs, and buffers for mapping to WebGL.

// Secondarily, it holds shared caches for surfaces, glyphs, paths, and

// shadows so that each DrawTargetWebgl does not require its own cache. It is

// important that SetTarget is called to install the current DrawTargetWebgl

// before actually using the SharedContext, as the individual framebuffers

// and viewport are still maintained in DrawTargetWebgl itself.

class SharedContextWebgl : public mozilla::RefCounted<SharedContextWebgl>,

                           public mozilla::SupportsWeakPtr {

  friend class DrawTargetWebgl;

  friend class SourceSurfaceWebgl;

  friend class TextureHandle;

  friend class SharedTextureHandle;

  friend class StandaloneTexture;

 public:

  MOZ_DECLARE_REFCOUNTED_TYPENAME(SharedContextWebgl)

  static already_AddRefed<SharedContextWebgl> Create();

  ~SharedContextWebgl();

  gl::GLContext* GetGLContext();

  void EnterTlsScope();

  void ExitTlsScope();

  bool IsContextLost() const;

  void OnMemoryPressure();

  void ClearCaches();

 private:

  SharedContextWebgl();

  WeakPtr<DrawTargetWebgl> mCurrentTarget;

  IntSize mViewportSize;

  // The current integer-aligned scissor rect.

  IntRect mClipRect;

  // The current fractional AA'd clip rect bounds.

  Rect mClipAARect;

  RefPtr<WebGLContext> mWebgl;

  // Avoid spurious state changes by caching last used state.

  RefPtr<WebGLProgram> mLastProgram;

  RefPtr<WebGLTexture> mLastTexture;

  RefPtr<WebGLTexture> mLastClipMask;

  // WebGL shader resources

  RefPtr<WebGLBuffer> mPathVertexBuffer;

  RefPtr<WebGLVertexArray> mPathVertexArray;

  // The current insertion offset into the GPU path buffer.

  uint32_t mPathVertexOffset = 0;

  // The maximum size of the GPU path buffer.

  uint32_t mPathVertexCapacity = 0;

  // The maximum supported type complexity of a GPU path.

  uint32_t mPathMaxComplexity = 0;

  // Whether to accelerate stroked paths with AAStroke.

  bool mPathAAStroke = true;

  // Whether to accelerate stroked paths with WGR.

  bool mPathWGRStroke = false;

  WGR::PathBuilder* mWGRPathBuilder = nullptr;

  // Temporary buffer for generating WGR output into.

  UniquePtr<WGR::OutputVertex[]> mWGROutputBuffer;

  RefPtr<WebGLProgram> mSolidProgram;

  Maybe<uint32_t> mSolidProgramViewport;

  Maybe<uint32_t> mSolidProgramAA;

  Maybe<uint32_t> mSolidProgramTransform;

  Maybe<uint32_t> mSolidProgramColor;

  Maybe<uint32_t> mSolidProgramClipMask;

  Maybe<uint32_t> mSolidProgramClipBounds;

  RefPtr<WebGLProgram> mImageProgram;

  Maybe<uint32_t> mImageProgramViewport;

  Maybe<uint32_t> mImageProgramAA;

  Maybe<uint32_t> mImageProgramTransform;

  Maybe<uint32_t> mImageProgramTexMatrix;

  Maybe<uint32_t> mImageProgramTexBounds;

  Maybe<uint32_t> mImageProgramColor;

  Maybe<uint32_t> mImageProgramSwizzle;

  Maybe<uint32_t> mImageProgramSampler;

  Maybe<uint32_t> mImageProgramClipMask;

  Maybe<uint32_t> mImageProgramClipBounds;

  struct SolidProgramUniformState {

    Maybe<Array<float, 2>> mViewport;

    Maybe<Array<float, 1>> mAA;

    Maybe<Array<float, 6>> mTransform;

    Maybe<Array<float, 4>> mColor;

    Maybe<Array<float, 4>> mClipBounds;

  } mSolidProgramUniformState;

  struct ImageProgramUniformState {

    Maybe<Array<float, 2>> mViewport;

    Maybe<Array<float, 1>> mAA;

    Maybe<Array<float, 6>> mTransform;

    Maybe<Array<float, 6>> mTexMatrix;

    Maybe<Array<float, 4>> mTexBounds;

    Maybe<Array<float, 4>> mColor;

    Maybe<Array<float, 1>> mSwizzle;

    Maybe<Array<float, 4>> mClipBounds;

  } mImageProgramUniformState;

  // Scratch framebuffer used to wrap textures for miscellaneous utility ops.

  RefPtr<WebGLFramebuffer> mScratchFramebuffer;

  // Buffer filled with zero data for initializing textures.

  RefPtr<WebGLBuffer> mZeroBuffer;

  size_t mZeroSize = 0;

  // 1x1 texture with solid white mask for disabling clipping

  RefPtr<WebGLTexture> mNoClipMask;

  uint32_t mMaxTextureSize = 0;

  bool mRasterizationTruncates = false;

  // The current blending operation.

  CompositionOp mLastCompositionOp = CompositionOp::OP_SOURCE;

  // The constant blend color used for the blending operation.

  Maybe<DeviceColor> mLastBlendColor;

  // The cached scissor state. Operations that rely on scissor state should

  // take care to enable or disable the cached scissor state as necessary.

  bool mScissorEnabled = false;

  IntRect mLastScissor = {-1, -1, -1, -1};

  // A most-recently-used list of allocated texture handles.

  LinkedList<RefPtr<TextureHandle>> mTextureHandles;

  size_t mNumTextureHandles = 0;

  // User data key linking a SourceSurface with its TextureHandle.

  UserDataKey mTextureHandleKey = {0};

  // User data key linking a SourceSurface with its shadow blur TextureHandle.

  UserDataKey mShadowTextureKey = {0};

  // User data key linking a ScaledFont with its GlyphCache.

  UserDataKey mGlyphCacheKey = {0};

  // List of all GlyphCaches currently allocated to fonts.

  LinkedList<GlyphCache> mGlyphCaches;

  // Cache of rasterized paths.

  UniquePtr<PathCache> mPathCache;

  // Collection of allocated shared texture pages that may be shared amongst

  // many handles.

  std::vector<RefPtr<SharedTexture>> mSharedTextures;

  // Collection of allocated standalone textures that have a single assigned

  // handle.

  std::vector<RefPtr<StandaloneTexture>> mStandaloneTextures;

  size_t mUsedTextureMemory = 0;

  size_t mTotalTextureMemory = 0;

  // The total reserved memory for empty texture pages that are kept around

  // for future allocations.

  size_t mEmptyTextureMemory = 0;

  // A memory pressure event may signal from another thread that caches should

  // be cleared if possible.

  Atomic<bool> mShouldClearCaches;

  // The total number of DrawTargetWebgls using this shared context.

  size_t mDrawTargetCount = 0;

  // Whether we are inside a scoped usage of TLS MakeCurrent, and what previous

  // value to restore it to when exiting the scope.

  Maybe<bool> mTlsScope;

  // Cached unit circle path

  RefPtr<Path> mUnitCirclePath;

  bool Initialize();

  bool CreateShaders();

  void ResetPathVertexBuffer(bool aChanged = true);

  void BlendFunc(GLenum aSrcFactor, GLenum aDstFactor);

  void SetBlendState(CompositionOp aOp,

                     const Maybe<DeviceColor>& aColor = Nothing());

  void SetClipRect(const Rect& aClipRect);

  void SetClipRect(const IntRect& aClipRect) { SetClipRect(Rect(aClipRect)); }

  bool SetClipMask(const RefPtr<WebGLTexture>& aTex);

  bool SetNoClipMask();

  bool HasClipMask() const {

    return mLastClipMask && mLastClipMask != mNoClipMask;

  Maybe<uint32_t> GetUniformLocation(const RefPtr<WebGLProgram>& prog,

                                     const std::string& aName) const;

  template <class T, size_t N>

  void UniformData(GLenum aFuncElemType, const Maybe<uint32_t>& aLoc,

                   const Array<T, N>& aData);

  // Avoids redundant UniformData calls by caching the previously set value.

  template <class T, size_t N>

  void MaybeUniformData(GLenum aFuncElemType, const Maybe<uint32_t>& aLoc,

                        const Array<T, N>& aData, Maybe<Array<T, N>>& aCached);

  bool IsCurrentTarget(DrawTargetWebgl* aDT) const {

    return aDT == mCurrentTarget;

  bool SetTarget(DrawTargetWebgl* aDT);

  // Reset the current target.

  void ClearTarget() { mCurrentTarget = nullptr; }

  // Reset the last used texture to force binding next use.

  void ClearLastTexture(bool aFullClear = false);

  bool SupportsPattern(const Pattern& aPattern);

  void EnableScissor(const IntRect& aRect);

  void DisableScissor();

  void SetTexFilter(WebGLTexture* aTex, bool aFilter);

  void InitTexParameters(WebGLTexture* aTex, bool aFilter = true);

  bool ReadInto(uint8_t* aDstData, int32_t aDstStride, SurfaceFormat aFormat,

                const IntRect& aBounds, TextureHandle* aHandle = nullptr);

  already_AddRefed<DataSourceSurface> ReadSnapshot(

      TextureHandle* aHandle = nullptr);

  already_AddRefed<TextureHandle> WrapSnapshot(const IntSize& aSize,

                                               SurfaceFormat aFormat,

                                               RefPtr<WebGLTexture> aTex);

  already_AddRefed<TextureHandle> CopySnapshot(

      const IntRect& aRect, TextureHandle* aHandle = nullptr);

  already_AddRefed<WebGLTexture> GetCompatibleSnapshot(

      SourceSurface* aSurface) const;

  bool IsCompatibleSurface(SourceSurface* aSurface) const;

  bool UploadSurface(DataSourceSurface* aData, SurfaceFormat aFormat,

                     const IntRect& aSrcRect, const IntPoint& aDstOffset,

                     bool aInit, bool aZero = false,

                     const RefPtr<WebGLTexture>& aTex = nullptr);

  already_AddRefed<TextureHandle> AllocateTextureHandle(

      SurfaceFormat aFormat, const IntSize& aSize, bool aAllowShared = true,

      bool aRenderable = false);

  void DrawQuad();

  void DrawTriangles(const PathVertexRange& aRange);

  bool DrawRectAccel(const Rect& aRect, const Pattern& aPattern,

                     const DrawOptions& aOptions,

                     Maybe<DeviceColor> aMaskColor = Nothing(),

                     RefPtr<TextureHandle>* aHandle = nullptr,

                     bool aTransformed = true, bool aClipped = true,

                     bool aAccelOnly = false, bool aForceUpdate = false,

                     const StrokeOptions* aStrokeOptions = nullptr,

                     const PathVertexRange* aVertexRange = nullptr,

                     const Matrix* aRectXform = nullptr);

  already_AddRefed<TextureHandle> DrawStrokeMask(

      const PathVertexRange& aVertexRange, const IntSize& aSize);

  bool DrawPathAccel(const Path* aPath, const Pattern& aPattern,

                     const DrawOptions& aOptions,

                     const StrokeOptions* aStrokeOptions = nullptr,

                     bool aAllowStrokeAlpha = false,

                     const ShadowOptions* aShadow = nullptr,

                     bool aCacheable = true,

                     const Matrix* aPathXform = nullptr);

  bool DrawCircleAccel(const Point& aCenter, float aRadius,

                       const Pattern& aPattern, const DrawOptions& aOptions,

                       const StrokeOptions* aStrokeOptions = nullptr);

  bool DrawGlyphsAccel(ScaledFont* aFont, const GlyphBuffer& aBuffer,

                       const Pattern& aPattern, const DrawOptions& aOptions,

                       const StrokeOptions* aStrokeOptions,

                       bool aUseSubpixelAA);

  void PruneTextureHandle(const RefPtr<TextureHandle>& aHandle);

  bool PruneTextureMemory(size_t aMargin = 0, bool aPruneUnused = true);

  bool RemoveSharedTexture(const RefPtr<SharedTexture>& aTexture);

  bool RemoveStandaloneTexture(const RefPtr<StandaloneTexture>& aTexture);

  void UnlinkSurfaceTextures();

  void UnlinkSurfaceTexture(const RefPtr<TextureHandle>& aHandle);

  void UnlinkGlyphCaches();

  void ClearAllTextures();

  void ClearEmptyTextureMemory();

  void ClearCachesIfNecessary();

  void CachePrefs();

};

// DrawTargetWebgl implements a subset of the DrawTarget API suitable for use

// by CanvasRenderingContext2D. It maps these to a client WebGL context so that

// they can be accelerated where possible by WebGL. It manages both routing to

// appropriate shaders and texture allocation/caching for surfaces. For commands

// that are not feasible to accelerate with WebGL, it mirrors state to a backup

// DrawTargetSkia that can be used as a fallback software renderer. Multiple

// instances of DrawTargetWebgl within a process will actually share a single

// WebGL context so that data can be more easily interchanged between them and

// also to enable more reasonable limiting of resource usage.

class DrawTargetWebgl : public DrawTarget, public SupportsWeakPtr {

  friend class SourceSurfaceWebgl;

  friend class SharedContextWebgl;

 public:

  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetWebgl, override)

 private:

  IntSize mSize;

  RefPtr<WebGLFramebuffer> mFramebuffer;

  RefPtr<WebGLTexture> mTex;

  RefPtr<WebGLTexture> mClipMask;

  // The integer-aligned, scissor-compatible conservative bounds of the clip.

  IntRect mClipBounds;

  // The fractional, AA'd bounds of the clip rect, if applicable.

  Rect mClipAARect;

  RefPtr<DrawTargetSkia> mSkia;

  // Skia DT pointing to the same pixel data, but without any applied clips.

  RefPtr<DrawTargetSkia> mSkiaNoClip;

  // The Shmem backing the Skia DT, if applicable.

  RefPtr<mozilla::ipc::SharedMemoryBasic> mShmem;

  // The currently cached snapshot of the WebGL context

  RefPtr<SourceSurfaceWebgl> mSnapshot;

  // The mappable size of mShmem.

  uint32_t mShmemSize = 0;

  // Whether the framebuffer is still in the initially clear state.

  bool mIsClear = true;

  // Whether or not the Skia target has valid contents and is being drawn to

  bool mSkiaValid = false;

  // Whether or not Skia layering over the WebGL context is enabled

  bool mSkiaLayer = false;

  // Whether the WebGL target was clear when the Skia layer was established.

  bool mSkiaLayerClear = false;

  // Whether or not the WebGL context has valid contents and is being drawn to

  bool mWebglValid = true;

  // Whether or not the clip state has changed since last used by

  // SharedContextWebgl.

  bool mClipChanged = true;

  // Whether or not the clip state needs to be refreshed. Sometimes the clip

  // state may be overwritten and require a refresh later, even though it has

  // not changed.

  bool mRefreshClipState = true;

  // The number of layers currently pushed.

  int32_t mLayerDepth = 0;

  RefPtr<TextureHandle> mSnapshotTexture;

  // Store a log of clips currently pushed so that they can be used to init

  // the clip state of temporary DTs.

  struct ClipStack {

    Matrix mTransform;

    Rect mRect;

    RefPtr<const Path> mPath;

    bool operator==(const ClipStack& aOther) const;

};

  std::vector<ClipStack> mClipStack;

  // The previous state of the clip stack when a mask was generated.

  std::vector<ClipStack> mCachedClipStack;

  // UsageProfile stores per-frame counters for significant profiling events

  // that assist in determining whether acceleration should still be used for

  // a Canvas2D user.

  struct UsageProfile {

    uint32_t mFailedFrames = 0;

    uint32_t mFrameCount = 0;

    uint32_t mCacheMisses = 0;

    uint32_t mCacheHits = 0;

    uint32_t mUncachedDraws = 0;

    uint32_t mLayers = 0;

    uint32_t mReadbacks = 0;

    uint32_t mFallbacks = 0;

    void BeginFrame();

    void EndFrame();

    bool RequiresRefresh() const;

    void OnCacheMiss() { ++mCacheMisses; }

    void OnCacheHit() { ++mCacheHits; }

    void OnUncachedDraw() { ++mUncachedDraws; }

    void OnLayer() { ++mLayers; }

    void OnReadback() { ++mReadbacks; }

    void OnFallback() { ++mFallbacks; }

};

  UsageProfile mProfile;

  RefPtr<SharedContextWebgl> mSharedContext;

 public:

  DrawTargetWebgl();

  ~DrawTargetWebgl();

  static bool CanCreate(const IntSize& aSize, SurfaceFormat aFormat);

  static already_AddRefed<DrawTargetWebgl> Create(

      const IntSize& aSize, SurfaceFormat aFormat,

      const RefPtr<SharedContextWebgl>& aSharedContext);

  bool Init(const IntSize& aSize, SurfaceFormat aFormat,

            const RefPtr<SharedContextWebgl>& aSharedContext);

  bool IsValid() const override;

  DrawTargetType GetType() const override {

    return DrawTargetType::HARDWARE_RASTER;

  BackendType GetBackendType() const override { return BackendType::WEBGL; }

  IntSize GetSize() const override { return mSize; }

  const RefPtr<SharedContextWebgl>& GetSharedContext() const {

    return mSharedContext;

  bool HasDataSnapshot() const;

  bool EnsureDataSnapshot();

  void PrepareShmem();

  already_AddRefed<SourceSurface> GetDataSnapshot();

  already_AddRefed<SourceSurface> Snapshot() override;

  already_AddRefed<SourceSurface> GetOptimizedSnapshot(DrawTarget* aTarget);

  already_AddRefed<SourceSurface> GetBackingSurface() override;

  void DetachAllSnapshots() override;

  void BeginFrame(bool aInvalidContents = false);

  void EndFrame();

  bool RequiresRefresh() const { return mProfile.RequiresRefresh(); }

  bool LockBits(uint8_t** aData, IntSize* aSize, int32_t* aStride,

                SurfaceFormat* aFormat, IntPoint* aOrigin = nullptr) override;

  void ReleaseBits(uint8_t* aData) override;

  void Flush() override {}

  void DrawSurface(

      SourceSurface* aSurface, const Rect& aDest, const Rect& aSource,

      const DrawSurfaceOptions& aSurfOptions = DrawSurfaceOptions(),

      const DrawOptions& aOptions = DrawOptions()) override;

  void DrawFilter(FilterNode* aNode, const Rect& aSourceRect,

                  const Point& aDestPoint,

                  const DrawOptions& aOptions = DrawOptions()) override;

  void DrawSurfaceWithShadow(SourceSurface* aSurface, const Point& aDest,

                             const ShadowOptions& aShadow,

                             CompositionOp aOperator) override;

  void DrawShadow(const Path* aPath, const Pattern& aPattern,

                  const ShadowOptions& aShadow, const DrawOptions& aOptions,

                  const StrokeOptions* aStrokeOptions = nullptr) override;

  void ClearRect(const Rect& aRect) override;

  void CopySurface(SourceSurface* aSurface, const IntRect& aSourceRect,

                   const IntPoint& aDestination) override;

  void FillRect(const Rect& aRect, const Pattern& aPattern,

                const DrawOptions& aOptions = DrawOptions()) override;

  void StrokeRect(const Rect& aRect, const Pattern& aPattern,

                  const StrokeOptions& aStrokeOptions = StrokeOptions(),

                  const DrawOptions& aOptions = DrawOptions()) override;

  bool StrokeLineAccel(const Point& aStart, const Point& aEnd,

                       const Pattern& aPattern,

                       const StrokeOptions& aStrokeOptions,

                       const DrawOptions& aOptions, bool aClosed = false);

  void StrokeLine(const Point& aStart, const Point& aEnd,

                  const Pattern& aPattern,

                  const StrokeOptions& aStrokeOptions = StrokeOptions(),

                  const DrawOptions& aOptions = DrawOptions()) override;

  void Stroke(const Path* aPath, const Pattern& aPattern,

              const StrokeOptions& aStrokeOptions = StrokeOptions(),

              const DrawOptions& aOptions = DrawOptions()) override;

  void Fill(const Path* aPath, const Pattern& aPattern,

            const DrawOptions& aOptions = DrawOptions()) override;

  void FillCircle(const Point& aOrigin, float aRadius, const Pattern& aPattern,

                  const DrawOptions& aOptions = DrawOptions()) override;

  void StrokeCircle(const Point& aOrigin, float aRadius,

                    const Pattern& aPattern,

                    const StrokeOptions& aStrokeOptions = StrokeOptions(),

                    const DrawOptions& aOptions = DrawOptions()) override;

  void SetPermitSubpixelAA(bool aPermitSubpixelAA) override;

  void FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,

                  const Pattern& aPattern,

                  const DrawOptions& aOptions = DrawOptions()) override;

  void StrokeGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer,

                    const Pattern& aPattern,

                    const StrokeOptions& aStrokeOptions = StrokeOptions(),

                    const DrawOptions& aOptions = DrawOptions()) override;

  void Mask(const Pattern& aSource, const Pattern& aMask,

            const DrawOptions& aOptions = DrawOptions()) override;

  void MaskSurface(const Pattern& aSource, SourceSurface* aMask, Point aOffset,

                   const DrawOptions& aOptions = DrawOptions()) override;

  bool Draw3DTransformedSurface(SourceSurface* aSurface,

                                const Matrix4x4& aMatrix) override;

  void PushClip(const Path* aPath) override;

  void PushClipRect(const Rect& aRect) override;

  void PushDeviceSpaceClipRects(const IntRect* aRects,

                                uint32_t aCount) override;

  void PopClip() override;

  bool RemoveAllClips() override;

  void CopyToFallback(DrawTarget* aDT);

  void PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask,

                 const Matrix& aMaskTransform,

                 const IntRect& aBounds = IntRect(),

                 bool aCopyBackground = false) override;

  void PushLayerWithBlend(

      bool aOpaque, Float aOpacity, SourceSurface* aMask,

      const Matrix& aMaskTransform, const IntRect& aBounds = IntRect(),

      bool aCopyBackground = false,

      CompositionOp aCompositionOp = CompositionOp::OP_OVER) override;

  void PopLayer() override;

  already_AddRefed<SourceSurface> CreateSourceSurfaceFromData(

      unsigned char* aData, const IntSize& aSize, int32_t aStride,

      SurfaceFormat aFormat) const override;

  already_AddRefed<SourceSurface> OptimizeSourceSurface(

      SourceSurface* aSurface) const override;

  already_AddRefed<SourceSurface> OptimizeSourceSurfaceForUnknownAlpha(

      SourceSurface* aSurface) const override;

  already_AddRefed<SourceSurface> CreateSourceSurfaceFromNativeSurface(

      const NativeSurface& aSurface) const override;

  already_AddRefed<DrawTarget> CreateSimilarDrawTarget(

      const IntSize& aSize, SurfaceFormat aFormat) const override;

  bool CanCreateSimilarDrawTarget(const IntSize& aSize,

                                  SurfaceFormat aFormat) const override;

  RefPtr<DrawTarget> CreateClippedDrawTarget(const Rect& aBounds,

                                             SurfaceFormat aFormat) override;

  already_AddRefed<PathBuilder> CreatePathBuilder(

      FillRule aFillRule = FillRule::FILL_WINDING) const override;

  already_AddRefed<GradientStops> CreateGradientStops(

      GradientStop* aStops, uint32_t aNumStops,

      ExtendMode aExtendMode = ExtendMode::CLAMP) const override;

  already_AddRefed<FilterNode> CreateFilter(FilterType aType) override;

  void SetTransform(const Matrix& aTransform) override;

  void* GetNativeSurface(NativeSurfaceType aType) override;

  bool CopyToSwapChain(

      layers::TextureType aTextureType, layers::RemoteTextureId aId,

      layers::RemoteTextureOwnerId aOwnerId,

      layers::RemoteTextureOwnerClient* aOwnerClient = nullptr);

  void OnMemoryPressure() { mSharedContext->OnMemoryPressure(); }

  operator std::string() const {

    std::stringstream stream;

    stream << "DrawTargetWebgl(" << this << ")";

    return stream.str();

  mozilla::ipc::SharedMemoryBasic::Handle TakeShmemHandle() const {

    return mShmem ? mShmem->TakeHandle()

                  : mozilla::ipc::SharedMemoryBasic::NULLHandle();

  uint32_t GetShmemSize() const { return mShmemSize; }

 private:

  bool SupportsPattern(const Pattern& aPattern) {

    return mSharedContext->SupportsPattern(aPattern);

  bool SetSimpleClipRect();

  bool GenerateComplexClipMask();

  bool PrepareContext(bool aClipped = true);

  void DrawRectFallback(const Rect& aRect, const Pattern& aPattern,

                        const DrawOptions& aOptions,

                        Maybe<DeviceColor> aMaskColor = Nothing(),

                        bool aTransform = true, bool aClipped = true,

                        const StrokeOptions* aStrokeOptions = nullptr);

  bool DrawRect(const Rect& aRect, const Pattern& aPattern,

                const DrawOptions& aOptions,

                Maybe<DeviceColor> aMaskColor = Nothing(),

                RefPtr<TextureHandle>* aHandle = nullptr,

                bool aTransformed = true, bool aClipped = true,

                bool aAccelOnly = false, bool aForceUpdate = false,

                const StrokeOptions* aStrokeOptions = nullptr);

  ColorPattern GetClearPattern() const;

  bool RectContainsViewport(const Rect& aRect) const;

  bool ShouldAccelPath(const DrawOptions& aOptions,

                       const StrokeOptions* aStrokeOptions);

  void DrawPath(const Path* aPath, const Pattern& aPattern,

                const DrawOptions& aOptions,

                const StrokeOptions* aStrokeOptions = nullptr,

                bool aAllowStrokeAlpha = false);

  void DrawCircle(const Point& aOrigin, float aRadius, const Pattern& aPattern,

                  const DrawOptions& aOptions,

                  const StrokeOptions* aStrokeOptions = nullptr);

  bool MarkChanged();

  bool ReadIntoSkia();

  void FlattenSkia();

  bool PrepareSkia();

  bool FlushFromSkia();

  void MarkSkiaChanged(bool aOverwrite = false);

  void MarkSkiaChanged(const DrawOptions& aOptions);

  bool ShouldUseSubpixelAA(ScaledFont* aFont, const DrawOptions& aOptions);

  bool ReadInto(uint8_t* aDstData, int32_t aDstStride);

  already_AddRefed<DataSourceSurface> ReadSnapshot();

  already_AddRefed<TextureHandle> CopySnapshot(const IntRect& aRect);

  already_AddRefed<TextureHandle> CopySnapshot() {

    return CopySnapshot(GetRect());

  void ClearSnapshot(bool aCopyOnWrite = true, bool aNeedHandle = false);

  bool CreateFramebuffer();

  // PrepareContext may sometimes be used recursively. When this occurs, ensure

  // that clip state is restored after the context is used.

  struct AutoRestoreContext {

    DrawTargetWebgl* mTarget;

    Rect mClipAARect;

    RefPtr<WebGLTexture> mLastClipMask;

    explicit AutoRestoreContext(DrawTargetWebgl* aTarget);

    ~AutoRestoreContext();

};

};

}  // namespace gfx

}  // namespace mozilla

#endif  // _MOZILLA_GFX_DRAWTARGETWEBGL_H