size_t SharedBuffer::getSomeDataInternal(const char*& someData,
size_t position) const {
size_t totalSize = size();
if (position >= totalSize) {
someData = 0;
return 0;
}
SECURITY_DCHECK(position < m_size);
size_t consecutiveSize = m_buffer.size();
if (position < consecutiveSize) {
someData = m_buffer.data() + position;
return consecutiveSize - position;
}
position -= consecutiveSize;
size_t segments = m_segments.size();
size_t maxSegmentedSize = segments * kSegmentSize;
size_t segment = segmentIndex(position);
if (segment < segments) {
size_t bytesLeft = totalSize - consecutiveSize;
size_t segmentedSize = std::min(maxSegmentedSize, bytesLeft);
size_t positionInSegment = offsetInSegment(position);
someData = m_segments[segment] + positionInSegment;
return segment == segments - 1 ? segmentedSize - position
: kSegmentSize - positionInSegment;
}
ASSERT_NOT_REACHED();
return 0;
}
unsigned SharedBuffer::getSomeData(const char*& someData, unsigned position) const
{
if (hasPlatformData() || m_purgeableBuffer) {
someData = data() + position;
return size() - position;
}
if (position >= m_size) {
someData = 0;
return 0;
}
unsigned consecutiveSize = m_buffer.size();
if (position < consecutiveSize) {
someData = m_buffer.data() + position;
return consecutiveSize - position;
}
position -= consecutiveSize;
unsigned segmentedSize = m_size - consecutiveSize;
unsigned segments = m_segments.size();
unsigned segment = segmentIndex(position);
ASSERT(segment < segments);
unsigned positionInSegment = offsetInSegment(position);
someData = m_segments[segment] + positionInSegment;
return segment == segments - 1 ? segmentedSize - position : segmentSize - positionInSegment;
}
void SharedBuffer::append(const char* data, unsigned length)
{
ASSERT(!m_purgeableBuffer);
if (!length)
return;
#if ENABLE(MEMORY_OUT_HANDLING)
if (WTF::MemoryOutManager::AbortReached())
return;
#endif
maybeTransferPlatformData();
unsigned positionInSegment = offsetInSegment(m_size - m_buffer.size());
m_size += length;
if (m_size <= segmentSize) {
// No need to use segments for small resource data
if (m_buffer.isEmpty())
m_buffer.reserveInitialCapacity(length);
m_buffer.append(data, length);
return;
}
char* segment;
if (!positionInSegment) {
segment = allocateSegment();
#if ENABLE(MEMORY_OUT_HANDLING)
if (!segment)
return;
#endif
m_segments.append(segment);
} else
segment = m_segments.last() + positionInSegment;
unsigned segmentFreeSpace = segmentSize - positionInSegment;
unsigned bytesToCopy = min(length, segmentFreeSpace);
for (;;) {
memcpy(segment, data, bytesToCopy);
if (static_cast<unsigned>(length) == bytesToCopy)
break;
length -= bytesToCopy;
data += bytesToCopy;
segment = allocateSegment();
#if ENABLE(MEMORY_OUT_HANDLING)
if (!segment)
return;
#endif
m_segments.append(segment);
bytesToCopy = min(length, segmentSize);
}
}
void SharedBuffer::append(const char* data, unsigned length)
{
ASSERT(!m_purgeableBuffer);
#if ENABLE(DISK_IMAGE_CACHE)
ASSERT(!isMemoryMapped());
#endif
if (!length)
return;
maybeTransferPlatformData();
#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
unsigned positionInSegment = offsetInSegment(m_size - m_buffer->data.size());
m_size += length;
if (m_size <= segmentSize) {
// No need to use segments for small resource data
if (m_buffer->data.isEmpty())
m_buffer->data.reserveInitialCapacity(length);
appendToDataBuffer(data, length);
return;
}
char* segment;
if (!positionInSegment) {
segment = allocateSegment();
m_segments.append(segment);
} else
segment = m_segments.last() + positionInSegment;
unsigned segmentFreeSpace = segmentSize - positionInSegment;
unsigned bytesToCopy = std::min(length, segmentFreeSpace);
for (;;) {
memcpy(segment, data, bytesToCopy);
if (static_cast<unsigned>(length) == bytesToCopy)
break;
length -= bytesToCopy;
data += bytesToCopy;
segment = allocateSegment();
m_segments.append(segment);
bytesToCopy = std::min(length, segmentSize);
}
#else
m_size += length;
if (m_buffer->data.isEmpty())
m_buffer->data.reserveInitialCapacity(length);
appendToDataBuffer(data, length);
#endif
}
unsigned SharedBuffer::getSomeData(const char*& someData, unsigned position) const
{
unsigned totalSize = size();
if (position >= totalSize) {
someData = 0;
return 0;
}
#if ENABLE(DISK_IMAGE_CACHE)
ASSERT(position < size());
if (isMemoryMapped()) {
const char* data = static_cast<const char*>(diskImageCache().dataForItem(m_diskImageCacheId));
someData = data + position;
return size() - position;
}
#endif
if (hasPlatformData() || m_purgeableBuffer) {
ASSERT_WITH_SECURITY_IMPLICATION(position < size());
someData = data() + position;
return totalSize - position;
}
ASSERT_WITH_SECURITY_IMPLICATION(position < m_size);
unsigned consecutiveSize = m_buffer->data.size();
if (position < consecutiveSize) {
someData = m_buffer->data.data() + position;
return consecutiveSize - position;
}
position -= consecutiveSize;
#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
unsigned segments = m_segments.size();
unsigned maxSegmentedSize = segments * segmentSize;
unsigned segment = segmentIndex(position);
if (segment < segments) {
unsigned bytesLeft = totalSize - consecutiveSize;
unsigned segmentedSize = std::min(maxSegmentedSize, bytesLeft);
unsigned positionInSegment = offsetInSegment(position);
someData = m_segments[segment] + positionInSegment;
return segment == segments - 1 ? segmentedSize - position : segmentSize - positionInSegment;
}
ASSERT_NOT_REACHED();
return 0;
#else
return copySomeDataFromDataArray(someData, position);
#endif
}
unsigned SharedBuffer::getSomeData(const char*& someData, unsigned position) const
{
unsigned totalSize = size();
if (position >= totalSize) {
someData = 0;
return 0;
}
if (hasPlatformData() || m_purgeableBuffer) {
ASSERT(position < size());
someData = data() + position;
return totalSize - position;
}
ASSERT(position < m_size);
unsigned consecutiveSize = m_buffer.size();
if (position < consecutiveSize) {
someData = m_buffer.data() + position;
return consecutiveSize - position;
}
position -= consecutiveSize;
unsigned segments = m_segments.size();
unsigned maxSegmentedSize = segments * segmentSize;
unsigned segment = segmentIndex(position);
if (segment < segments) {
unsigned bytesLeft = totalSize - consecutiveSize;
unsigned segmentedSize = min(maxSegmentedSize, bytesLeft);
unsigned positionInSegment = offsetInSegment(position);
someData = m_segments[segment] + positionInSegment;
return segment == segments - 1 ? segmentedSize - position : segmentSize - positionInSegment;
}
#if HAVE(NETWORK_CFDATA_ARRAY_CALLBACK)
ASSERT(maxSegmentedSize <= position);
position -= maxSegmentedSize;
return copySomeDataFromDataArray(someData, position);
#else
ASSERT_NOT_REACHED();
return 0;
#endif
}
unsigned SharedBuffer::getSomeData(const char*& someData, unsigned position) const
{
unsigned totalSize = size();
if (position >= totalSize) {
someData = 0;
return 0;
}
if (hasPlatformData()) {
ASSERT_WITH_SECURITY_IMPLICATION(position < size());
someData = data() + position;
return totalSize - position;
}
ASSERT_WITH_SECURITY_IMPLICATION(position < m_size);
unsigned consecutiveSize = m_buffer->data.size();
if (position < consecutiveSize) {
someData = m_buffer->data.data() + position;
return consecutiveSize - position;
}
position -= consecutiveSize;
#if !USE(NETWORK_CFDATA_ARRAY_CALLBACK)
unsigned segments = m_segments.size();
unsigned maxSegmentedSize = segments * segmentSize;
unsigned segment = segmentIndex(position);
if (segment < segments) {
unsigned bytesLeft = totalSize - consecutiveSize;
unsigned segmentedSize = std::min(maxSegmentedSize, bytesLeft);
unsigned positionInSegment = offsetInSegment(position);
someData = m_segments[segment] + positionInSegment;
return segment == segments - 1 ? segmentedSize - position : segmentSize - positionInSegment;
}
ASSERT_NOT_REACHED();
return 0;
#else
return copySomeDataFromDataArray(someData, position);
#endif
}
void SharedBuffer::append(const char* data, unsigned length)
{
ASSERT(!m_purgeableBuffer);
if (!length)
return;
maybeTransferPlatformData();
unsigned positionInSegment = offsetInSegment(m_size - m_buffer.size());
m_size += length;
if (m_size <= segmentSize) {
// No need to use segments for small resource data
m_buffer.append(data, length);
return;
}
char* segment;
if (!positionInSegment) {
segment = allocateSegment();
m_segments.append(segment);
} else
segment = m_segments.last() + positionInSegment;
unsigned segmentFreeSpace = segmentSize - positionInSegment;
unsigned bytesToCopy = min(length, segmentFreeSpace);
for (;;) {
memcpy(segment, data, bytesToCopy);
if (static_cast<unsigned>(length) == bytesToCopy)
break;
length -= bytesToCopy;
data += bytesToCopy;
segment = allocateSegment();
m_segments.append(segment);
bytesToCopy = min(length, segmentSize);
}
}
void SharedBuffer::appendInternal(const char* data, size_t length) {
if (!length)
return;
ASSERT(m_size >= m_buffer.size());
size_t positionInSegment = offsetInSegment(m_size - m_buffer.size());
m_size += length;
if (m_size <= kSegmentSize) {
// No need to use segments for small resource data.
m_buffer.append(data, length);
return;
}
char* segment;
if (!positionInSegment) {
segment = allocateSegment();
m_segments.append(segment);
} else
segment = m_segments.back() + positionInSegment;
size_t segmentFreeSpace = kSegmentSize - positionInSegment;
size_t bytesToCopy = std::min(length, segmentFreeSpace);
for (;;) {
memcpy(segment, data, bytesToCopy);
if (length == bytesToCopy)
break;
length -= bytesToCopy;
data += bytesToCopy;
segment = allocateSegment();
m_segments.append(segment);
bytesToCopy = std::min(length, static_cast<size_t>(kSegmentSize));
}
}
