src/cc/test/fake_tile_manager.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/test/fake_tile_manager.h"
   6
   7 #include <deque>
   8 #include <limits>
   9
  10 #include "cc/resources/raster_worker_pool.h"
  11
  12 namespace cc {
  13
  14 namespace {
  15
  16 class FakeRasterWorkerPool : public RasterWorkerPool {
  17  public:
  18   FakeRasterWorkerPool() : RasterWorkerPool(NULL, NULL) {}
  19
  20   // Overridden from RasterWorkerPool:
  21   virtual void ScheduleTasks(RasterTask::Queue* queue) OVERRIDE {
  22     for (RasterTaskQueueIterator it(queue); it; ++it) {
  23       internal::RasterWorkerPoolTask* task = *it;
  24
  25       task->DidSchedule();
  26
  27       completed_tasks_.push_back(task);
  28     }
  29   }
  30   virtual void CheckForCompletedTasks() OVERRIDE {
  31     while (!completed_tasks_.empty()) {
  32       internal::WorkerPoolTask* task = completed_tasks_.front().get();
  33
  34       task->WillComplete();
  35       task->DidComplete();
  36       task->RunReplyOnOriginThread();
  37
  38       completed_tasks_.pop_front();
  39     }
  40   }
  41   virtual GLenum GetResourceTarget() const OVERRIDE {
  42     return GL_TEXTURE_2D;
  43   }
  44   virtual ResourceFormat GetResourceFormat() const OVERRIDE {
  45     return RGBA_8888;
  46   }
  47
  48   // Overridden from internal::WorkerPoolTaskClient:
  49   virtual SkCanvas* AcquireCanvasForRaster(internal::RasterWorkerPoolTask* task)
  50       OVERRIDE {
  51     return NULL;
  52   }
  53   virtual void OnRasterCompleted(internal::RasterWorkerPoolTask* task,
  54                                  const PicturePileImpl::Analysis& analysis)
  55       OVERRIDE {}
  56   virtual void OnImageDecodeCompleted(internal::WorkerPoolTask* task) OVERRIDE {
  57   }
  58
  59  private:
  60   // Overridden from RasterWorkerPool:
  61   virtual void OnRasterTasksFinished() OVERRIDE {}
  62   virtual void OnRasterTasksRequiredForActivationFinished() OVERRIDE {}
  63
  64   TaskDeque completed_tasks_;
  65 };
  66
  67 }  // namespace
  68
  69 FakeTileManager::FakeTileManager(TileManagerClient* client)
  70     : TileManager(client,
  71                   NULL,
  72                   NULL,
  73                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  74                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  75                   std::numeric_limits<unsigned>::max(),
  76                   NULL,
  77                   true) {}
  78
  79 FakeTileManager::FakeTileManager(TileManagerClient* client,
  80                                  ResourceProvider* resource_provider)
  81     : TileManager(client,
  82                   resource_provider,
  83                   NULL,
  84                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  85                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  86                   std::numeric_limits<unsigned>::max(),
  87                   NULL,
  88                   true) {}
  89
  90 FakeTileManager::FakeTileManager(TileManagerClient* client,
  91                                  ResourceProvider* resource_provider,
  92                                  bool allow_on_demand_raster)
  93     : TileManager(client,
  94                   resource_provider,
  95                   NULL,
  96                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  97                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
  98                   std::numeric_limits<unsigned>::max(),
  99                   NULL,
 100                   allow_on_demand_raster) {}
 101
 102 FakeTileManager::FakeTileManager(TileManagerClient* client,
 103                                  ResourceProvider* resource_provider,
 104                                  size_t raster_task_limit_bytes)
 105     : TileManager(client,
 106                   resource_provider,
 107                   NULL,
 108                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
 109                   make_scoped_ptr<RasterWorkerPool>(new FakeRasterWorkerPool),
 110                   raster_task_limit_bytes,
 111                   NULL,
 112                   true) {}
 113
 114 FakeTileManager::~FakeTileManager() {}
 115
 116 void FakeTileManager::AssignMemoryToTiles(
 117     const GlobalStateThatImpactsTilePriority& state) {
 118   tiles_for_raster.clear();
 119   all_tiles.Clear();
 120
 121   SetGlobalStateForTesting(state);
 122   GetTilesWithAssignedBins(&all_tiles);
 123   AssignGpuMemoryToTiles(&all_tiles, &tiles_for_raster);
 124 }
 125
 126 bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) {
 127   return std::find(tiles_for_raster.begin(),
 128                    tiles_for_raster.end(),
 129                    tile) != tiles_for_raster.end();
 130 }
 131
 132 void FakeTileManager::DidFinishRunningTasksForTesting() {
 133   DidFinishRunningTasks();
 134 }
 135
 136 void FakeTileManager::Release(Tile* tile) {
 137   TileManager::Release(tile);
 138   CleanUpReleasedTiles();
 139 }
 140
 141 }  // namespace cc