The Tor Browser: comparison gfx/thebes/gfxBaseSharedMemorySurface.h

--1:000000000000
+:a1971bd53354
+// vim:set ts=4 sts=4 sw=4 et cin:
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* 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_SHARED_MEMORYSURFACE_H
+#define GFX_SHARED_MEMORYSURFACE_H
+#include "mozilla/ipc/Shmem.h"
+#include "mozilla/ipc/SharedMemory.h"
+#include "gfxASurface.h"
+#include "gfxImageSurface.h"
+#include "pratom.h"
+typedef struct _cairo_user_data_key cairo_user_data_key_t;
+struct SharedImageInfo {
+int32_t width;
+int32_t height;
+gfxImageFormat format;
+int32_t readCount;
+};
+inline SharedImageInfo*
+GetShmInfoPtr(const mozilla::ipc::Shmem& aShmem)
+{
+return reinterpret_cast<SharedImageInfo*>
+(aShmem.get<char>() + aShmem.Size<char>() - sizeof(SharedImageInfo));
+}
+extern const cairo_user_data_key_t SHM_KEY;
+template <typename Base, typename Sub>
+class gfxBaseSharedMemorySurface : public Base {
+typedef mozilla::ipc::SharedMemory SharedMemory;
+typedef mozilla::ipc::Shmem Shmem;
+friend class gfxReusableSharedImageSurfaceWrapper;
+public:
+virtual ~gfxBaseSharedMemorySurface()
+{
+MOZ_COUNT_DTOR(gfxBaseSharedMemorySurface);
+}
+/**
+* Return a new gfxSharedImageSurface around a shmem segment newly
+* allocated by this function.  |aAllocator| is the object used to
+* allocate the new shmem segment.  Null is returned if creating
+* the surface failed.
+*
+* NB: the *caller* is responsible for freeing the Shmem allocated
+* by this function.
+*/
+template<class ShmemAllocator>
+static already_AddRefed<Sub>
+Create(ShmemAllocator* aAllocator,
+const gfxIntSize& aSize,
+gfxImageFormat aFormat,
+SharedMemory::SharedMemoryType aShmType = SharedMemory::TYPE_BASIC)
+{
+return Create<ShmemAllocator, false>(aAllocator, aSize, aFormat, aShmType);
+}
+/**
+* Return a new gfxSharedImageSurface that wraps a shmem segment
+* already created by the Create() above.  Bad things will happen
+* if an attempt is made to wrap any other shmem segment.  Null is
+* returned if creating the surface failed.
+*/
+static already_AddRefed<Sub>
+Open(const Shmem& aShmem)
+{
+SharedImageInfo* shmInfo = GetShmInfoPtr(aShmem);
+gfxIntSize size(shmInfo->width, shmInfo->height);
+if (!gfxASurface::CheckSurfaceSize(size))
+return nullptr;
+gfxImageFormat format = (gfxImageFormat)shmInfo->format;
+long stride = gfxImageSurface::ComputeStride(size, format);
+nsRefPtr<Sub> s =
+new Sub(size,
+stride,
+format,
+aShmem);
+// We didn't create this Shmem and so don't free it on errors
+return (s->CairoStatus() != 0) ? nullptr : s.forget();
+}
+template<class ShmemAllocator>
+static already_AddRefed<Sub>
+CreateUnsafe(ShmemAllocator* aAllocator,
+const gfxIntSize& aSize,
+gfxImageFormat aFormat,
+SharedMemory::SharedMemoryType aShmType = SharedMemory::TYPE_BASIC)
+{
+return Create<ShmemAllocator, true>(aAllocator, aSize, aFormat, aShmType);
+}
+Shmem& GetShmem() { return mShmem; }
+static bool IsSharedImage(gfxASurface *aSurface)
+{
+return (aSurface
+&& aSurface->GetType() == gfxSurfaceType::Image
+&& aSurface->GetData(&SHM_KEY));
+}
+protected:
+gfxBaseSharedMemorySurface(const gfxIntSize& aSize, long aStride,
+gfxImageFormat aFormat,
+const Shmem& aShmem)
+: Base(aShmem.get<unsigned char>(), aSize, aStride, aFormat)
+{
+MOZ_COUNT_CTOR(gfxBaseSharedMemorySurface);
+mShmem = aShmem;
+this->SetData(&SHM_KEY, this, nullptr);
+}
+private:
+void WriteShmemInfo()
+{
+SharedImageInfo* shmInfo = GetShmInfoPtr(mShmem);
+shmInfo->width = this->mSize.width;
+shmInfo->height = this->mSize.height;
+shmInfo->format = this->mFormat;
+shmInfo->readCount = 0;
+}
+int32_t
+ReadLock()
+{
+SharedImageInfo* shmInfo = GetShmInfoPtr(mShmem);
+return PR_ATOMIC_INCREMENT(&shmInfo->readCount);
+}
+int32_t
+ReadUnlock()
+{
+SharedImageInfo* shmInfo = GetShmInfoPtr(mShmem);
+return PR_ATOMIC_DECREMENT(&shmInfo->readCount);
+}
+int32_t
+GetReadCount()
+{
+SharedImageInfo* shmInfo = GetShmInfoPtr(mShmem);
+return shmInfo->readCount;
+}
+static size_t GetAlignedSize(const gfxIntSize& aSize, long aStride)
+{
+#define MOZ_ALIGN_WORD(x) (((x) + 3) & ~3)
+return MOZ_ALIGN_WORD(sizeof(SharedImageInfo) + aSize.height * aStride);
+}
+template<class ShmemAllocator, bool Unsafe>
+static already_AddRefed<Sub>
+Create(ShmemAllocator* aAllocator,
+const gfxIntSize& aSize,
+gfxImageFormat aFormat,
+SharedMemory::SharedMemoryType aShmType)
+{
+if (!gfxASurface::CheckSurfaceSize(aSize))
+return nullptr;
+Shmem shmem;
+long stride = gfxImageSurface::ComputeStride(aSize, aFormat);
+size_t size = GetAlignedSize(aSize, stride);
+if (!Unsafe) {
+if (!aAllocator->AllocShmem(size, aShmType, &shmem))
+return nullptr;
+} else {
+if (!aAllocator->AllocUnsafeShmem(size, aShmType, &shmem))
+return nullptr;
+}
+nsRefPtr<Sub> s =
+new Sub(aSize, stride, aFormat, shmem);
+if (s->CairoStatus() != 0) {
+aAllocator->DeallocShmem(shmem);
+return nullptr;
+}
+s->WriteShmemInfo();
+return s.forget();
+}
+Shmem mShmem;
+// Calling these is very bad, disallow it
+gfxBaseSharedMemorySurface(const gfxBaseSharedMemorySurface&);
+gfxBaseSharedMemorySurface& operator=(const gfxBaseSharedMemorySurface&);
+};
+#endif /* GFX_SHARED_MEMORYSURFACE_H */

The Tor Browser / file comparison

comparison: gfx/thebes/gfxBaseSharedMemorySurface.h

gfx/thebes/gfxBaseSharedMemorySurface.h