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)); } }