#include "cc/test/fake_tile_manager.h"
#include <deque>
-#include <limits>
-#include "cc/resources/raster_worker_pool.h"
+#include "base/lazy_instance.h"
+#include "cc/resources/rasterizer.h"
namespace cc {
namespace {
-class FakeRasterWorkerPool : public RasterWorkerPool {
+class FakeRasterizerImpl : public Rasterizer, public RasterizerTaskClient {
public:
- FakeRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}
-
- virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE {
- RasterWorkerPool::SetRasterTasks(queue);
- for (RasterTaskVector::const_iterator it = raster_tasks().begin();
- it != raster_tasks().end(); ++it) {
- completed_tasks_.push_back(it->get());
+ // Overridden from Rasterizer:
+ virtual void SetClient(RasterizerClient* client) OVERRIDE {}
+ virtual void Shutdown() OVERRIDE {}
+ virtual void ScheduleTasks(RasterTaskQueue* queue) OVERRIDE {
+ for (RasterTaskQueue::Item::Vector::const_iterator it =
+ queue->items.begin();
+ it != queue->items.end();
+ ++it) {
+ RasterTask* task = it->task;
+
+ task->WillSchedule();
+ task->ScheduleOnOriginThread(this);
+ task->DidSchedule();
+
+ completed_tasks_.push_back(task);
}
}
virtual void CheckForCompletedTasks() OVERRIDE {
- while (!completed_tasks_.empty()) {
- internal::RasterWorkerPoolTask* task = completed_tasks_.front().get();
+ for (RasterTask::Vector::iterator it = completed_tasks_.begin();
+ it != completed_tasks_.end();
+ ++it) {
+ RasterTask* task = it->get();
+
task->WillComplete();
- task->CompleteOnOriginThread();
+ task->CompleteOnOriginThread(this);
task->DidComplete();
- completed_tasks_.pop_front();
+
+ task->RunReplyOnOriginThread();
}
+ completed_tasks_.clear();
}
- virtual GLenum GetResourceTarget() const OVERRIDE {
- return GL_TEXTURE_2D;
- }
- virtual ResourceFormat GetResourceFormat() const OVERRIDE {
- return RGBA_8888;
+
+ // Overridden from RasterizerTaskClient:
+ virtual SkCanvas* AcquireCanvasForRaster(RasterTask* task) OVERRIDE {
+ return NULL;
}
- virtual void OnRasterTasksFinished() OVERRIDE {}
- virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE {}
+ virtual void ReleaseCanvasForRaster(RasterTask* task) OVERRIDE {}
private:
- typedef std::deque<scoped_refptr<internal::RasterWorkerPoolTask> > TaskDeque;
- TaskDeque completed_tasks_;
+ RasterTask::Vector completed_tasks_;
};
+base::LazyInstance<FakeRasterizerImpl> g_fake_rasterizer =
+ LAZY_INSTANCE_INITIALIZER;
} // namespace
FakeTileManager::FakeTileManager(TileManagerClient* client)
: TileManager(client,
+ base::MessageLoopProxy::current(),
NULL,
- make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
- std::numeric_limits<unsigned>::max(),
+ g_fake_rasterizer.Pointer(),
NULL) {}
FakeTileManager::FakeTileManager(TileManagerClient* client,
- ResourceProvider* resource_provider)
+ ResourcePool* resource_pool)
: TileManager(client,
- resource_provider,
- make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
- std::numeric_limits<unsigned>::max(),
+ base::MessageLoopProxy::current(),
+ resource_pool,
+ g_fake_rasterizer.Pointer(),
NULL) {}
-FakeTileManager::FakeTileManager(TileManagerClient* client,
- ResourceProvider* resource_provider,
- size_t raster_task_limit_bytes)
- : TileManager(client,
- resource_provider,
- make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
- raster_task_limit_bytes,
- NULL) {}
-
-FakeTileManager::~FakeTileManager() {
- RasterWorkerPoolForTesting()->Shutdown();
- RasterWorkerPoolForTesting()->CheckForCompletedTasks();
-}
+FakeTileManager::~FakeTileManager() {}
void FakeTileManager::AssignMemoryToTiles(
const GlobalStateThatImpactsTilePriority& state) {
tile) != tiles_for_raster.end();
}
-void FakeTileManager::CheckForCompletedTasks() {
- RasterWorkerPoolForTesting()->CheckForCompletedTasks();
+void FakeTileManager::DidFinishRunningTasksForTesting() {
+ DidFinishRunningTasks();
}
void FakeTileManager::Release(Tile* tile) {
TileManager::Release(tile);
+
+ FreeResourcesForReleasedTiles();
CleanUpReleasedTiles();
}