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_worker_pool.h" | 16 #include "cc/test/fake_tile_task_manager.h" |
17 | 17 |
18 namespace cc { | 18 namespace cc { |
19 | 19 |
20 namespace { | 20 namespace { |
21 | 21 |
22 class FakeTileTaskWorkerPoolImpl : public TileTaskWorkerPool, | 22 base::LazyInstance<FakeTileTaskManagerImpl> g_fake_tile_task_manager = |
23 public RasterBufferProvider { | |
24 public: | |
25 // Overridden from TileTaskWorkerPool: | |
26 void Shutdown() override {} | |
27 void ScheduleTasks(TaskGraph* graph) override { | |
28 for (const auto& node : graph->nodes) { | |
29 TileTask* task = static_cast<TileTask*>(node.task); | |
30 | |
31 task->WillSchedule(); | |
32 task->ScheduleOnOriginThread(this); | |
33 task->DidSchedule(); | |
34 | |
35 completed_tasks_.push_back(task); | |
36 } | |
37 } | |
38 void CheckForCompletedTasks() override { | |
39 for (TileTask::Vector::iterator it = completed_tasks_.begin(); | |
40 it != completed_tasks_.end(); ++it) { | |
41 TileTask* task = it->get(); | |
42 | |
43 task->WillComplete(); | |
44 task->CompleteOnOriginThread(this); | |
45 task->DidComplete(); | |
46 } | |
47 completed_tasks_.clear(); | |
48 } | |
49 ResourceFormat GetResourceFormat(bool must_support_alpha) const override { | |
50 return RGBA_8888; | |
51 } | |
52 bool GetResourceRequiresSwizzle(bool must_support_alpha) const override { | |
53 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); | |
54 } | |
55 RasterBufferProvider* AsRasterBufferProvider() override { return this; } | |
56 | |
57 // Overridden from RasterBufferProvider: | |
58 std::unique_ptr<RasterBuffer> AcquireBufferForRaster( | |
59 const Resource* resource, | |
60 uint64_t resource_content_id, | |
61 uint64_t previous_content_id) override { | |
62 return nullptr; | |
63 } | |
64 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {} | |
65 | |
66 private: | |
67 TileTask::Vector completed_tasks_; | |
68 }; | |
69 base::LazyInstance<FakeTileTaskWorkerPoolImpl> g_fake_tile_task_worker_pool = | |
70 LAZY_INSTANCE_INITIALIZER; | 23 LAZY_INSTANCE_INITIALIZER; |
71 | 24 |
72 } // namespace | 25 } // namespace |
73 | 26 |
74 FakeTileManager::FakeTileManager(TileManagerClient* client) | 27 FakeTileManager::FakeTileManager(TileManagerClient* client) |
75 : TileManager(client, | 28 : TileManager(client, |
76 base::ThreadTaskRunnerHandle::Get(), | 29 base::ThreadTaskRunnerHandle::Get(), |
77 std::numeric_limits<size_t>::max(), | 30 std::numeric_limits<size_t>::max(), |
78 false /* use_partial_raster */) { | 31 false /* use_partial_raster */) { |
79 SetResources(nullptr, g_fake_tile_task_worker_pool.Pointer(), | 32 SetResources( |
80 &image_decode_controller_, std::numeric_limits<size_t>::max(), | 33 nullptr, &image_decode_controller_, g_fake_tile_task_manager.Pointer(), |
81 false /* use_gpu_rasterization */); | 34 std::numeric_limits<size_t>::max(), false /* use_gpu_rasterization */); |
82 } | 35 } |
83 | 36 |
84 FakeTileManager::FakeTileManager(TileManagerClient* client, | 37 FakeTileManager::FakeTileManager(TileManagerClient* client, |
85 ResourcePool* resource_pool) | 38 ResourcePool* resource_pool) |
86 : TileManager(client, | 39 : TileManager(client, |
87 base::ThreadTaskRunnerHandle::Get(), | 40 base::ThreadTaskRunnerHandle::Get(), |
88 std::numeric_limits<size_t>::max(), | 41 std::numeric_limits<size_t>::max(), |
89 false /* use_partial_raster */) { | 42 false /* use_partial_raster */) { |
90 SetResources(resource_pool, g_fake_tile_task_worker_pool.Pointer(), | 43 SetResources(resource_pool, &image_decode_controller_, |
91 &image_decode_controller_, std::numeric_limits<size_t>::max(), | 44 g_fake_tile_task_manager.Pointer(), |
| 45 std::numeric_limits<size_t>::max(), |
92 false /* use_gpu_rasterization */); | 46 false /* use_gpu_rasterization */); |
93 } | 47 } |
94 | 48 |
95 FakeTileManager::~FakeTileManager() {} | 49 FakeTileManager::~FakeTileManager() {} |
96 | 50 |
97 bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) { | 51 bool FakeTileManager::HasBeenAssignedMemory(Tile* tile) { |
98 return std::find(tiles_for_raster.begin(), | 52 return std::find(tiles_for_raster.begin(), |
99 tiles_for_raster.end(), | 53 tiles_for_raster.end(), |
100 tile) != tiles_for_raster.end(); | 54 tile) != tiles_for_raster.end(); |
101 } | 55 } |
102 | 56 |
103 void FakeTileManager::Release(Tile* tile) { | 57 void FakeTileManager::Release(Tile* tile) { |
104 TileManager::Release(tile); | 58 TileManager::Release(tile); |
105 | 59 |
106 FreeResourcesForReleasedTiles(); | 60 FreeResourcesForReleasedTiles(); |
107 CleanUpReleasedTiles(); | 61 CleanUpReleasedTiles(); |
108 } | 62 } |
109 | 63 |
110 } // namespace cc | 64 } // namespace cc |
OLD | NEW |