ShareableBitmap.cpp [plain text]
#include "config.h"
#include "ShareableBitmap.h"
#include "SharedMemory.h"
#include "WebCoreArgumentCoders.h"
#include <WebCore/GraphicsContext.h>
using namespace WebCore;
namespace WebKit {
static unsigned calculateBytesPerPixel(ShareableBitmap::Flags flags)
{
if (flags & ShareableBitmap::SupportsExtendedColor)
return 8; return 4;
}
ShareableBitmap::Handle::Handle()
: m_flags(0)
{
}
void ShareableBitmap::Handle::encode(IPC::Encoder& encoder) const
{
encoder << m_handle;
encoder << m_size;
encoder << m_flags;
}
bool ShareableBitmap::Handle::decode(IPC::Decoder& decoder, Handle& handle)
{
if (!decoder.decode(handle.m_handle))
return false;
if (!decoder.decode(handle.m_size))
return false;
if (!decoder.decode(handle.m_flags))
return false;
handle.m_bytesPerPixel = calculateBytesPerPixel(handle.m_flags);
return true;
}
void ShareableBitmap::Handle::clear()
{
m_handle.clear();
m_size = IntSize();
m_flags = Flag::NoFlags;
m_bytesPerPixel = calculateBytesPerPixel(m_flags);
}
RefPtr<ShareableBitmap> ShareableBitmap::create(const IntSize& size, Flags flags)
{
unsigned bytesPerPixel = calculateBytesPerPixel(flags);
auto numBytes = numBytesForSize(size, bytesPerPixel);
if (numBytes.hasOverflowed())
return nullptr;
void* data = 0;
if (!tryFastMalloc(numBytes.unsafeGet()).getValue(data))
return nullptr;
return adoptRef(new ShareableBitmap(size, flags, data));
}
RefPtr<ShareableBitmap> ShareableBitmap::createShareable(const IntSize& size, Flags flags)
{
unsigned bytesPerPixel = calculateBytesPerPixel(flags);
auto numBytes = numBytesForSize(size, bytesPerPixel);
if (numBytes.hasOverflowed())
return nullptr;
RefPtr<SharedMemory> sharedMemory = SharedMemory::allocate(numBytes.unsafeGet());
if (!sharedMemory)
return nullptr;
return adoptRef(new ShareableBitmap(size, flags, sharedMemory));
}
RefPtr<ShareableBitmap> ShareableBitmap::create(const IntSize& size, Flags flags, RefPtr<SharedMemory> sharedMemory)
{
ASSERT(sharedMemory);
unsigned bytesPerPixel = calculateBytesPerPixel(flags);
auto numBytes = numBytesForSize(size, bytesPerPixel);
if (numBytes.hasOverflowed())
return nullptr;
if (sharedMemory->size() < numBytes.unsafeGet()) {
ASSERT_NOT_REACHED();
return nullptr;
}
return adoptRef(new ShareableBitmap(size, flags, sharedMemory));
}
RefPtr<ShareableBitmap> ShareableBitmap::create(const Handle& handle, SharedMemory::Protection protection)
{
auto sharedMemory = SharedMemory::map(handle.m_handle, protection);
if (!sharedMemory)
return nullptr;
return create(handle.m_size, handle.m_flags, WTFMove(sharedMemory));
}
bool ShareableBitmap::createHandle(Handle& handle, SharedMemory::Protection protection)
{
ASSERT(isBackedBySharedMemory());
if (!m_sharedMemory->createHandle(handle.m_handle, protection))
return false;
handle.m_size = m_size;
handle.m_flags = m_flags;
handle.m_bytesPerPixel = m_bytesPerPixel;
return true;
}
ShareableBitmap::ShareableBitmap(const IntSize& size, Flags flags, void* data)
: m_size(size)
, m_flags(flags)
, m_data(data)
{
m_bytesPerPixel = calculateBytesPerPixel(flags);
}
ShareableBitmap::ShareableBitmap(const IntSize& size, Flags flags, RefPtr<SharedMemory> sharedMemory)
: m_size(size)
, m_flags(flags)
, m_sharedMemory(sharedMemory)
, m_data(0)
{
m_bytesPerPixel = calculateBytesPerPixel(flags);
}
ShareableBitmap::~ShareableBitmap()
{
if (!isBackedBySharedMemory())
fastFree(m_data);
}
void* ShareableBitmap::data() const
{
if (isBackedBySharedMemory())
return m_sharedMemory->data();
ASSERT(m_data);
return m_data;
}
}