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_runner.h" |
17 | 17 |
18 namespace cc { | 18 namespace cc { |
19 | 19 |
20 namespace { | 20 namespace { |
21 | 21 |
22 class FakeTileTaskRunnerImpl : public TileTaskRunner, | 22 class FakeTileTaskRunnerImpl : public TileTaskRunner, |
23 public RasterBufferProvider { | 23 public RasterBufferProvider { |
24 public: | 24 public: |
25 // Overridden from TileTaskRunner: | 25 // Overridden from TileTaskRunner: |
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 RasterTask* task = static_cast<RasterTask*>(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); |
36 } | 36 } |
37 } | 37 } |
38 void CheckForCompletedTasks() override { | 38 void CheckForCompletedTasks() override { |
39 for (RasterTask::Vector::iterator it = completed_tasks_.begin(); | 39 for (TileTask::Vector::iterator it = completed_tasks_.begin(); |
40 it != completed_tasks_.end(); | 40 it != completed_tasks_.end(); ++it) { |
41 ++it) { | 41 TileTask* task = it->get(); |
42 RasterTask* task = it->get(); | |
43 | 42 |
44 task->WillComplete(); | 43 task->WillComplete(); |
45 task->CompleteOnOriginThread(this); | 44 task->CompleteOnOriginThread(this); |
46 task->DidComplete(); | 45 task->DidComplete(); |
47 } | 46 } |
48 completed_tasks_.clear(); | 47 completed_tasks_.clear(); |
49 } | 48 } |
50 ResourceFormat GetResourceFormat(bool must_support_alpha) const override { | 49 ResourceFormat GetResourceFormat(bool must_support_alpha) const override { |
51 return RGBA_8888; | 50 return RGBA_8888; |
52 } | 51 } |
53 bool GetResourceRequiresSwizzle(bool must_support_alpha) const override { | 52 bool GetResourceRequiresSwizzle(bool must_support_alpha) const override { |
54 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); | 53 return ResourceFormatRequiresSwizzle(GetResourceFormat(must_support_alpha)); |
55 } | 54 } |
56 RasterBufferProvider* AsRasterBufferProvider() override { return this; } | 55 RasterBufferProvider* AsRasterBufferProvider() override { return this; } |
57 | 56 |
58 // Overridden from RasterBufferProvider: | 57 // Overridden from RasterBufferProvider: |
59 std::unique_ptr<RasterBuffer> AcquireBufferForRaster( | 58 std::unique_ptr<RasterBuffer> AcquireBufferForRaster( |
60 const Resource* resource, | 59 const Resource* resource, |
61 uint64_t resource_content_id, | 60 uint64_t resource_content_id, |
62 uint64_t previous_content_id) override { | 61 uint64_t previous_content_id) override { |
63 return nullptr; | 62 return nullptr; |
64 } | 63 } |
65 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {} | 64 void ReleaseBufferForRaster(std::unique_ptr<RasterBuffer> buffer) override {} |
66 | 65 |
67 private: | 66 private: |
68 RasterTask::Vector completed_tasks_; | 67 TileTask::Vector completed_tasks_; |
69 }; | 68 }; |
70 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner = | 69 base::LazyInstance<FakeTileTaskRunnerImpl> g_fake_tile_task_runner = |
71 LAZY_INSTANCE_INITIALIZER; | 70 LAZY_INSTANCE_INITIALIZER; |
72 | 71 |
73 } // namespace | 72 } // namespace |
74 | 73 |
75 FakeTileManager::FakeTileManager(TileManagerClient* client) | 74 FakeTileManager::FakeTileManager(TileManagerClient* client) |
76 : TileManager(client, | 75 : TileManager(client, |
77 base::ThreadTaskRunnerHandle::Get(), | 76 base::ThreadTaskRunnerHandle::Get(), |
78 std::numeric_limits<size_t>::max(), | 77 std::numeric_limits<size_t>::max(), |
(...skipping 23 matching lines...) Expand all Loading... |
102 } | 101 } |
103 | 102 |
104 void FakeTileManager::Release(Tile* tile) { | 103 void FakeTileManager::Release(Tile* tile) { |
105 TileManager::Release(tile); | 104 TileManager::Release(tile); |
106 | 105 |
107 FreeResourcesForReleasedTiles(); | 106 FreeResourcesForReleasedTiles(); |
108 CleanUpReleasedTiles(); | 107 CleanUpReleasedTiles(); |
109 } | 108 } |
110 | 109 |
111 } // namespace cc | 110 } // namespace cc |
OLD | NEW |