#ifndef CC_RESOURCES_TILE_MANAGER_H_
#define CC_RESOURCES_TILE_MANAGER_H_
+#include <deque>
#include <queue>
#include <set>
+#include <utility>
#include <vector>
#include "base/containers/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "cc/base/ref_counted_managed.h"
+#include "cc/base/unique_notifier.h"
#include "cc/debug/rendering_stats_instrumentation.h"
+#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_worker_pool.h"
+#include "cc/resources/raster_tile_priority_queue.h"
+#include "cc/resources/rasterizer.h"
#include "cc/resources/resource_pool.h"
#include "cc/resources/tile.h"
+namespace base {
+namespace debug {
+class ConvertableToTraceFormat;
+class TracedValue;
+}
+}
+
namespace cc {
-class RasterWorkerPoolDelegate;
+class PictureLayerImpl;
class ResourceProvider;
class CC_EXPORT TileManagerClient {
public:
+ // Returns the set of layers that the tile manager should consider for raster.
+ // TODO(vmpstr): Change the way we determine if we are ready to activate, so
+ // that this can be removed.
+ virtual const std::vector<PictureLayerImpl*>& GetPictureLayers() const = 0;
+
+ // Called when all tiles marked as required for activation are ready to draw.
virtual void NotifyReadyToActivate() = 0;
+ // Called when the visible representation of a tile might have changed. Some
+ // examples are:
+ // - Tile version initialized.
+ // - Tile resources freed.
+ // - Tile marked for on-demand raster.
+ virtual void NotifyTileStateChanged(const Tile* tile) = 0;
+
+ // Given an empty raster tile priority queue, this will build a priority queue
+ // that will return tiles in order in which they should be rasterized.
+ // Note if the queue was previous built, Reset must be called on it.
+ virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
+ TreePriority tree_priority) = 0;
+
+ // Given an empty eviction tile priority queue, this will build a priority
+ // queue that will return tiles in order in which they should be evicted.
+ // Note if the queue was previous built, Reset must be called on it.
+ virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
+ TreePriority tree_priority) = 0;
+
protected:
virtual ~TileManagerClient() {}
};
size_t completed_count;
size_t canceled_count;
};
-scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
- const RasterTaskCompletionStats& stats);
+scoped_refptr<base::debug::ConvertableToTraceFormat>
+ RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
// This class manages tiles, deciding which should get rasterized and which
// should no longer have any memory assigned to them. Tile objects are "owned"
// by layers; they automatically register with the manager when they are
// created, and unregister from the manager when they are deleted.
-class CC_EXPORT TileManager : public RasterWorkerPoolClient,
+class CC_EXPORT TileManager : public RasterizerClient,
public RefCountedManager<Tile> {
public:
static scoped_ptr<TileManager> Create(
TileManagerClient* client,
- ResourceProvider* resource_provider,
- ContextProvider* context_provider,
- RenderingStatsInstrumentation* rendering_stats_instrumentation,
- bool use_map_image,
- bool use_rasterize_on_demand,
- size_t max_transfer_buffer_usage_bytes,
- size_t max_raster_usage_bytes,
- unsigned map_image_texture_target);
+ base::SequencedTaskRunner* task_runner,
+ ResourcePool* resource_pool,
+ Rasterizer* rasterizer,
+ RenderingStatsInstrumentation* rendering_stats_instrumentation);
virtual ~TileManager();
void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
int source_frame_number,
int flags);
- scoped_ptr<base::Value> BasicStateAsValue() const;
- scoped_ptr<base::Value> AllTilesAsValue() const;
- void GetMemoryStats(size_t* memory_required_bytes,
- size_t* memory_nice_to_have_bytes,
- size_t* memory_allocated_bytes,
- size_t* memory_used_bytes) const;
-
+ scoped_refptr<base::debug::ConvertableToTraceFormat> BasicStateAsValue()
+ const;
+ void BasicStateAsValueInto(base::debug::TracedValue* dict) const;
+ void AllTilesAsValueInto(base::debug::TracedValue* array) const;
const MemoryHistory::Entry& memory_stats_from_last_assign() const {
return memory_stats_from_last_assign_;
}
- void InitializeTilesWithResourcesForTesting(
- const std::vector<Tile*>& tiles,
- ResourceProvider* resource_provider) {
+ 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_NO_LCD_RASTER_MODE];
+ mts.tile_versions[HIGH_QUALITY_RASTER_MODE];
- tile_version.resource_ = resource_pool_->AcquireResource(gfx::Size(1, 1));
+ tile_version.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));
+ }
+ }
+ }
+
void SetGlobalStateForTesting(
const GlobalStateThatImpactsTilePriority& state) {
// Soft limit is used for resource pool such that
if (state != global_state_) {
global_state_ = state;
prioritized_tiles_dirty_ = true;
- resource_pool_->SetResourceUsageLimits(
- global_state_.soft_memory_limit_in_bytes,
- global_state_.unused_memory_limit_in_bytes,
- global_state_.num_resources_limit);
}
}
+ void SetRasterizerForTesting(Rasterizer* rasterizer);
+
+ void FreeResourcesAndCleanUpReleasedTilesForTesting() {
+ prioritized_tiles_.Clear();
+ FreeResourcesForReleasedTiles();
+ CleanUpReleasedTiles();
+ }
+
protected:
TileManager(TileManagerClient* client,
- ResourceProvider* resource_provider,
- ContextProvider* context_provider,
- scoped_ptr<RasterWorkerPool> raster_worker_pool,
- scoped_ptr<RasterWorkerPool> direct_raster_worker_pool,
- size_t max_raster_usage_bytes,
- RenderingStatsInstrumentation* rendering_stats_instrumentation,
- bool use_rasterize_on_demand);
+ base::SequencedTaskRunner* task_runner,
+ ResourcePool* resource_pool,
+ Rasterizer* rasterizer,
+ RenderingStatsInstrumentation* rendering_stats_instrumentation);
// Methods called by Tile
friend class Tile;
void DidChangeTilePriority(Tile* tile);
+ void FreeResourcesForReleasedTiles();
void CleanUpReleasedTiles();
// Overriden from RefCountedManager<Tile>:
virtual void Release(Tile* tile) OVERRIDE;
- // Overriden from RasterWorkerPoolClient:
+ // Overriden from RasterizerClient:
virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE;
virtual void DidFinishRunningTasks() OVERRIDE;
virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
private:
- enum RasterWorkerPoolType {
- RASTER_WORKER_POOL_TYPE_DEFAULT,
- RASTER_WORKER_POOL_TYPE_DIRECT,
- NUM_RASTER_WORKER_POOL_TYPES
- };
-
void OnImageDecodeTaskCompleted(int layer_id,
SkPixelRef* pixel_ref,
bool was_canceled);
inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
return Resource::MemorySizeBytes(tile->size(),
- raster_worker_pool_->GetResourceFormat());
+ resource_pool_->resource_format());
}
- RasterMode DetermineRasterMode(const Tile* tile) const;
void FreeResourceForTile(Tile* tile, RasterMode mode);
void FreeResourcesForTile(Tile* tile);
void FreeUnusedResourcesForTile(Tile* tile);
- RasterWorkerPool::Task CreateImageDecodeTask(Tile* tile,
- SkPixelRef* pixel_ref);
- RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
- scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
+ void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
+ scoped_refptr<ImageDecodeTask> CreateImageDecodeTask(Tile* tile,
+ SkPixelRef* pixel_ref);
+ scoped_refptr<RasterTask> CreateRasterTask(Tile* tile);
void UpdatePrioritizedTileSetIfNeeded();
+ bool IsReadyToActivate() const;
+ void CheckIfReadyToActivate();
+
TileManagerClient* client_;
- ContextProvider* context_provider_;
- scoped_ptr<ResourcePool> resource_pool_;
- scoped_ptr<RasterWorkerPool> raster_worker_pool_;
- scoped_ptr<RasterWorkerPool> direct_raster_worker_pool_;
- scoped_ptr<RasterWorkerPoolDelegate> raster_worker_pool_delegate_;
+ scoped_refptr<base::SequencedTaskRunner> task_runner_;
+ ResourcePool* resource_pool_;
+ Rasterizer* rasterizer_;
GlobalStateThatImpactsTilePriority global_state_;
typedef base::hash_map<Tile::Id, Tile*> TileMap;
bool all_tiles_that_need_to_be_rasterized_have_memory_;
bool all_tiles_required_for_activation_have_memory_;
- size_t memory_required_bytes_;
- size_t memory_nice_to_have_bytes_;
-
size_t bytes_releasable_;
size_t resources_releasable_;
- size_t max_raster_usage_bytes_;
bool ever_exceeded_memory_budget_;
MemoryHistory::Entry memory_stats_from_last_assign_;
bool did_initialize_visible_tile_;
bool did_check_for_completed_tasks_since_last_schedule_tasks_;
- typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap;
+ typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask> >
+ PixelRefTaskMap;
typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
LayerPixelRefTaskMap image_decode_tasks_;
std::vector<Tile*> released_tiles_;
- bool use_rasterize_on_demand_;
+ ResourceFormat resource_format_;
+
+ // Queue used when scheduling raster tasks.
+ RasterTaskQueue raster_queue_;
+
+ std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
- // Queues used when scheduling raster tasks.
- RasterWorkerPool::RasterTask::Queue
- raster_queue_[NUM_RASTER_WORKER_POOL_TYPES];
+ UniqueNotifier ready_to_activate_check_notifier_;
DISALLOW_COPY_AND_ASSIGN(TileManager);
};
projects / platform / framework / web / crosswalk.git / blobdiff