From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- gfx/layers/PersistentBufferProvider.h | 187 ++++++++++++++++++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 gfx/layers/PersistentBufferProvider.h (limited to 'gfx/layers/PersistentBufferProvider.h') diff --git a/gfx/layers/PersistentBufferProvider.h b/gfx/layers/PersistentBufferProvider.h new file mode 100644 index 000000000..1a1355ca9 --- /dev/null +++ b/gfx/layers/PersistentBufferProvider.h @@ -0,0 +1,187 @@ +/* -*- 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 MOZILLA_GFX_PersistentBUFFERPROVIDER_H +#define MOZILLA_GFX_PersistentBUFFERPROVIDER_H + +#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc +#include "mozilla/RefPtr.h" // for RefPtr, already_AddRefed, etc +#include "mozilla/layers/LayersTypes.h" +#include "mozilla/layers/ShadowLayers.h" +#include "mozilla/gfx/Types.h" +#include "mozilla/Vector.h" + +namespace mozilla { + +namespace gfx { + class SourceSurface; + class DrawTarget; +} + +namespace layers { + +class CopyableCanvasLayer; + +/** + * A PersistentBufferProvider is for users which require the temporary use of + * a DrawTarget to draw into. When they're done drawing they return the + * DrawTarget, when they later need to continue drawing they get a DrawTarget + * from the provider again, the provider will guarantee the contents of the + * previously returned DrawTarget is persisted into the one newly returned. + */ +class PersistentBufferProvider : public RefCounted +{ +public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PersistentBufferProvider) + + virtual ~PersistentBufferProvider() { } + + virtual LayersBackend GetType() { return LayersBackend::LAYERS_NONE; } + + /** + * Get a DrawTarget from the PersistentBufferProvider. + * + * \param aPersistedRect This indicates the area of the DrawTarget that needs + * to have remained the same since the call to + * ReturnDrawTarget. + */ + virtual already_AddRefed BorrowDrawTarget(const gfx::IntRect& aPersistedRect) = 0; + + /** + * Return a DrawTarget to the PersistentBufferProvider and indicate the + * contents of this DrawTarget is to be considered current by the + * BufferProvider. The caller should forget any references to the DrawTarget. + */ + virtual bool ReturnDrawTarget(already_AddRefed aDT) = 0; + + virtual already_AddRefed BorrowSnapshot() = 0; + + virtual void ReturnSnapshot(already_AddRefed aSnapshot) = 0; + + virtual TextureClient* GetTextureClient() { return nullptr; } + + virtual void OnShutdown() {} + + virtual bool SetForwarder(ShadowLayerForwarder* aFwd) { return true; } + + /** + * Return true if this provider preserves the drawing state (clips, transforms, + * etc.) across frames. In practice this means users of the provider can skip + * popping all of the clips at the end of the frames and pushing them back at + * the beginning of the following frames, which can be costly (cf. bug 1294351). + */ + virtual bool PreservesDrawingState() const = 0; +}; + + +class PersistentBufferProviderBasic : public PersistentBufferProvider +{ +public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PersistentBufferProviderBasic, override) + + static already_AddRefed + Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, gfx::BackendType aBackend); + + explicit PersistentBufferProviderBasic(gfx::DrawTarget* aTarget); + + virtual LayersBackend GetType() override { return LayersBackend::LAYERS_BASIC; } + + virtual already_AddRefed BorrowDrawTarget(const gfx::IntRect& aPersistedRect) override; + + virtual bool ReturnDrawTarget(already_AddRefed aDT) override; + + virtual already_AddRefed BorrowSnapshot() override; + + virtual void ReturnSnapshot(already_AddRefed aSnapshot) override; + + virtual bool PreservesDrawingState() const override { return true; } +private: + ~PersistentBufferProviderBasic(); + + RefPtr mDrawTarget; + RefPtr mSnapshot; +}; + + +/** + * Provides access to a buffer which can be sent to the compositor without + * requiring a copy. + */ +class PersistentBufferProviderShared : public PersistentBufferProvider + , public ActiveResource +{ +public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PersistentBufferProviderShared, override) + + static already_AddRefed + Create(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + ShadowLayerForwarder* aFwd); + + virtual LayersBackend GetType() override { return LayersBackend::LAYERS_CLIENT; } + + virtual already_AddRefed BorrowDrawTarget(const gfx::IntRect& aPersistedRect) override; + + virtual bool ReturnDrawTarget(already_AddRefed aDT) override; + + virtual already_AddRefed BorrowSnapshot() override; + + virtual void ReturnSnapshot(already_AddRefed aSnapshot) override; + + virtual TextureClient* GetTextureClient() override; + + virtual void NotifyInactive() override; + + virtual void OnShutdown() override { Destroy(); } + + virtual bool SetForwarder(ShadowLayerForwarder* aFwd) override; + + virtual bool PreservesDrawingState() const override { return false; } +protected: + PersistentBufferProviderShared(gfx::IntSize aSize, gfx::SurfaceFormat aFormat, + ShadowLayerForwarder* aFwd, + RefPtr& aTexture); + + ~PersistentBufferProviderShared(); + + TextureClient* GetTexture(Maybe aIndex); + bool CheckIndex(uint32_t aIndex) { return aIndex < mTextures.length(); } + + void Destroy(); + + gfx::IntSize mSize; + gfx::SurfaceFormat mFormat; + RefPtr mFwd; + Vector, 4> mTextures; + // Offset of the texture in mTextures that the canvas uses. + Maybe mBack; + // Offset of the texture in mTextures that is presented to the compositor. + Maybe mFront; + + RefPtr mDrawTarget; + RefPtr mSnapshot; +}; + +struct AutoReturnSnapshot +{ + PersistentBufferProvider* mBufferProvider; + RefPtr* mSnapshot; + + explicit AutoReturnSnapshot(PersistentBufferProvider* aProvider = nullptr) + : mBufferProvider(aProvider) + , mSnapshot(nullptr) + {} + + ~AutoReturnSnapshot() + { + if (mBufferProvider) { + mBufferProvider->ReturnSnapshot(mSnapshot ? mSnapshot->forget() : nullptr); + } + } +}; + +} // namespace layers +} // namespace mozilla + +#endif -- cgit v1.2.3