diff -r 000000000000 -r 6474c204b198 gfx/layers/client/CompositableClient.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/layers/client/CompositableClient.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,178 @@ +/* -*- 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_BUFFERCLIENT_H +#define MOZILLA_GFX_BUFFERCLIENT_H + +#include // for uint64_t +#include // for vector +#include // for map +#include "mozilla/Assertions.h" // for MOZ_CRASH +#include "mozilla/RefPtr.h" // for TemporaryRef, RefCounted +#include "mozilla/gfx/Types.h" // for SurfaceFormat +#include "mozilla/layers/CompositorTypes.h" +#include "mozilla/layers/LayersTypes.h" // for LayersBackend +#include "mozilla/layers/PCompositableChild.h" // for PCompositableChild +#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc + +namespace mozilla { +namespace layers { + +class CompositableClient; +class TextureClient; +class BufferTextureClient; +class ImageBridgeChild; +class CompositableForwarder; +class CompositableChild; +class SurfaceDescriptor; +class TextureClientData; + +/** + * CompositableClient manages the texture-specific logic for composite layers, + * independently of the layer. It is the content side of a CompositableClient/ + * CompositableHost pair. + * + * CompositableClient's purpose is to send texture data to the compositor side + * along with any extra information about how the texture is to be composited. + * Things like opacity or transformation belong to layer and not compositable. + * + * Since Compositables are independent of layers it is possible to create one, + * connect it to the compositor side, and start sending images to it. This alone + * is arguably not very useful, but it means that as long as a shadow layer can + * do the proper magic to find a reference to the right CompositableHost on the + * Compositor side, a Compositable client can be used outside of the main + * shadow layer forwarder machinery that is used on the main thread. + * + * The first step is to create a Compositable client and call Connect(). + * Connect() creates the underlying IPDL actor (see CompositableChild) and the + * corresponding CompositableHost on the other side. + * + * To do in-transaction texture transfer (the default), call + * ShadowLayerForwarder::Attach(CompositableClient*, ShadowableLayer*). This + * will let the LayerComposite on the compositor side know which CompositableHost + * to use for compositing. + * + * To do async texture transfer (like async-video), the CompositableClient + * should be created with a different CompositableForwarder (like + * ImageBridgeChild) and attachment is done with + * CompositableForwarder::AttachAsyncCompositable that takes an identifier + * instead of a CompositableChild, since the CompositableClient is not managed + * by this layer forwarder (the matching uses a global map on the compositor side, + * see CompositableMap in ImageBridgeParent.cpp) + * + * Subclasses: Thebes layers use ContentClients, ImageLayers use ImageClients, + * Canvas layers use CanvasClients (but ImageHosts). We have a different subclass + * where we have a different way of interfacing with the textures - in terms of + * drawing into the compositable and/or passing its contents to the compostior. + */ +class CompositableClient +{ +protected: + virtual ~CompositableClient(); + +public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CompositableClient) + + CompositableClient(CompositableForwarder* aForwarder, TextureFlags aFlags = 0); + + virtual TextureInfo GetTextureInfo() const = 0; + + LayersBackend GetCompositorBackendType() const; + + TemporaryRef + CreateBufferTextureClient(gfx::SurfaceFormat aFormat, + TextureFlags aFlags = TEXTURE_FLAGS_DEFAULT, + gfx::BackendType aMoz2dBackend = gfx::BackendType::NONE); + + TemporaryRef + CreateTextureClientForDrawing(gfx::SurfaceFormat aFormat, + TextureFlags aTextureFlags, + gfx::BackendType aMoz2dBackend, + const gfx::IntSize& aSizeHint); + + virtual void SetDescriptorFromReply(TextureIdentifier aTextureId, + const SurfaceDescriptor& aDescriptor) + { + MOZ_CRASH("If you want to call this, you should have implemented it"); + } + + /** + * Establishes the connection with compositor side through IPDL + */ + virtual bool Connect(); + + void Destroy(); + + PCompositableChild* GetIPDLActor() const; + + // should only be called by a CompositableForwarder + virtual void SetIPDLActor(CompositableChild* aChild); + + CompositableForwarder* GetForwarder() const + { + return mForwarder; + } + + /** + * This identifier is what lets us attach async compositables with a shadow + * layer. It is not used if the compositable is used with the regular shadow + * layer forwarder. + * + * If this returns zero, it means the compositable is not async (it is used + * on the main thread). + */ + uint64_t GetAsyncID() const; + + /** + * Tells the Compositor to create a TextureHost for this TextureClient. + */ + virtual bool AddTextureClient(TextureClient* aClient); + + /** + * A hook for the Compositable to execute whatever it held off for next transaction. + */ + virtual void OnTransaction(); + + /** + * A hook for the when the Compositable is detached from it's layer. + */ + virtual void OnDetach() {} + + /** + * Clear any resources that are not immediately necessary. This may be called + * in low-memory conditions. + */ + virtual void ClearCachedResources() {} + + static CompositableClient* FromIPDLActor(PCompositableChild* aActor); + + /** + * Allocate and deallocate a CompositableChild actor. + * + * CompositableChild is an implementation detail of CompositableClient that is not + * exposed to the rest of the code base. CreateIPDLActor and DestroyIPDLActor + * are for use with the managing IPDL protocols only (so that they can + * implement AllocCompositableChild and DeallocPCompositableChild). + */ + static PCompositableChild* CreateIPDLActor(); + + static bool DestroyIPDLActor(PCompositableChild* actor); + + void InitIPDLActor(PCompositableChild* aActor, uint64_t aAsyncID = 0); + +protected: + CompositableChild* mCompositableChild; + CompositableForwarder* mForwarder; + // Some layers may want to enforce some flags to all their textures + // (like disallowing tiling) + TextureFlags mTextureFlags; + + friend class CompositableChild; +}; + +} // namespace +} // namespace + +#endif