The Tor Browser: comparison gfx/layers/composite/TiledContentHost.h

--1:000000000000
+:12974f3ffc00
+/* -*- 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_TILEDCONTENTHOST_H
+#define GFX_TILEDCONTENTHOST_H
+#include <stdint.h>                     // for uint16_t
+#include <stdio.h>                      // for FILE
+#include <algorithm>                    // for swap
+#include "ContentHost.h"                // for ContentHost
+#include "TiledLayerBuffer.h"           // for TiledLayerBuffer, etc
+#include "CompositableHost.h"
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+#include "mozilla/Attributes.h"         // for MOZ_OVERRIDE
+#include "mozilla/RefPtr.h"             // for RefPtr
+#include "mozilla/gfx/Point.h"          // for Point
+#include "mozilla/gfx/Rect.h"           // for Rect
+#include "mozilla/gfx/Types.h"          // for Filter
+#include "mozilla/layers/CompositorTypes.h"  // for TextureInfo, etc
+#include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
+#include "mozilla/layers/LayersTypes.h"  // for LayerRenderState, etc
+#include "mozilla/layers/TextureHost.h"  // for TextureHost
+#include "mozilla/layers/TiledContentClient.h"
+#include "mozilla/mozalloc.h"           // for operator delete
+#include "nsRegion.h"                   // for nsIntRegion
+#include "nscore.h"                     // for nsACString
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
+#include <ui/Fence.h>
+#endif
+class gfxReusableSurfaceWrapper;
+struct nsIntPoint;
+struct nsIntRect;
+struct nsIntSize;
+namespace mozilla {
+namespace gfx {
+class Matrix4x4;
+}
+namespace layers {
+class Compositor;
+class ISurfaceAllocator;
+class Layer;
+class ThebesBufferData;
+struct EffectChain;
+class TileHost {
+public:
+// Constructs a placeholder TileHost. See the comments above
+// TiledLayerBuffer for more information on what this is used for;
+// essentially, this is a sentinel used to represent an invalid or blank
+// tile.
+TileHost()
+: mSharedLock(nullptr)
+, mTextureHost(nullptr)
+{}
+// Constructs a TileHost from a gfxSharedReadLock and TextureHost.
+TileHost(gfxSharedReadLock* aSharedLock,
+TextureHost* aTextureHost)
+: mSharedLock(aSharedLock)
+, mTextureHost(aTextureHost)
+{}
+TileHost(const TileHost& o) {
+mTextureHost = o.mTextureHost;
+mSharedLock = o.mSharedLock;
+}
+TileHost& operator=(const TileHost& o) {
+if (this == &o) {
+return *this;
+}
+mTextureHost = o.mTextureHost;
+mSharedLock = o.mSharedLock;
+return *this;
+}
+bool operator== (const TileHost& o) const {
+return mTextureHost == o.mTextureHost;
+}
+bool operator!= (const TileHost& o) const {
+return mTextureHost != o.mTextureHost;
+}
+bool IsPlaceholderTile() const { return mTextureHost == nullptr; }
+void ReadUnlock() {
+if (mSharedLock) {
+mSharedLock->ReadUnlock();
+}
+}
+RefPtr<gfxSharedReadLock> mSharedLock;
+RefPtr<TextureHost> mTextureHost;
+};
+class TiledLayerBufferComposite
+: public TiledLayerBuffer<TiledLayerBufferComposite, TileHost>
+{
+friend class TiledLayerBuffer<TiledLayerBufferComposite, TileHost>;
+public:
+typedef TiledLayerBuffer<TiledLayerBufferComposite, TileHost>::Iterator Iterator;
+TiledLayerBufferComposite();
+TiledLayerBufferComposite(ISurfaceAllocator* aAllocator,
+const SurfaceDescriptorTiles& aDescriptor,
+const nsIntRegion& aOldPaintedRegion);
+TileHost GetPlaceholderTile() const { return TileHost(); }
+// Stores the absolute resolution of the containing frame, calculated
+// by the sum of the resolutions of all parent layers' FrameMetrics.
+const CSSToParentLayerScale& GetFrameResolution() { return mFrameResolution; }
+void ReadUnlock();
+void ReleaseTextureHosts();
+/**
+* This will synchronously upload any necessary texture contents, making the
+* sources immediately available for compositing. For texture hosts that
+* don't have an internal buffer, this is unlikely to actually do anything.
+*/
+void Upload();
+void SetCompositor(Compositor* aCompositor);
+bool HasDoubleBufferedTiles() { return mHasDoubleBufferedTiles; }
+bool IsValid() const { return !mUninitialized; }
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
+virtual void SetReleaseFence(const android::sp<android::Fence>& aReleaseFence);
+#endif
+// Recycle callback for TextureHost.
+// Used when TiledContentClient is present in client side.
+static void RecycleCallback(TextureHost* textureHost, void* aClosure);
+protected:
+TileHost ValidateTile(TileHost aTile,
+const nsIntPoint& aTileRect,
+const nsIntRegion& dirtyRect);
+// do nothing, the desctructor in the texture host takes care of releasing resources
+void ReleaseTile(TileHost aTile) {}
+void SwapTiles(TileHost& aTileA, TileHost& aTileB) { std::swap(aTileA, aTileB); }
+private:
+CSSToParentLayerScale mFrameResolution;
+bool mHasDoubleBufferedTiles;
+bool mUninitialized;
+};
+/**
+* ContentHost for tiled Thebes layers. Since tiled layers are special snow
+* flakes, we have a unique update process. All the textures that back the
+* tiles are added in the usual way, but Updated is called on the host side
+* in response to a message that describes the transaction for every tile.
+* Composition happens in the normal way.
+*
+* TiledContentHost has a TiledLayerBufferComposite which keeps hold of the tiles.
+* Each tile has a reference to a texture host. During the layers transaction, we
+* receive a list of descriptors for the client-side tile buffer tiles
+* (UseTiledLayerBuffer). If we receive two transactions before a composition,
+* we immediately unlock and discard the unused buffer.
+*
+* When the content host is composited, we first validate the TiledLayerBuffer
+* (Upload), which calls Updated on each tile's texture host to make sure the
+* texture data has been uploaded. For single-buffered tiles, we unlock at this
+* point, for double-buffered tiles we unlock and discard the last composited
+* buffer after compositing a new one. Rendering takes us to RenderTile which
+* is similar to Composite for non-tiled ContentHosts.
+*/
+class TiledContentHost : public ContentHost,
+public TiledLayerComposer
+{
+public:
+TiledContentHost(const TextureInfo& aTextureInfo);
+~TiledContentHost();
+virtual LayerRenderState GetRenderState() MOZ_OVERRIDE
+{
+return LayerRenderState();
+}
+virtual bool UpdateThebes(const ThebesBufferData& aData,
+const nsIntRegion& aUpdated,
+const nsIntRegion& aOldValidRegionBack,
+nsIntRegion* aUpdatedRegionBack)
+{
+NS_ERROR("N/A for tiled layers");
+return false;
+}
+const nsIntRegion& GetValidLowPrecisionRegion() const
+{
+return mLowPrecisionTiledBuffer.GetValidRegion();
+}
+void UseTiledLayerBuffer(ISurfaceAllocator* aAllocator,
+const SurfaceDescriptorTiles& aTiledDescriptor);
+void Composite(EffectChain& aEffectChain,
+float aOpacity,
+const gfx::Matrix4x4& aTransform,
+const gfx::Filter& aFilter,
+const gfx::Rect& aClipRect,
+const nsIntRegion* aVisibleRegion = nullptr,
+TiledLayerProperties* aLayerProperties = nullptr);
+virtual CompositableType GetType() { return BUFFER_TILED; }
+virtual TiledLayerComposer* AsTiledLayerComposer() MOZ_OVERRIDE { return this; }
+virtual void Attach(Layer* aLayer,
+Compositor* aCompositor,
+AttachFlags aFlags = NO_FLAGS) MOZ_OVERRIDE;
+#ifdef MOZ_DUMP_PAINTING
+virtual void Dump(FILE* aFile=nullptr,
+const char* aPrefix="",
+bool aDumpHtml=false) MOZ_OVERRIDE;
+#endif
+virtual void PrintInfo(nsACString& aTo, const char* aPrefix);
+#if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
+/**
+* Store a fence that will signal when the current buffer is no longer being read.
+* Similar to android's GLConsumer::setReleaseFence()
+*/
+virtual void SetReleaseFence(const android::sp<android::Fence>& aReleaseFence)
+{
+mTiledBuffer.SetReleaseFence(aReleaseFence);
+mLowPrecisionTiledBuffer.SetReleaseFence(aReleaseFence);
+}
+#endif
+private:
+void RenderLayerBuffer(TiledLayerBufferComposite& aLayerBuffer,
+EffectChain& aEffectChain,
+float aOpacity,
+const gfx::Filter& aFilter,
+const gfx::Rect& aClipRect,
+nsIntRegion aMaskRegion,
+gfx::Matrix4x4 aTransform);
+// Renders a single given tile.
+void RenderTile(const TileHost& aTile,
+EffectChain& aEffectChain,
+float aOpacity,
+const gfx::Matrix4x4& aTransform,
+const gfx::Filter& aFilter,
+const gfx::Rect& aClipRect,
+const nsIntRegion& aScreenRegion,
+const nsIntPoint& aTextureOffset,
+const nsIntSize& aTextureBounds);
+void EnsureTileStore() {}
+TiledLayerBufferComposite    mTiledBuffer;
+TiledLayerBufferComposite    mLowPrecisionTiledBuffer;
+TiledLayerBufferComposite    mOldTiledBuffer;
+TiledLayerBufferComposite    mOldLowPrecisionTiledBuffer;
+bool                         mPendingUpload;
+bool                         mPendingLowPrecisionUpload;
+};
+}
+}
+#endif

The Tor Browser / file comparison

comparison: gfx/layers/composite/TiledContentHost.h

gfx/layers/composite/TiledContentHost.h