#include "cc/resources/eviction_tile_priority_queue.h"
#include "cc/resources/managed_tile_state.h"
#include "cc/resources/memory_history.h"
-#include "cc/resources/picture_pile_impl.h"
-#include "cc/resources/prioritized_tile_set.h"
+#include "cc/resources/raster_source.h"
#include "cc/resources/raster_tile_priority_queue.h"
#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_pool.h"
base::SequencedTaskRunner* task_runner,
ResourcePool* resource_pool,
Rasterizer* rasterizer,
- RenderingStatsInstrumentation* rendering_stats_instrumentation);
- virtual ~TileManager();
+ RenderingStatsInstrumentation* rendering_stats_instrumentation,
+ size_t scheduled_raster_task_limit);
+ ~TileManager() override;
void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
// Returns true when visible tiles have been initialized.
bool UpdateVisibleTiles();
- scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile,
+ scoped_refptr<Tile> CreateTile(RasterSource* raster_source,
const gfx::Size& tile_size,
const gfx::Rect& content_rect,
float contents_scale,
void InitializeTilesWithResourcesForTesting(const std::vector<Tile*>& tiles) {
for (size_t i = 0; i < tiles.size(); ++i) {
ManagedTileState& mts = tiles[i]->managed_state();
- ManagedTileState::TileVersion& tile_version =
- mts.tile_versions[HIGH_QUALITY_RASTER_MODE];
- tile_version.resource_ =
+ mts.draw_info.resource_ =
resource_pool_->AcquireResource(tiles[i]->size());
-
- bytes_releasable_ += BytesConsumedIfAllocated(tiles[i]);
- ++resources_releasable_;
}
}
void ReleaseTileResourcesForTesting(const std::vector<Tile*>& tiles) {
for (size_t i = 0; i < tiles.size(); ++i) {
Tile* tile = tiles[i];
- for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
- FreeResourceForTile(tile, static_cast<RasterMode>(mode));
- }
+ FreeResourcesForTile(tile);
}
}
void SetGlobalStateForTesting(
const GlobalStateThatImpactsTilePriority& state) {
- // Soft limit is used for resource pool such that
- // memory returns to soft limit after going over.
- if (state != global_state_) {
- global_state_ = state;
- prioritized_tiles_dirty_ = true;
- }
+ global_state_ = state;
}
void SetRasterizerForTesting(Rasterizer* rasterizer);
void FreeResourcesAndCleanUpReleasedTilesForTesting() {
- prioritized_tiles_.Clear();
FreeResourcesForReleasedTiles();
CleanUpReleasedTiles();
}
const scoped_refptr<base::SequencedTaskRunner>& task_runner,
ResourcePool* resource_pool,
Rasterizer* rasterizer,
- RenderingStatsInstrumentation* rendering_stats_instrumentation);
-
- // Methods called by Tile
- friend class Tile;
- void DidChangeTilePriority(Tile* tile);
+ RenderingStatsInstrumentation* rendering_stats_instrumentation,
+ size_t scheduled_raster_task_limit);
void FreeResourcesForReleasedTiles();
void CleanUpReleasedTiles();
// Overriden from RefCountedManager<Tile>:
- virtual void Release(Tile* tile) OVERRIDE;
+ friend class Tile;
+ void Release(Tile* tile) override;
// Overriden from RasterizerClient:
- virtual void DidFinishRunningTasks(TaskSet task_set) OVERRIDE;
- virtual TaskSetCollection TasksThatShouldBeForcedToComplete() const OVERRIDE;
+ void DidFinishRunningTasks(TaskSet task_set) override;
+ TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
typedef std::vector<Tile*> TileVector;
typedef std::set<Tile*> TileSet;
virtual void ScheduleTasks(
const TileVector& tiles_that_need_to_be_rasterized);
- void AssignGpuMemoryToTiles(PrioritizedTileSet* tiles,
- TileVector* tiles_that_need_to_be_rasterized);
- void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
+ void AssignGpuMemoryToTiles(TileVector* tiles_that_need_to_be_rasterized);
private:
+ class MemoryUsage {
+ public:
+ MemoryUsage();
+ MemoryUsage(int64 memory_bytes, int resource_count);
+
+ static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
+ static MemoryUsage FromTile(const Tile* tile);
+
+ MemoryUsage& operator+=(const MemoryUsage& other);
+ MemoryUsage& operator-=(const MemoryUsage& other);
+ MemoryUsage operator-(const MemoryUsage& other);
+
+ bool Exceeds(const MemoryUsage& limit) const;
+ int64 memory_bytes() const { return memory_bytes_; }
+
+ private:
+ int64 memory_bytes_;
+ int resource_count_;
+ };
+
void OnImageDecodeTaskCompleted(int layer_id,
SkPixelRef* pixel_ref,
bool was_canceled);
void OnRasterTaskCompleted(Tile::Id tile,
scoped_ptr<ScopedResource> resource,
- RasterMode raster_mode,
- const PicturePileImpl::Analysis& analysis,
+ const RasterSource::SolidColorAnalysis& analysis,
bool was_canceled);
- inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
- return Resource::MemorySizeBytes(tile->size(),
- resource_pool_->resource_format());
- }
-
- void FreeResourceForTile(Tile* tile, RasterMode mode);
void FreeResourcesForTile(Tile* tile);
- void FreeUnusedResourcesForTile(Tile* tile);
void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
SkPixelRef* pixel_ref);
scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
- void UpdatePrioritizedTileSetIfNeeded();
+ void RebuildEvictionQueueIfNeeded();
+ bool FreeTileResourcesUntilUsageIsWithinLimit(const MemoryUsage& limit,
+ MemoryUsage* usage);
+ bool FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
+ const MemoryUsage& limit,
+ const TilePriority& oother_priority,
+ MemoryUsage* usage);
+ bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority);
bool IsReadyToActivate() const;
void CheckIfReadyToActivate();
ResourcePool* resource_pool_;
Rasterizer* rasterizer_;
GlobalStateThatImpactsTilePriority global_state_;
+ const size_t scheduled_raster_task_limit_;
typedef base::hash_map<Tile::Id, Tile*> TileMap;
TileMap tiles_;
- PrioritizedTileSet prioritized_tiles_;
- bool prioritized_tiles_dirty_;
-
- bool all_tiles_that_need_to_be_rasterized_have_memory_;
- bool all_tiles_required_for_activation_have_memory_;
-
- size_t bytes_releasable_;
- size_t resources_releasable_;
-
- bool ever_exceeded_memory_budget_;
+ bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
MemoryHistory::Entry memory_stats_from_last_assign_;
RenderingStatsInstrumentation* rendering_stats_instrumentation_;
bool did_check_for_completed_tasks_since_last_schedule_tasks_;
bool did_oom_on_last_assign_;
- typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> >
+ typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>
PixelRefTaskMap;
typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
LayerPixelRefTaskMap image_decode_tasks_;
// Queue used when scheduling raster tasks.
RasterTaskQueue raster_queue_;
- std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
+ std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
UniqueNotifier ready_to_activate_check_notifier_;
+ RasterTilePriorityQueue raster_priority_queue_;
+ EvictionTilePriorityQueue eviction_priority_queue_;
+ bool eviction_priority_queue_is_up_to_date_;
+
DISALLOW_COPY_AND_ASSIGN(TileManager);
};
projects / platform / framework / web / crosswalk.git / blobdiff