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" | |
16 #include "cc/raster/tile_task_runner.h" | 15 #include "cc/raster/tile_task_runner.h" |
17 | 16 |
18 namespace cc { | 17 namespace cc { |
19 | 18 |
20 namespace { | 19 namespace { |
21 | 20 |
22 class FakeTileTaskRunnerImpl : public TileTaskRunner, public TileTaskClient { | 21 class FakeTileTaskRunnerImpl : public TileTaskRunner { |
23 public: | 22 public: |
| 23 // Overridden from RasterBufferProvider: |
| 24 scoped_ptr<RasterBuffer> AcquireBufferForRaster( |
| 25 const Resource* resource, |
| 26 uint64_t resource_content_id, |
| 27 uint64_t previous_content_id) override { |
| 28 return nullptr; |
| 29 } |
| 30 void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override {} |
| 31 |
24 // Overridden from TileTaskRunner: | 32 // Overridden from TileTaskRunner: |
25 void Shutdown() override {} | 33 void Shutdown() override {} |
26 void ScheduleTasks(TaskGraph* graph) override { | 34 void ScheduleTasks(TaskGraph* graph) override { |
27 for (const auto& node : graph->nodes) { | 35 for (const auto& node : graph->nodes) { |
28 RasterTask* task = static_cast<RasterTask*>(node.task); | 36 Task* task = node.task; |
29 | 37 |
30 task->WillSchedule(); | 38 task->WillSchedule(); |
31 task->ScheduleOnOriginThread(this); | 39 task->ScheduleOnOriginThread(); |
32 task->DidSchedule(); | 40 task->DidSchedule(); |
33 | 41 |
34 completed_tasks_.push_back(task); | 42 completed_tasks_.push_back(task); |
35 } | 43 } |
36 } | 44 } |
37 void CheckForCompletedTasks() override { | 45 void CheckForCompletedTasks() override { |
38 for (RasterTask::Vector::iterator it = completed_tasks_.begin(); | 46 for (Task::Vector::iterator it = completed_tasks_.begin(); |
39 it != completed_tasks_.end(); | 47 it != completed_tasks_.end(); ++it) { |
40 ++it) { | 48 Task* task = it->get(); |
41 RasterTask* task = it->get(); | |
42 | 49 |
43 task->WillComplete(); | 50 task->WillComplete(); |
44 task->CompleteOnOriginThread(this); | 51 task->CompleteOnOriginThread(); |
45 task->DidComplete(); | 52 task->DidComplete(); |
46 } | 53 } |
47 completed_tasks_.clear(); | 54 completed_tasks_.clear(); |
48 } | 55 } |
49 ResourceFormat GetResourceFormat(bool must_support_alpha) const override { | 56 ResourceFormat GetResourceFormat(bool must_support_alpha) const override { |
50 return RGBA_8888; | 57 return RGBA_8888; |
51 } | 58 } |
52 bool GetResourceRequiresSwizzle(bool must_support_alpha) const override { | 59 bool GetResourceRequiresSwizzle(bool must_support_alpha) const override { |
53 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); | 60 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); |
54 } | 61 } |
55 | 62 |
56 // Overridden from TileTaskClient: | |
57 scoped_ptr<RasterBuffer> AcquireBufferForRaster( | |
58 const Resource* resource, | |
59 uint64_t resource_content_id, | |
60 uint64_t previous_content_id) override { | |
61 return nullptr; | |
62 } | |
63 void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override {} | |
64 | |
65 private: | 63 private: |
66 RasterTask::Vector completed_tasks_; | 64 Task::Vector completed_tasks_; |
67 }; | 65 }; |
68 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner = | 66 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner = |
69 LAZY_INSTANCE_INITIALIZER; | 67 LAZY_INSTANCE_INITIALIZER; |
70 | 68 |
71 } // namespace | 69 } // namespace |
72 | 70 |
73 FakeTileManager::FakeTileManager(TileManagerClient* client) | 71 FakeTileManager::FakeTileManager(TileManagerClient* client) |
74 : TileManager(client, | 72 : TileManager(client, |
75 base::ThreadTaskRunnerHandle::Get(), | 73 base::ThreadTaskRunnerHandle::Get(), |
76 std::numeric_limits<size_t>::max(), | 74 std::numeric_limits<size_t>::max(), |
(...skipping 23 matching lines...) Expand all Loading... |
100 } | 98 } |
101 | 99 |
102 void FakeTileManager::Release(Tile* tile) { | 100 void FakeTileManager::Release(Tile* tile) { |
103 TileManager::Release(tile); | 101 TileManager::Release(tile); |
104 | 102 |
105 FreeResourcesForReleasedTiles(); | 103 FreeResourcesForReleasedTiles(); |
106 CleanUpReleasedTiles(); | 104 CleanUpReleasedTiles(); |
107 } | 105 } |
108 | 106 |
109 } // namespace cc | 107 } // namespace cc |
OLD | NEW |