| /* |
| * Copyright (C) 2021 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "DisplayListIterator.h" |
| |
| namespace WebCore { |
| namespace DisplayList { |
| |
| bool DisplayList::Iterator::atEnd() const |
| { |
| if (m_displayList.isEmpty() || !m_isValid) |
| return true; |
| |
| auto& items = *itemBuffer(); |
| auto endCursor = items.m_writableBuffer.data + items.m_writtenNumberOfBytes; |
| return m_cursor == endCursor; |
| } |
| |
| auto DisplayList::Iterator::updateCurrentDrawingItemExtent(ItemType itemType) -> ExtentUpdateResult |
| { |
| auto& extents = m_displayList.m_drawingItemExtents; |
| if (extents.isEmpty()) |
| return ExtentUpdateResult::Success; |
| |
| if (!isDrawingItem(itemType)) { |
| m_currentExtent = std::nullopt; |
| return ExtentUpdateResult::Success; |
| } |
| |
| if (m_drawingItemIndex >= extents.size()) |
| return ExtentUpdateResult::Failure; |
| |
| m_currentExtent = extents[m_drawingItemIndex]; |
| m_drawingItemIndex++; |
| return ExtentUpdateResult::Success; |
| } |
| |
| void DisplayList::Iterator::updateCurrentItem() |
| { |
| clearCurrentItem(); |
| |
| if (atEnd()) |
| return; |
| |
| auto& items = *itemBuffer(); |
| auto rawItemTypeValue = m_cursor[0]; |
| if (UNLIKELY(!isValidEnum<ItemType>(rawItemTypeValue))) { |
| m_isValid = false; |
| return; |
| } |
| |
| auto itemType = static_cast<ItemType>(rawItemTypeValue); |
| if (UNLIKELY(updateCurrentDrawingItemExtent(itemType) == ExtentUpdateResult::Failure)) { |
| m_isValid = false; |
| return; |
| } |
| |
| auto remainingCapacityInBuffer = static_cast<uint64_t>(m_currentEndOfBuffer - m_cursor); |
| auto paddedSizeOfTypeAndItem = paddedSizeOfTypeAndItemInBytes(itemType); |
| m_currentBufferForItem = paddedSizeOfTypeAndItem <= sizeOfFixedBufferForCurrentItem ? m_fixedBufferForCurrentItem : static_cast<uint8_t*>(fastMalloc(paddedSizeOfTypeAndItem)); |
| if (isInlineItem(itemType)) { |
| if (UNLIKELY(remainingCapacityInBuffer < paddedSizeOfTypeAndItem)) { |
| m_isValid = false; |
| return; |
| } |
| |
| if (UNLIKELY(!ItemHandle { m_cursor }.safeCopy(itemType, { m_currentBufferForItem }))) { |
| m_isValid = false; |
| return; |
| } |
| |
| m_currentItemSizeInBuffer = paddedSizeOfTypeAndItem; |
| } else { |
| auto* client = items.m_readingClient; |
| RELEASE_ASSERT(client); |
| constexpr auto sizeOfTypeAndDataLength = 2 * sizeof(uint64_t); |
| |
| if (UNLIKELY(remainingCapacityInBuffer < sizeOfTypeAndDataLength)) { |
| m_isValid = false; |
| return; |
| } |
| |
| auto dataLength = reinterpret_cast<uint64_t*>(m_cursor)[1]; |
| if (UNLIKELY(dataLength >= std::numeric_limits<uint32_t>::max() - alignof(uint64_t) - sizeOfTypeAndDataLength)) { |
| m_isValid = false; |
| return; |
| } |
| |
| auto itemSizeInBuffer = roundUpToMultipleOf<alignof(uint64_t)>(dataLength) + sizeOfTypeAndDataLength; |
| if (UNLIKELY(remainingCapacityInBuffer < itemSizeInBuffer)) { |
| m_isValid = false; |
| return; |
| } |
| |
| auto* startOfData = m_cursor + sizeOfTypeAndDataLength; |
| auto decodedItemHandle = client->decodeItem(startOfData, dataLength, itemType, m_currentBufferForItem); |
| if (UNLIKELY(!decodedItemHandle)) { |
| m_isValid = false; |
| return; |
| } |
| |
| m_currentBufferForItem[0] = static_cast<uint8_t>(itemType); |
| m_currentItemSizeInBuffer = itemSizeInBuffer; |
| } |
| } |
| |
| void DisplayList::Iterator::advance() |
| { |
| if (atEnd()) |
| return; |
| |
| m_cursor += m_currentItemSizeInBuffer; |
| |
| if (m_cursor == m_currentEndOfBuffer && m_readOnlyBufferIndex < itemBuffer()->m_readOnlyBuffers.size()) { |
| m_readOnlyBufferIndex++; |
| moveCursorToStartOfCurrentBuffer(); |
| } |
| |
| updateCurrentItem(); |
| } |
| |
| void DisplayList::Iterator::clearCurrentItem() |
| { |
| auto items = itemBuffer(); |
| if (items && items->m_readingClient && m_currentBufferForItem) { |
| if (LIKELY(m_isValid)) |
| ItemHandle { m_currentBufferForItem }.destroy(); |
| |
| if (UNLIKELY(m_currentBufferForItem != m_fixedBufferForCurrentItem)) |
| fastFree(m_currentBufferForItem); |
| } |
| |
| m_currentItemSizeInBuffer = 0; |
| m_currentBufferForItem = nullptr; |
| } |
| |
| void DisplayList::Iterator::moveToEnd() |
| { |
| if (auto items = itemBuffer()) { |
| m_cursor = items->m_writableBuffer.data + items->m_writtenNumberOfBytes; |
| m_currentEndOfBuffer = m_cursor; |
| m_readOnlyBufferIndex = items->m_readOnlyBuffers.size(); |
| } |
| } |
| |
| void DisplayList::Iterator::moveCursorToStartOfCurrentBuffer() |
| { |
| auto items = itemBuffer(); |
| if (!items) |
| return; |
| |
| auto numberOfReadOnlyBuffers = items->m_readOnlyBuffers.size(); |
| if (m_readOnlyBufferIndex < numberOfReadOnlyBuffers) { |
| auto& nextBufferHandle = items->m_readOnlyBuffers[m_readOnlyBufferIndex]; |
| m_cursor = nextBufferHandle.data; |
| m_currentEndOfBuffer = m_cursor + nextBufferHandle.capacity; |
| } else if (m_readOnlyBufferIndex == numberOfReadOnlyBuffers) { |
| m_cursor = items->m_writableBuffer.data; |
| m_currentEndOfBuffer = m_cursor + items->m_writtenNumberOfBytes; |
| } |
| } |
| |
| } |
| } |