OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/test/fake_tile_manager.h" | 5 #include "cc/test/fake_tile_manager.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <deque> | 10 #include <deque> |
11 #include <limits> | 11 #include <limits> |
12 | 12 |
13 #include "base/lazy_instance.h" | 13 #include "base/lazy_instance.h" |
14 #include "base/thread_task_runner_handle.h" | 14 #include "base/thread_task_runner_handle.h" |
15 #include "cc/raster/raster_buffer.h" | 15 #include "cc/raster/raster_buffer.h" |
16 #include "cc/raster/tile_task_runner.h" | 16 #include "cc/raster/tile_task_worker_pool.h" |
17 | 17 |
18 namespace cc { | 18 namespace cc { |
19 | 19 |
20 namespace { | 20 namespace { |
21 | 21 |
22 class FakeTileTaskRunnerImpl : public TileTaskRunner, | 22 class FakeTileTaskWorkerPoolImpl : public TileTaskWorkerPool, |
23 public RasterBufferProvider { | 23 public RasterBufferProvider { |
24 public: | 24 public: |
25 // Overridden from TileTaskRunner: | 25 // Overridden from TileTaskWorkerPool: |
26 void Shutdown() override {} | 26 void Shutdown() override {} |
27 void ScheduleTasks(TaskGraph* graph) override { | 27 void ScheduleTasks(TaskGraph* graph) override { |
28 for (const auto& node : graph->nodes) { | 28 for (const auto& node : graph->nodes) { |
29 TileTask* task = static_cast<TileTask*>(node.task); | 29 TileTask* task = static_cast<TileTask*>(node.task); |
30 | 30 |
31 task->WillSchedule(); | 31 task->WillSchedule(); |
32 task->ScheduleOnOriginThread(this); | 32 task->ScheduleOnOriginThread(this); |
33 task->DidSchedule(); | 33 task->DidSchedule(); |
34 | 34 |
35 completed_tasks_.push_back(task); | 35 completed_tasks_.push_back(task); |
(...skipping 23 matching lines...) Expand all Loading... |
59 const Resource* resource, | 59 const Resource* resource, |
60 uint64_t resource_content_id, | 60 uint64_t resource_content_id, |
61 uint64_t previous_content_id) override { | 61 uint64_t previous_content_id) override { |
62 return nullptr; | 62 return nullptr; |
63 } | 63 } |
64 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {} | 64 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {} |
65 | 65 |
66 private: | 66 private: |
67 TileTask::Vector completed_tasks_; | 67 TileTask::Vector completed_tasks_; |
68 }; | 68 }; |
69 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner = | 69 base::LazyInstance<FakeTileTaskWorkerPoolImpl> g_fake_tile_task_worker_pool = |
70 LAZY_INSTANCE_INITIALIZER; | 70 LAZY_INSTANCE_INITIALIZER; |
71 | 71 |
72 } // namespace | 72 } // namespace |
73 | 73 |
74 FakeTileManager::FakeTileManager(TileManagerClient* client) | 74 FakeTileManager::FakeTileManager(TileManagerClient* client) |
75 : TileManager(client, | 75 : TileManager(client, |
76 base::ThreadTaskRunnerHandle::Get(), | 76 base::ThreadTaskRunnerHandle::Get(), |
77 std::numeric_limits<size_t>::max(), | 77 std::numeric_limits<size_t>::max(), |
78 false /* use_partial_raster */) { | 78 false /* use_partial_raster */) { |
79 SetResources(nullptr, g_fake_tile_task_runner.Pointer(), | 79 SetResources(nullptr, g_fake_tile_task_worker_pool.Pointer(), |
80 &image_decode_controller_, std::numeric_limits<size_t>::max(), | 80 &image_decode_controller_, std::numeric_limits<size_t>::max(), |
81 false /* use_gpu_rasterization */); | 81 false /* use_gpu_rasterization */); |
82 } | 82 } |
83 | 83 |
84 FakeTileManager::FakeTileManager(TileManagerClient* client, | 84 FakeTileManager::FakeTileManager(TileManagerClient* client, |
85 ResourcePool* resource_pool) | 85 ResourcePool* resource_pool) |
86 : TileManager(client, | 86 : TileManager(client, |
87 base::ThreadTaskRunnerHandle::Get(), | 87 base::ThreadTaskRunnerHandle::Get(), |
88 std::numeric_limits<size_t>::max(), | 88 std::numeric_limits<size_t>::max(), |
89 false /* use_partial_raster */) { | 89 false /* use_partial_raster */) { |
90 SetResources(resource_pool, g_fake_tile_task_runner.Pointer(), | 90 SetResources(resource_pool, g_fake_tile_task_worker_pool.Pointer(), |
91 &image_decode_controller_, std::numeric_limits<size_t>::max(), | 91 &image_decode_controller_, std::numeric_limits<size_t>::max(), |
92 false /* use_gpu_rasterization */); | 92 false /* use_gpu_rasterization */); |
93 } | 93 } |
94 | 94 |
95 FakeTileManager::~FakeTileManager() {} | 95 FakeTileManager::~FakeTileManager() {} |
96 | 96 |
97 bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) { | 97 bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) { |
98 return std::find(tiles_for_raster.begin(), | 98 return std::find(tiles_for_raster.begin(), |
99 tiles_for_raster.end(), | 99 tiles_for_raster.end(), |
100 tile) != tiles_for_raster.end(); | 100 tile) != tiles_for_raster.end(); |
101 } | 101 } |
102 | 102 |
103 void FakeTileManager::Release(Tile* tile) { | 103 void FakeTileManager::Release(Tile* tile) { |
104 TileManager::Release(tile); | 104 TileManager::Release(tile); |
105 | 105 |
106 FreeResourcesForReleasedTiles(); | 106 FreeResourcesForReleasedTiles(); |
107 CleanUpReleasedTiles(); | 107 CleanUpReleasedTiles(); |
108 } | 108 } |
109 | 109 |
110 } // namespace cc | 110 } // namespace cc |
OLD | NEW |