| /* |
| * Copyright (C) 2009, 2010, 2011, 2012 Research In Motion Limited. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include "config.h" |
| #include "RenderQueue.h" |
| |
| #include "BackingStore_p.h" |
| #include "SurfacePool.h" |
| #include "WebPageClient.h" |
| #include "WebPage_p.h" |
| |
| #include <wtf/NonCopyingSort.h> |
| |
| #define DEBUG_RENDER_QUEUE 0 |
| #define DEBUG_RENDER_QUEUE_SORT 0 |
| |
| #if DEBUG_RENDER_QUEUE |
| #include <BlackBerryPlatformLog.h> |
| #include <wtf/CurrentTime.h> |
| #endif |
| |
| namespace BlackBerry { |
| namespace WebKit { |
| |
| template<SortDirection sortDirection> |
| static inline int compareRectOneDirection(const TileIndex& t1, const TileIndex& t2) |
| { |
| switch (sortDirection) { |
| case LeftToRight: |
| return t1.i() - t2.i(); |
| case RightToLeft: |
| return t2.i() - t1.i(); |
| case TopToBottom: |
| return t1.j() - t2.j(); |
| case BottomToTop: |
| return t2.j() - t1.j(); |
| default: |
| break; |
| } |
| ASSERT_NOT_REACHED(); |
| return 0; |
| } |
| |
| template<SortDirection primarySortDirection, SortDirection secondarySortDirection> |
| static bool tileIndexIsLessThan(const TileIndex& t1, const TileIndex& t2) |
| { |
| int primaryResult = compareRectOneDirection<primarySortDirection>(t1, t2); |
| if (primaryResult || secondarySortDirection == primarySortDirection) |
| return primaryResult < 0; |
| return compareRectOneDirection<secondarySortDirection>(t1, t2) < 0; |
| } |
| |
| typedef bool (*FuncTileIndexLessThan)(const TileIndex& t1, const TileIndex& t2); |
| static FuncTileIndexLessThan tileIndexLessThanFunction(SortDirection primary, SortDirection secondary) |
| { |
| static FuncTileIndexLessThan s_tileIndexLessThanFunctions[NumSortDirections][NumSortDirections] = { { 0 } }; |
| static bool s_initialized = false; |
| if (!s_initialized) { |
| #define ADD_COMPARE_FUNCTION(_primary, _secondary) \ |
| s_tileIndexLessThanFunctions[_primary][_secondary] = tileIndexIsLessThan<_primary, _secondary> |
| |
| ADD_COMPARE_FUNCTION(LeftToRight, LeftToRight); |
| ADD_COMPARE_FUNCTION(LeftToRight, RightToLeft); |
| ADD_COMPARE_FUNCTION(LeftToRight, TopToBottom); |
| ADD_COMPARE_FUNCTION(LeftToRight, BottomToTop); |
| |
| ADD_COMPARE_FUNCTION(RightToLeft, LeftToRight); |
| ADD_COMPARE_FUNCTION(RightToLeft, RightToLeft); |
| ADD_COMPARE_FUNCTION(RightToLeft, TopToBottom); |
| ADD_COMPARE_FUNCTION(RightToLeft, BottomToTop); |
| |
| ADD_COMPARE_FUNCTION(TopToBottom, LeftToRight); |
| ADD_COMPARE_FUNCTION(TopToBottom, RightToLeft); |
| ADD_COMPARE_FUNCTION(TopToBottom, TopToBottom); |
| ADD_COMPARE_FUNCTION(TopToBottom, BottomToTop); |
| |
| ADD_COMPARE_FUNCTION(BottomToTop, LeftToRight); |
| ADD_COMPARE_FUNCTION(BottomToTop, RightToLeft); |
| ADD_COMPARE_FUNCTION(BottomToTop, TopToBottom); |
| ADD_COMPARE_FUNCTION(BottomToTop, BottomToTop); |
| #undef ADD_COMPARE_FUNCTION |
| |
| s_initialized = true; |
| } |
| |
| return s_tileIndexLessThanFunctions[primary][secondary]; |
| } |
| |
| class TileIndexLessThan { |
| public: |
| TileIndexLessThan(SortDirection primarySortDirection, SortDirection secondarySortDirection) |
| : m_tileIndexIsLessThan(tileIndexLessThanFunction(primarySortDirection, secondarySortDirection)) |
| { |
| } |
| |
| bool operator()(const TileIndex& t1, const TileIndex& t2) |
| { |
| return m_tileIndexIsLessThan(t1, t2); |
| } |
| |
| private: |
| FuncTileIndexLessThan m_tileIndexIsLessThan; |
| }; |
| |
| RenderQueue::RenderQueue(BackingStorePrivate* parent) |
| : m_parent(parent) |
| , m_rectsAddedToRegularRenderJobsInCurrentCycle(false) |
| , m_currentRegularRenderJobsBatchUnderPressure(false) |
| , m_primarySortDirection(TopToBottom) |
| , m_secondarySortDirection(LeftToRight) |
| { |
| } |
| |
| void RenderQueue::reset() |
| { |
| m_rectsAddedToRegularRenderJobsInCurrentCycle = false; |
| m_currentRegularRenderJobsBatchUnderPressure = false; |
| m_primarySortDirection = TopToBottom; |
| m_secondarySortDirection = LeftToRight; |
| m_visibleZoomJobs.clear(); |
| m_visibleZoomJobsCompleted.clear(); |
| m_visibleScrollJobs.clear(); |
| m_visibleScrollJobsCompleted.clear(); |
| m_nonVisibleScrollJobs.clear(); |
| m_nonVisibleScrollJobsCompleted.clear(); |
| m_regularRenderJobsRegion = Platform::IntRectRegion(); |
| m_currentRegularRenderJobsBatch.clear(); |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); |
| m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion(); |
| ASSERT(isEmpty()); |
| } |
| |
| bool RenderQueue::isEmpty(bool shouldPerformRegularRenderJobs) const |
| { |
| return m_visibleZoomJobs.isEmpty() && m_visibleScrollJobs.isEmpty() |
| && (!shouldPerformRegularRenderJobs || m_currentRegularRenderJobsBatch.isEmpty()) |
| && (!shouldPerformRegularRenderJobs || m_regularRenderJobsRegion.isEmpty()) |
| && m_nonVisibleScrollJobs.isEmpty(); |
| } |
| |
| bool RenderQueue::hasCurrentRegularRenderJob() const |
| { |
| return !m_currentRegularRenderJobsBatch.isEmpty() || !m_regularRenderJobsRegion.isEmpty(); |
| } |
| |
| bool RenderQueue::hasCurrentVisibleZoomJob() const |
| { |
| return !m_visibleZoomJobs.isEmpty(); |
| } |
| |
| bool RenderQueue::hasCurrentVisibleScrollJob() const |
| { |
| return !m_visibleScrollJobs.isEmpty(); |
| } |
| |
| bool RenderQueue::isCurrentVisibleZoomJob(const TileIndex& index) const |
| { |
| return m_visibleZoomJobs.contains(index); |
| } |
| |
| bool RenderQueue::isCurrentVisibleZoomJobCompleted(const TileIndex& index) const |
| { |
| return m_visibleZoomJobsCompleted.contains(index); |
| } |
| |
| bool RenderQueue::isCurrentVisibleScrollJob(const TileIndex& index) const |
| { |
| return m_visibleScrollJobs.contains(index); |
| } |
| |
| bool RenderQueue::isCurrentVisibleScrollJobCompleted(const TileIndex& index) const |
| { |
| return m_visibleScrollJobsCompleted.contains(index); |
| } |
| |
| bool RenderQueue::isCurrentRegularRenderJob(const TileIndex& index, BackingStoreGeometry* geometry) const |
| { |
| Platform::IntRect tileRect(geometry->originOfTile(index), m_parent->tileSize()); |
| Platform::IntRectRegion::IntersectionState regularJobsState = m_regularRenderJobsRegion.isRectInRegion(tileRect); |
| Platform::IntRectRegion::IntersectionState currentRegularJobsState = m_currentRegularRenderJobsBatchRegion.isRectInRegion(tileRect); |
| |
| return regularJobsState == Platform::IntRectRegion::ContainedInRegion |
| || regularJobsState == Platform::IntRectRegion::PartiallyContainedInRegion |
| || currentRegularJobsState == Platform::IntRectRegion::ContainedInRegion |
| || currentRegularJobsState == Platform::IntRectRegion::PartiallyContainedInRegion; |
| } |
| |
| bool RenderQueue::currentRegularRenderJobBatchUnderPressure() const |
| { |
| return m_currentRegularRenderJobsBatchUnderPressure; |
| } |
| |
| void RenderQueue::setCurrentRegularRenderJobBatchUnderPressure(bool currentRegularRenderJobsBatchUnderPressure) |
| { |
| m_currentRegularRenderJobsBatchUnderPressure = currentRegularRenderJobsBatchUnderPressure; |
| } |
| |
| void RenderQueue::eventQueueCycled() |
| { |
| // Called by the backing store when the event queue has cycled to allow the |
| // render queue to determine if the regular render jobs are under pressure. |
| if (m_rectsAddedToRegularRenderJobsInCurrentCycle && m_currentRegularRenderJobsBatchRegion.isEmpty()) |
| m_currentRegularRenderJobsBatchUnderPressure = true; |
| m_rectsAddedToRegularRenderJobsInCurrentCycle = false; |
| } |
| |
| TileIndexList RenderQueue::tileIndexesIntersectingRegion(const Platform::IntRectRegion& region, BackingStoreGeometry* geometry) const |
| { |
| TileIndexList indexes; |
| TileIndexList allIndexes = m_parent->indexesForBackingStoreRect(geometry->backingStoreRect()); |
| |
| for (size_t i = 0; i < allIndexes.size(); ++i) { |
| Platform::IntRect tileRect(geometry->originOfTile(allIndexes[i]), m_parent->tileSize()); |
| Platform::IntRectRegion::IntersectionState state = region.isRectInRegion(tileRect); |
| if (state == Platform::IntRectRegion::ContainedInRegion || state == Platform::IntRectRegion::PartiallyContainedInRegion) |
| indexes.append(allIndexes[i]); |
| } |
| return indexes; |
| } |
| |
| TileIndexList RenderQueue::tileIndexesFullyContainedInRegion(const Platform::IntRectRegion& region, BackingStoreGeometry* geometry) const |
| { |
| TileIndexList indexes; |
| TileIndexList allIndexes = m_parent->indexesForBackingStoreRect(geometry->backingStoreRect()); |
| |
| for (size_t i = 0; i < allIndexes.size(); ++i) { |
| Platform::IntRect tileRect(geometry->originOfTile(allIndexes[i]), m_parent->tileSize()); |
| Platform::IntRectRegion::IntersectionState state = region.isRectInRegion(tileRect); |
| if (state == Platform::IntRectRegion::ContainedInRegion) |
| indexes.append(allIndexes[i]); |
| } |
| return indexes; |
| } |
| |
| Platform::IntRectRegion RenderQueue::tileRegion(const TileIndexList& indexes, BackingStoreGeometry* geometry) const |
| { |
| Platform::IntRectRegion region; |
| |
| // Chances are the tiles comprise a perfect rectangle. If we add rectangles |
| // row by row or column by column, IntRectRegion should have an easier time |
| // merging them as the individual rows or columns will merge into another |
| // plain rectangle. |
| Platform::IntRectRegion currentRowOrColumnRegion; |
| size_t lastI = 0; |
| size_t lastJ = 0; |
| |
| for (size_t i = 0; i < indexes.size(); ++i) { |
| Platform::IntRect tileRect(geometry->originOfTile(indexes[i]), m_parent->tileSize()); |
| bool extendsCurrentRowOrColumn = i && (lastI == indexes[i].i() || lastJ == indexes[i].j()); |
| |
| if (extendsCurrentRowOrColumn) |
| currentRowOrColumnRegion = Platform::IntRectRegion::unionRegions(currentRowOrColumnRegion, tileRect); |
| else { |
| region = Platform::IntRectRegion::unionRegions(region, currentRowOrColumnRegion); |
| currentRowOrColumnRegion = tileRect; |
| } |
| lastI = indexes[i].i(); |
| lastJ = indexes[i].j(); |
| } |
| |
| return Platform::IntRectRegion::unionRegions(region, currentRowOrColumnRegion); |
| } |
| |
| void RenderQueue::addToQueue(JobType type, const Platform::IntRectRegion& region) |
| { |
| if (type == RegularRender) { |
| // Flag that we added rects in the current event queue cycle. |
| m_rectsAddedToRegularRenderJobsInCurrentCycle = true; |
| |
| // We try and detect if this newly added region intersects or is contained in the currently running |
| // batch of render jobs. If so, then we have to start the batch over since we decompose individual |
| // rects into subrects and might have already rendered one of them. If the web page's content has |
| // changed state then this can lead to artifacts. We mark this by noting the batch is now under pressure |
| // and the backingstore will attempt to clear it at the next available opportunity. |
| std::vector<Platform::IntRect> rectsInRegion = region.rects(); |
| for (size_t i = 0; i < rectsInRegion.size(); ++i) { |
| Platform::IntRectRegion::IntersectionState state = m_currentRegularRenderJobsBatchRegion.isRectInRegion(rectsInRegion[i]); |
| if (state == Platform::IntRectRegion::ContainedInRegion || state == Platform::IntRectRegion::PartiallyContainedInRegion) { |
| m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, m_currentRegularRenderJobsBatchRegion); |
| m_currentRegularRenderJobsBatch.clear(); |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); |
| m_currentRegularRenderJobsBatchUnderPressure = true; |
| } |
| } |
| addToRegularQueue(region); |
| return; |
| } |
| |
| TileIndexList indexes = tileIndexesIntersectingRegion(region, m_parent->frontState()); |
| |
| switch (type) { |
| case VisibleZoom: |
| addToScrollZoomQueue(indexes, &m_visibleZoomJobs); |
| return; |
| case VisibleScroll: |
| addToScrollZoomQueue(indexes, &m_visibleScrollJobs); |
| return; |
| case NonVisibleScroll: |
| addToScrollZoomQueue(indexes, &m_nonVisibleScrollJobs); |
| return; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| } |
| |
| void RenderQueue::addToRegularQueue(const Platform::IntRectRegion& region) |
| { |
| #if DEBUG_RENDER_QUEUE |
| std::vector<Platform::IntRect> rectsInRegion = region.rects(); |
| for (size_t i = 0; i < rectsInRegion.size(); ++i) { |
| if (m_regularRenderJobsRegion.isRectInRegion(rectsInRegion[i]) != Platform::IntRectRegion::ContainedInRegion) { |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::addToRegularQueue region within %s", |
| region.extents().toString().c_str()); |
| break; |
| } |
| } |
| #endif |
| |
| m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, region); |
| |
| // Do not let the regular render queue grow past a maximum of 3 disjoint rects. |
| if (m_regularRenderJobsRegion.numRects() > 2) |
| m_regularRenderJobsRegion = m_regularRenderJobsRegion.extents(); |
| |
| if (!isEmpty()) |
| m_parent->dispatchRenderJob(); |
| } |
| |
| void RenderQueue::addToScrollZoomQueue(const TileIndexList& addedTiles, TileIndexList* alreadyQueuedTiles) |
| { |
| Platform::IntRect contentsRect = m_parent->expandedContentsRect(); |
| for (size_t i = 0; i < addedTiles.size(); ++i) { |
| if (alreadyQueuedTiles->contains(addedTiles[i])) |
| continue; |
| |
| Platform::IntRect tileRect(m_parent->frontState()->originOfTile(addedTiles[i]), m_parent->tileSize()); |
| if (!contentsRect.intersects(tileRect)) { |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::addToScrollZoomQueue tile at %s outside of expanded contents rect %s, ignoring.", |
| tileRect.toString().c_str(), |
| contentsRect.toString().c_str()); |
| #endif |
| continue; |
| } |
| |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::addToScrollZoomQueue tile at %s", |
| m_parent->frontState()->originOfTile(addedTiles[i]).toString().c_str()); |
| #endif |
| alreadyQueuedTiles->append(addedTiles[i]); |
| } |
| |
| if (!isEmpty()) |
| m_parent->dispatchRenderJob(); |
| } |
| |
| void RenderQueue::quickSort(TileIndexList* queue) |
| { |
| size_t length = queue->size(); |
| if (!length) |
| return; |
| |
| WTF::nonCopyingSort(queue->begin(), queue->end(), TileIndexLessThan(m_primarySortDirection, m_secondarySortDirection)); |
| } |
| |
| void RenderQueue::updateSortDirection(int lastDeltaX, int lastDeltaY) |
| { |
| bool primaryIsHorizontal = abs(lastDeltaX) >= abs(lastDeltaY); |
| if (primaryIsHorizontal) { |
| m_primarySortDirection = lastDeltaX <= 0 ? LeftToRight : RightToLeft; |
| m_secondarySortDirection = lastDeltaY <= 0 ? TopToBottom : BottomToTop; |
| } else { |
| m_primarySortDirection = lastDeltaY <= 0 ? TopToBottom : BottomToTop; |
| m_secondarySortDirection = lastDeltaX <= 0 ? LeftToRight : RightToLeft; |
| } |
| } |
| |
| void RenderQueue::visibleContentChanged(const Platform::IntRect& visibleContent) |
| { |
| if (m_visibleScrollJobs.isEmpty() && m_nonVisibleScrollJobs.isEmpty()) { |
| ASSERT(m_visibleScrollJobsCompleted.isEmpty() && m_nonVisibleScrollJobsCompleted.isEmpty()); |
| return; |
| } |
| |
| TileIndexList visibleTiles = tileIndexesIntersectingRegion(visibleContent, m_parent->frontState()); |
| |
| // Move visibleScrollJobs to nonVisibleScrollJobs if they do not intersect |
| // the visible content rect. |
| for (size_t i = 0; i < m_visibleScrollJobs.size(); ++i) { |
| if (!visibleTiles.contains(m_visibleScrollJobs[i])) { |
| ASSERT(!m_nonVisibleScrollJobs.contains(m_visibleScrollJobs[i])); |
| m_nonVisibleScrollJobs.append(m_visibleScrollJobs[i]); |
| m_visibleScrollJobs.remove(i); |
| --i; |
| } |
| } |
| |
| // Do the same for the completed list. |
| for (size_t i = 0; i < m_visibleScrollJobsCompleted.size(); ++i) { |
| if (!visibleTiles.contains(m_visibleScrollJobsCompleted[i])) { |
| ASSERT(!m_nonVisibleScrollJobsCompleted.contains(m_visibleScrollJobsCompleted[i])); |
| m_nonVisibleScrollJobsCompleted.append(m_visibleScrollJobsCompleted[i]); |
| m_visibleScrollJobsCompleted.remove(i); |
| --i; |
| } |
| } |
| |
| // Move nonVisibleScrollJobs to visibleScrollJobs if they do intersect |
| // the visible content rect. |
| for (size_t i = 0; i < m_nonVisibleScrollJobs.size(); ++i) { |
| if (visibleTiles.contains(m_nonVisibleScrollJobs[i])) { |
| ASSERT(!m_visibleScrollJobs.contains(m_nonVisibleScrollJobs[i])); |
| m_visibleScrollJobs.append(m_nonVisibleScrollJobs[i]); |
| m_nonVisibleScrollJobs.remove(i); |
| --i; |
| } |
| } |
| |
| // Do the same for the completed list. |
| for (size_t i = 0; i < m_nonVisibleScrollJobsCompleted.size(); ++i) { |
| if (visibleTiles.contains(m_nonVisibleScrollJobsCompleted[i])) { |
| ASSERT(!m_visibleScrollJobsCompleted.contains(m_nonVisibleScrollJobsCompleted[i])); |
| m_visibleScrollJobsCompleted.append(m_nonVisibleScrollJobsCompleted[i]); |
| m_nonVisibleScrollJobsCompleted.remove(i); |
| --i; |
| } |
| } |
| |
| if (m_visibleScrollJobs.isEmpty() && !m_visibleScrollJobsCompleted.isEmpty()) |
| scrollZoomJobsCompleted(m_visibleScrollJobs, &m_visibleScrollJobsCompleted, false /*shouldBlit*/); |
| |
| if (m_nonVisibleScrollJobs.isEmpty() && !m_nonVisibleScrollJobsCompleted.isEmpty()) |
| scrollZoomJobsCompleted(m_nonVisibleScrollJobs, &m_nonVisibleScrollJobsCompleted, false /*shouldBlit*/); |
| |
| // We shouldn't be empty because the early return above and the fact that this |
| // method just shuffles rects from queue to queue hence the total number of |
| // rects in the various queues should be conserved. |
| ASSERT(!isEmpty()); |
| } |
| |
| void RenderQueue::backingStoreRectChanging(const Platform::IntRect&, const Platform::IntRect&) |
| { |
| // We could empty them here instead of in BackingStorePrivate::setBackingStoreRect(), |
| // but it seems cleaner to do it there and still avoid code to manually move them. |
| ASSERT(m_visibleZoomJobs.isEmpty()); |
| ASSERT(m_visibleZoomJobsCompleted.isEmpty()); |
| ASSERT(m_visibleScrollJobs.isEmpty()); |
| ASSERT(m_visibleScrollJobsCompleted.isEmpty()); |
| ASSERT(m_nonVisibleScrollJobs.isEmpty()); |
| ASSERT(m_nonVisibleScrollJobsCompleted.isEmpty()); |
| |
| // Empty the tile-based current batch and merge its remaining region with |
| // the one from other upcoming regular render jobs. We'll pick all of them |
| // up next time renderRegularRenderJobs() is called. |
| m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, m_currentRegularRenderJobsBatchRegion); |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); |
| m_currentRegularRenderJobsBatch.clear(); |
| } |
| |
| void RenderQueue::clear(const Platform::IntRectRegion& region, ClearJobsFlags clearJobsFlags) |
| { |
| clearRegions(region, clearJobsFlags); |
| clearTileIndexes(tileIndexesFullyContainedInRegion(region, m_parent->frontState()), clearJobsFlags); |
| } |
| |
| void RenderQueue::clear(const TileIndexList& indexes, BackingStoreGeometry* geometry, ClearJobsFlags clearJobsFlags) |
| { |
| clearRegions(tileRegion(indexes, geometry), clearJobsFlags); |
| clearTileIndexes(indexes, clearJobsFlags); |
| } |
| |
| void RenderQueue::clearRegions(const Platform::IntRectRegion& region, ClearJobsFlags clearJobsFlags) |
| { |
| if (clearJobsFlags & ClearRegularRenderJobs) { |
| m_regularRenderJobsRegion = Platform::IntRectRegion::subtractRegions(m_regularRenderJobsRegion, region); |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::subtractRegions(m_currentRegularRenderJobsBatchRegion, region); |
| m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion::subtractRegions(m_regularRenderJobsNotRenderedRegion, region); |
| } |
| } |
| |
| void RenderQueue::clearTileIndexes(const TileIndexList& indexes, ClearJobsFlags clearJobsFlags) |
| { |
| if (m_visibleScrollJobs.isEmpty() && m_nonVisibleScrollJobs.isEmpty()) |
| ASSERT(m_visibleScrollJobsCompleted.isEmpty() && m_nonVisibleScrollJobsCompleted.isEmpty()); |
| |
| // Remove all indexes from all queues that are being marked as cleared. |
| if (clearJobsFlags & ClearIncompleteZoomJobs) { |
| for (size_t i = 0; i < m_visibleZoomJobs.size(); ++i) { |
| if (indexes.contains(m_visibleZoomJobs.at(i))) { |
| m_visibleZoomJobs.remove(i); |
| --i; |
| } |
| } |
| } |
| |
| if (clearJobsFlags & ClearIncompleteScrollJobs) { |
| for (size_t i = 0; i < m_visibleScrollJobs.size(); ++i) { |
| if (indexes.contains(m_visibleScrollJobs.at(i))) { |
| m_visibleScrollJobs.remove(i); |
| --i; |
| } |
| } |
| |
| for (size_t i = 0; i < m_nonVisibleScrollJobs.size(); ++i) { |
| if (indexes.contains(m_nonVisibleScrollJobs.at(i))) { |
| m_nonVisibleScrollJobs.remove(i); |
| --i; |
| } |
| } |
| } |
| |
| if (clearJobsFlags & ClearCompletedJobs) { |
| for (size_t i = 0; i < m_visibleZoomJobsCompleted.size(); ++i) { |
| if (indexes.contains(m_visibleZoomJobsCompleted.at(i))) { |
| m_visibleZoomJobsCompleted.remove(i); |
| --i; |
| } |
| } |
| |
| for (size_t i = 0; i < m_visibleScrollJobsCompleted.size(); ++i) { |
| if (indexes.contains(m_visibleScrollJobsCompleted.at(i))) { |
| m_visibleScrollJobsCompleted.remove(i); |
| --i; |
| } |
| } |
| |
| for (size_t i = 0; i < m_nonVisibleScrollJobsCompleted.size(); ++i) { |
| if (indexes.contains(m_nonVisibleScrollJobsCompleted.at(i))) { |
| m_nonVisibleScrollJobsCompleted.remove(i); |
| --i; |
| } |
| } |
| } |
| |
| if (clearJobsFlags & ClearRegularRenderJobs) { |
| for (size_t i = 0; i < m_currentRegularRenderJobsBatch.size(); ++i) { |
| if (indexes.contains(m_currentRegularRenderJobsBatch.at(i))) { |
| m_currentRegularRenderJobsBatch.remove(i); |
| --i; |
| } |
| } |
| } |
| |
| if (m_visibleZoomJobs.isEmpty() && !m_visibleZoomJobsCompleted.isEmpty()) |
| scrollZoomJobsCompleted(m_visibleZoomJobs, &m_visibleZoomJobsCompleted, false /*shouldBlit*/); |
| |
| if (m_visibleScrollJobs.isEmpty() && !m_visibleScrollJobsCompleted.isEmpty()) |
| scrollZoomJobsCompleted(m_visibleScrollJobs, &m_visibleScrollJobsCompleted, false /*shouldBlit*/); |
| |
| if (m_nonVisibleScrollJobs.isEmpty() && !m_nonVisibleScrollJobsCompleted.isEmpty()) |
| scrollZoomJobsCompleted(m_nonVisibleScrollJobs, &m_nonVisibleScrollJobsCompleted, false /*shouldBlit*/); |
| } |
| |
| bool RenderQueue::regularRenderJobsPreviouslyAttemptedButNotRendered(const Platform::IntRect& rect) |
| { |
| return m_regularRenderJobsNotRenderedRegion.isRectInRegion(rect) != Platform::IntRectRegion::NotInRegion; |
| } |
| |
| void RenderQueue::render(bool shouldPerformRegularRenderJobs) |
| { |
| // We request a layout here to ensure that we're executing jobs in the correct |
| // order. If we didn't request a layout here then the jobs below could result |
| // in a layout and that layout can alter this queue. So request layout if needed |
| // to ensure that the queues below are in constant state before performing the |
| // next rendering job. |
| |
| #if DEBUG_RENDER_QUEUE |
| // Start the time measurement. |
| double time = WTF::currentTime(); |
| #endif |
| |
| m_parent->requestLayoutIfNeeded(); |
| m_parent->updateTileMatrixIfNeeded(); |
| |
| #if DEBUG_RENDER_QUEUE |
| double elapsed = WTF::currentTime() - time; |
| if (elapsed) |
| Platform::logAlways(Platform::LogLevelCritical, "RenderQueue::render layout elapsed=%f", elapsed); |
| #endif |
| |
| // Empty the queues in a precise order of priority. |
| if (!m_visibleZoomJobs.isEmpty()) |
| renderScrollZoomJobs(&m_visibleZoomJobs, &m_visibleZoomJobsCompleted, true /*allAtOnceIfPossible*/, true /*shouldBlitWhenCompleted*/); |
| else if (!m_visibleScrollJobs.isEmpty()) |
| renderScrollZoomJobs(&m_visibleScrollJobs, &m_visibleScrollJobsCompleted, false /*allAtOnceIfPossible*/, true /*shouldBlitWhenCompleted*/); |
| else if (shouldPerformRegularRenderJobs && (!m_currentRegularRenderJobsBatch.isEmpty() || !m_regularRenderJobsRegion.isEmpty())) { |
| bool allAtOnceIfPossible = currentRegularRenderJobBatchUnderPressure(); |
| renderRegularRenderJobs(allAtOnceIfPossible); |
| } else if (!m_nonVisibleScrollJobs.isEmpty()) |
| renderScrollZoomJobs(&m_nonVisibleScrollJobs, &m_nonVisibleScrollJobsCompleted, false /*allAtOnceIfPossible*/, false /*shouldBlitWhenCompleted*/); |
| } |
| |
| void RenderQueue::renderRegularRenderJobs(bool allAtOnceIfPossible) |
| { |
| #if DEBUG_RENDER_QUEUE |
| // Start the time measurement. |
| double time = WTF::currentTime(); |
| #endif |
| |
| ASSERT(!m_currentRegularRenderJobsBatch.isEmpty() || !m_regularRenderJobsRegion.isEmpty()); |
| |
| if (allAtOnceIfPossible && !m_currentRegularRenderJobsBatchRegion.isEmpty()) { |
| // If there is a current batch of jobs already, merge it back into the |
| // whole area so that we will pick up all of it for the next run. |
| m_regularRenderJobsRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsRegion, m_currentRegularRenderJobsBatchRegion); |
| |
| // Clear this since we're about to render everything. |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion(); |
| m_currentRegularRenderJobsBatch.clear(); |
| } |
| |
| Platform::IntRect contentsRect = m_parent->expandedContentsRect(); |
| |
| // Start new batch if needed. |
| if (m_currentRegularRenderJobsBatchRegion.isEmpty()) { |
| // Don't try to render anything outside the whole contents rectangle. |
| m_regularRenderJobsRegion = Platform::IntRectRegion::intersectRegions(m_regularRenderJobsRegion, contentsRect); |
| |
| // Split the current regular render job region into tiles. |
| // Discard regions outside of the region covered by these tiles. |
| // They'll be rendered when the geometry changes. |
| m_regularRenderJobsRegion = Platform::IntRectRegion::intersectRegions(m_regularRenderJobsRegion, m_parent->frontState()->backingStoreRect()); |
| m_currentRegularRenderJobsBatch = tileIndexesIntersectingRegion(m_regularRenderJobsRegion, m_parent->frontState()); |
| |
| // Create a region object that will be checked when adding new rects before |
| // this batch has been completed. |
| m_currentRegularRenderJobsBatchRegion = m_regularRenderJobsRegion; |
| |
| // Clear the former region since it is now part of this batch. |
| m_regularRenderJobsRegion = Platform::IntRectRegion(); |
| |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderRegularRenderJobs batch size is %d!", |
| m_currentRegularRenderJobsBatch.size()); |
| #endif |
| } |
| |
| Platform::IntRectRegion changingRegion = m_currentRegularRenderJobsBatchRegion; |
| Platform::IntRectRegion changingRegionScheduledForLater = m_regularRenderJobsRegion; |
| Platform::IntRectRegion regionNotRenderedThisTime; |
| |
| TileIndexList* outstandingJobs = &m_currentRegularRenderJobsBatch; |
| TileIndexList completedJobs; |
| TileIndexList tilesToRender; |
| |
| unsigned numberOfAvailableBackBuffers = SurfacePool::globalSurfacePool()->numberOfAvailableBackBuffers(); |
| |
| while (!outstandingJobs->isEmpty() && numberOfAvailableBackBuffers) { |
| // Render as many tiles at once as we can handle. |
| for (size_t i = 0; i < outstandingJobs->size() && numberOfAvailableBackBuffers; ++i) { |
| TileIndex index = (*outstandingJobs)[i]; |
| |
| BackingStoreGeometry* geometry = m_parent->frontState(); |
| Platform::IntRect tileRect(geometry->originOfTile(index), m_parent->tileSize()); |
| |
| if (!contentsRect.intersects(tileRect)) { |
| // This is a safety fallback, at this point we should only |
| // encounter tiles outside of the contents rect if we're in |
| // a second run of the same batch and the contents size has |
| // changed since the last run. Otherwise, see the cropping above. |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderRegularRenderJobs tile at %s outside of expanded contents rect %s, ignoring.", |
| tileRect.toString().c_str(), |
| contentsRect.toString().c_str()); |
| #endif |
| outstandingJobs->remove(i); |
| --i; |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::intersectRegions(m_currentRegularRenderJobsBatchRegion, contentsRect); |
| continue; |
| } |
| |
| if (m_parent->shouldSuppressNonVisibleRegularRenderJobs()) { |
| // If a tile is not visible, remember it as not rendered to be |
| // picked up later by updateTilesForScrollOrNotRenderedRegion() |
| // or updateTilesAfterBackingStoreRectChange(). |
| Platform::IntRectRegion tileRegionNotRendered; |
| |
| if (!m_parent->isTileVisible(index, geometry)) { |
| tileRegionNotRendered = Platform::IntRectRegion::intersectRegions(tileRect, m_currentRegularRenderJobsBatchRegion); |
| regionNotRenderedThisTime = Platform::IntRectRegion::unionRegions(regionNotRenderedThisTime, tileRegionNotRendered); |
| } |
| |
| if (!tileRegionNotRendered.isEmpty()) { |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderRegularRenderJobs region within %s not completely rendered!", |
| tileRegionNotRendered.extents().toString().c_str()); |
| #endif |
| outstandingJobs->remove(i); |
| --i; |
| continue; |
| } |
| } |
| |
| tilesToRender.append(index); |
| --numberOfAvailableBackBuffers; |
| } |
| |
| if (tilesToRender.isEmpty()) |
| break; |
| |
| // This will also clear the rendered tiles in outstandingJobs. |
| TileIndexList renderedTiles = m_parent->render(tilesToRender); |
| |
| // Update number of available back buffers now that we've used them. |
| numberOfAvailableBackBuffers = SurfacePool::globalSurfacePool()->numberOfAvailableBackBuffers(); |
| |
| ASSERT(!renderedTiles.isEmpty()); |
| if (renderedTiles.isEmpty()) { |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderRegularRenderJobs no tiles rendered (%d attempted), available back buffers: %d", |
| tilesToRender.size(), |
| numberOfAvailableBackBuffers); |
| #endif |
| break; // Something bad happened, make sure not to try again for now. |
| } |
| |
| for (size_t i = 0; i < renderedTiles.size(); ++i) { |
| if (!completedJobs.contains(renderedTiles[i])) |
| completedJobs.append(renderedTiles[i]); |
| } |
| |
| if (!allAtOnceIfPossible) |
| break; // We can do the rest next time. |
| } |
| |
| const Platform::IntRectRegion renderedRegion = tileRegion(completedJobs, m_parent->frontState()); |
| |
| m_regularRenderJobsNotRenderedRegion = Platform::IntRectRegion::unionRegions(m_regularRenderJobsNotRenderedRegion, regionNotRenderedThisTime); |
| m_currentRegularRenderJobsBatchRegion = Platform::IntRectRegion::subtractRegions(m_currentRegularRenderJobsBatchRegion, regionNotRenderedThisTime); |
| |
| #if DEBUG_RENDER_QUEUE |
| // Stop the time measurement. |
| double elapsed = WTF::currentTime() - time; |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderRegularRenderJobs within %s: completed = %d, outstanding = %d, elapsed=%f", |
| changingRegion.extents().toString().c_str(), |
| completedJobs.size(), |
| outstandingJobs->size(), |
| elapsed); |
| #endif |
| |
| // Make sure we didn't alter state of the queues that should have been empty |
| // before this method was called. |
| ASSERT(m_visibleZoomJobs.isEmpty()); |
| ASSERT(m_visibleScrollJobs.isEmpty()); |
| |
| if (m_currentRegularRenderJobsBatchRegion.isEmpty()) { |
| // If the whole scheduled area has been rendered, all outstanding jobs |
| // should have been cleared as well. |
| ASSERT(outstandingJobs->isEmpty()); |
| m_currentRegularRenderJobsBatchUnderPressure = false; |
| |
| // Notify about the newly rendered content. |
| // In case we picked up an unfinished batch from before, because we |
| // paint a larger area it's possible that we also rendered other |
| // regions that were originally scheduled for later. |
| Platform::IntRectRegion wholeScheduledRegion = Platform::IntRectRegion::unionRegions(changingRegion, changingRegionScheduledForLater); |
| Platform::IntRectRegion renderedChangedRegion = Platform::IntRectRegion::intersectRegions(wholeScheduledRegion, renderedRegion); |
| |
| // Blit since this batch is now complete. |
| m_parent->didRenderContent(renderedChangedRegion); |
| } |
| |
| if (m_parent->shouldSuppressNonVisibleRegularRenderJobs() && !regionNotRenderedThisTime.isEmpty()) |
| m_parent->updateTilesForScrollOrNotRenderedRegion(false /*checkLoading*/); |
| } |
| |
| void RenderQueue::renderScrollZoomJobs(TileIndexList* outstandingJobs, TileIndexList* completedJobs, bool allAtOnceIfPossible, bool shouldBlitWhenCompleted) |
| { |
| ASSERT(!outstandingJobs->isEmpty()); |
| |
| #if DEBUG_RENDER_QUEUE || DEBUG_RENDER_QUEUE_SORT |
| // Start the time measurement. |
| double time = WTF::currentTime(); |
| double elapsed; |
| #endif |
| |
| Platform::IntRect contentsRect = m_parent->expandedContentsRect(); |
| |
| unsigned numberOfAvailableBackBuffers = SurfacePool::globalSurfacePool()->numberOfAvailableBackBuffers(); |
| |
| // If we take multiple turns to render, we sort to make them appear in the right order. |
| if (!allAtOnceIfPossible && outstandingJobs->size() > numberOfAvailableBackBuffers) |
| quickSort(outstandingJobs); |
| |
| #if DEBUG_RENDER_QUEUE_SORT |
| // Stop the time measurement |
| elapsed = WTF::currentTime() - time; |
| Platform::logAlways(Platform::LogLevelCritical, "RenderQueue::renderScrollZoomJobs sort elapsed=%f", elapsed); |
| #endif |
| |
| TileIndexList tilesToRender; |
| |
| while (!outstandingJobs->isEmpty() && numberOfAvailableBackBuffers) { |
| // Render as many tiles at once as we can handle. |
| for (size_t i = 0; i < outstandingJobs->size() && numberOfAvailableBackBuffers; ++i) { |
| TileIndex index = (*outstandingJobs)[i]; |
| Platform::IntRect tileRect(m_parent->frontState()->originOfTile(index), m_parent->tileSize()); |
| |
| // Make sure we only try to render tiles containing contents. |
| if (!contentsRect.intersects(tileRect)) { |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderScrollZoomJobs tile at %s outside of expanded contents rect %s, ignoring.", |
| tileRect.toString().c_str(), |
| contentsRect.toString().c_str()); |
| #endif |
| outstandingJobs->remove(i); |
| --i; |
| continue; |
| } |
| |
| tilesToRender.append((*outstandingJobs)[i]); |
| --numberOfAvailableBackBuffers; |
| } |
| |
| if (tilesToRender.isEmpty()) |
| break; |
| |
| // This will clear the rendered tiles in outstandingJobs. |
| TileIndexList renderedTiles = m_parent->render(tilesToRender); |
| |
| // Update number of available back buffers now that we've used them. |
| numberOfAvailableBackBuffers = SurfacePool::globalSurfacePool()->numberOfAvailableBackBuffers(); |
| |
| ASSERT(!renderedTiles.isEmpty()); |
| if (renderedTiles.isEmpty()) { |
| #if DEBUG_RENDER_QUEUE |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderScrollZoomJobs no tiles rendered (%d attempted, available back buffers: %d)", |
| tilesToRender.size(), |
| numberOfAvailableBackBuffers); |
| #endif |
| break; // Something bad happened, make sure not to try again for now. |
| } |
| |
| for (size_t i = 0; i < renderedTiles.size(); ++i) { |
| if (!completedJobs->contains(renderedTiles[i])) |
| completedJobs->append(renderedTiles[i]); |
| } |
| |
| if (!allAtOnceIfPossible) |
| break; // We can do the rest next time. |
| } |
| |
| #if DEBUG_RENDER_QUEUE |
| // Stop the time measurement. |
| elapsed = WTF::currentTime() - time; |
| Platform::logAlways(Platform::LogLevelCritical, |
| "RenderQueue::renderScrollZoomJobs completed=%d, outstanding=%d, elapsed=%f", |
| completedJobs->size(), |
| outstandingJobs->size(), |
| elapsed); |
| #endif |
| |
| if (outstandingJobs->isEmpty()) |
| scrollZoomJobsCompleted(*outstandingJobs, completedJobs, shouldBlitWhenCompleted); |
| } |
| |
| void RenderQueue::scrollZoomJobsCompleted(const TileIndexList& outstandingJobs, TileIndexList* completedJobs, bool shouldBlit) |
| { |
| // Get rid of the completed list! |
| ASSERT(outstandingJobs.isEmpty()); |
| completedJobs->clear(); |
| |
| // Now blit to the screen if we are done! |
| if (shouldBlit) |
| m_parent->didRenderContent(m_parent->visibleContentsRect()); |
| } |
| |
| } // namespace WebKit |
| } // namespace BlackBerry |
