OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/raster/tile_task_worker_pool.h" | 5 #include "cc/raster/tile_task_worker_pool.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
11 #include <limits> | 11 #include <limits> |
12 #include <vector> | 12 #include <vector> |
13 | 13 |
14 #include "base/cancelable_callback.h" | 14 #include "base/cancelable_callback.h" |
15 #include "base/location.h" | 15 #include "base/location.h" |
16 #include "base/macros.h" | 16 #include "base/macros.h" |
17 #include "base/single_thread_task_runner.h" | 17 #include "base/single_thread_task_runner.h" |
18 #include "base/thread_task_runner_handle.h" | 18 #include "base/thread_task_runner_handle.h" |
19 #include "cc/base/unique_notifier.h" | 19 #include "cc/base/unique_notifier.h" |
20 #include "cc/raster/bitmap_tile_task_worker_pool.h" | 20 #include "cc/raster/bitmap_tile_task_worker_pool.h" |
21 #include "cc/raster/gpu_rasterizer.h" | 21 #include "cc/raster/gpu_rasterizer.h" |
22 #include "cc/raster/gpu_tile_task_worker_pool.h" | 22 #include "cc/raster/gpu_tile_task_worker_pool.h" |
23 #include "cc/raster/one_copy_tile_task_worker_pool.h" | 23 #include "cc/raster/one_copy_tile_task_worker_pool.h" |
24 #include "cc/raster/raster_buffer.h" | |
25 #include "cc/raster/synchronous_task_graph_runner.h" | 24 #include "cc/raster/synchronous_task_graph_runner.h" |
26 #include "cc/raster/tile_task_runner.h" | 25 #include "cc/raster/tile_task_runner.h" |
27 #include "cc/raster/zero_copy_tile_task_worker_pool.h" | 26 #include "cc/raster/zero_copy_tile_task_worker_pool.h" |
28 #include "cc/resources/resource_pool.h" | 27 #include "cc/resources/resource_pool.h" |
29 #include "cc/resources/resource_provider.h" | 28 #include "cc/resources/resource_provider.h" |
30 #include "cc/resources/scoped_resource.h" | 29 #include "cc/resources/scoped_resource.h" |
31 #include "cc/test/fake_output_surface.h" | 30 #include "cc/test/fake_output_surface.h" |
32 #include "cc/test/fake_output_surface_client.h" | 31 #include "cc/test/fake_output_surface_client.h" |
33 #include "cc/test/fake_raster_source.h" | 32 #include "cc/test/fake_raster_source.h" |
34 #include "cc/test/fake_resource_provider.h" | 33 #include "cc/test/fake_resource_provider.h" |
35 #include "cc/test/test_gpu_memory_buffer_manager.h" | 34 #include "cc/test/test_gpu_memory_buffer_manager.h" |
36 #include "cc/test/test_shared_bitmap_manager.h" | 35 #include "cc/test/test_shared_bitmap_manager.h" |
37 #include "cc/test/test_web_graphics_context_3d.h" | 36 #include "cc/test/test_web_graphics_context_3d.h" |
38 #include "gpu/GLES2/gl2extchromium.h" | 37 #include "gpu/GLES2/gl2extchromium.h" |
39 #include "testing/gtest/include/gtest/gtest.h" | 38 #include "testing/gtest/include/gtest/gtest.h" |
40 | 39 |
41 namespace cc { | 40 namespace cc { |
42 namespace { | 41 namespace { |
43 | 42 |
44 const size_t kMaxBytesPerCopyOperation = 1000U; | 43 const size_t kMaxBytesPerCopyOperation = 1000U; |
45 const size_t kMaxStagingBuffers = 32U; | 44 const size_t kMaxStagingBuffers = 32U; |
46 | 45 |
47 enum TileTaskWorkerPoolType { | 46 enum TileTaskWorkerPoolType { |
48 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 47 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
49 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 48 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
50 TILE_TASK_WORKER_POOL_TYPE_GPU, | 49 TILE_TASK_WORKER_POOL_TYPE_GPU, |
51 TILE_TASK_WORKER_POOL_TYPE_BITMAP | 50 TILE_TASK_WORKER_POOL_TYPE_BITMAP |
52 }; | 51 }; |
53 | 52 |
54 class TestRasterTaskImpl : public RasterTask { | 53 class TestRasterTaskImpl : public Task { |
55 public: | 54 public: |
56 typedef base::Callback<void(bool was_canceled)> Reply; | 55 typedef base::Callback<void(bool was_canceled)> Reply; |
57 | 56 |
58 TestRasterTaskImpl(const Resource* resource, | 57 TestRasterTaskImpl(RasterBufferProvider* raster_buffer_provider, |
59 const Reply& reply, | 58 const Resource* resource, |
60 ImageDecodeTask::Vector* dependencies) | 59 const Reply& reply) |
61 : RasterTask(dependencies), | 60 : raster_buffer_provider_(raster_buffer_provider), |
62 resource_(resource), | 61 resource_(resource), |
63 reply_(reply), | 62 reply_(reply), |
64 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} | 63 raster_source_(FakeRasterSource::CreateFilled(gfx::Size(1, 1))) {} |
65 | 64 |
66 // Overridden from Task: | 65 // Overridden from Task: |
| 66 void ScheduleOnOriginThread() override { |
| 67 // The raster buffer has no tile ids associated with it for partial update, |
| 68 // so doesn't need to provide a valid dirty rect. |
| 69 raster_buffer_ = |
| 70 raster_buffer_provider_->AcquireBufferForRaster(resource_, 0, 0); |
| 71 } |
| 72 void CompleteOnOriginThread() override { |
| 73 raster_buffer_provider_->ReleaseBufferForRaster(std::move(raster_buffer_)); |
| 74 reply_.Run(!HasFinishedRunning()); |
| 75 } |
67 void RunOnWorkerThread() override { | 76 void RunOnWorkerThread() override { |
68 uint64_t new_content_id = 0; | 77 uint64_t new_content_id = 0; |
69 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), | 78 raster_buffer_->Playback(raster_source_.get(), gfx::Rect(1, 1), |
70 gfx::Rect(1, 1), new_content_id, 1.f, | 79 gfx::Rect(1, 1), new_content_id, 1.f, |
71 RasterSource::PlaybackSettings()); | 80 RasterSource::PlaybackSettings()); |
72 } | 81 } |
73 | 82 |
74 // Overridden from TileTask: | |
75 void ScheduleOnOriginThread(TileTaskClient* client) override { | |
76 // The raster buffer has no tile ids associated with it for partial update, | |
77 // so doesn't need to provide a valid dirty rect. | |
78 raster_buffer_ = client->AcquireBufferForRaster(resource_, 0, 0); | |
79 } | |
80 void CompleteOnOriginThread(TileTaskClient* client) override { | |
81 client->ReleaseBufferForRaster(std::move(raster_buffer_)); | |
82 reply_.Run(!HasFinishedRunning()); | |
83 } | |
84 | |
85 protected: | 83 protected: |
86 ~TestRasterTaskImpl() override {} | 84 ~TestRasterTaskImpl() override {} |
87 | 85 |
88 private: | 86 private: |
| 87 RasterBufferProvider* raster_buffer_provider_; |
89 const Resource* resource_; | 88 const Resource* resource_; |
90 const Reply reply_; | 89 const Reply reply_; |
91 scoped_ptr<RasterBuffer> raster_buffer_; | 90 scoped_ptr<RasterBuffer> raster_buffer_; |
92 scoped_refptr<RasterSource> raster_source_; | 91 scoped_refptr<RasterSource> raster_source_; |
93 | 92 |
94 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); | 93 DISALLOW_COPY_AND_ASSIGN(TestRasterTaskImpl); |
95 }; | 94 }; |
96 | 95 |
97 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { | 96 class BlockingTestRasterTaskImpl : public TestRasterTaskImpl { |
98 public: | 97 public: |
99 BlockingTestRasterTaskImpl(const Resource* resource, | 98 BlockingTestRasterTaskImpl(RasterBufferProvider* raster_buffer_provider, |
| 99 const Resource* resource, |
100 const Reply& reply, | 100 const Reply& reply, |
101 base::Lock* lock, | 101 base::Lock* lock) |
102 ImageDecodeTask::Vector* dependencies) | 102 : TestRasterTaskImpl(raster_buffer_provider, resource, reply), |
103 : TestRasterTaskImpl(resource, reply, dependencies), lock_(lock) {} | 103 lock_(lock) {} |
104 | 104 |
105 // Overridden from Task: | 105 // Overridden from Task: |
106 void RunOnWorkerThread() override { | 106 void RunOnWorkerThread() override { |
107 base::AutoLock lock(*lock_); | 107 base::AutoLock lock(*lock_); |
108 TestRasterTaskImpl::RunOnWorkerThread(); | 108 TestRasterTaskImpl::RunOnWorkerThread(); |
109 } | 109 } |
110 | 110 |
111 protected: | 111 protected: |
112 ~BlockingTestRasterTaskImpl() override {} | 112 ~BlockingTestRasterTaskImpl() override {} |
113 | 113 |
114 private: | 114 private: |
115 base::Lock* lock_; | 115 base::Lock* lock_; |
116 | 116 |
117 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); | 117 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); |
118 }; | 118 }; |
119 | 119 |
120 class TileTaskWorkerPoolTest | 120 class TileTaskWorkerPoolTest |
121 : public testing::TestWithParam<TileTaskWorkerPoolType> { | 121 : public testing::TestWithParam<TileTaskWorkerPoolType> { |
122 public: | 122 public: |
123 struct RasterTaskResult { | 123 struct RasterTaskResult { |
124 unsigned id; | 124 unsigned id; |
125 bool canceled; | 125 bool canceled; |
126 }; | 126 }; |
127 | 127 |
128 typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector; | 128 typedef std::vector<scoped_refptr<Task>> RasterTaskVector; |
129 | 129 |
130 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | 130 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; |
131 | 131 |
132 TileTaskWorkerPoolTest() | 132 TileTaskWorkerPoolTest() |
133 : context_provider_(TestContextProvider::Create()), | 133 : context_provider_(TestContextProvider::Create()), |
134 worker_context_provider_(TestContextProvider::CreateWorker()), | 134 worker_context_provider_(TestContextProvider::CreateWorker()), |
135 all_tile_tasks_finished_( | 135 all_tile_tasks_finished_( |
136 base::ThreadTaskRunnerHandle::Get() | 136 base::ThreadTaskRunnerHandle::Get() |
137 .get(), | 137 .get(), |
138 base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished, | 138 base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished, |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
203 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph_); | 203 tile_task_worker_pool_->AsTileTaskRunner()->ScheduleTasks(&graph_); |
204 } | 204 } |
205 | 205 |
206 void AppendTask(unsigned id, const gfx::Size& size) { | 206 void AppendTask(unsigned id, const gfx::Size& size) { |
207 scoped_ptr<ScopedResource> resource( | 207 scoped_ptr<ScopedResource> resource( |
208 ScopedResource::Create(resource_provider_.get())); | 208 ScopedResource::Create(resource_provider_.get())); |
209 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 209 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
210 RGBA_8888); | 210 RGBA_8888); |
211 const Resource* const_resource = resource.get(); | 211 const Resource* const_resource = resource.get(); |
212 | 212 |
213 ImageDecodeTask::Vector empty; | |
214 tasks_.push_back(new TestRasterTaskImpl( | 213 tasks_.push_back(new TestRasterTaskImpl( |
215 const_resource, | 214 tile_task_worker_pool_->AsTileTaskRunner(), const_resource, |
216 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | 215 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, |
217 base::Unretained(this), base::Passed(&resource), id), | 216 base::Unretained(this), base::Passed(&resource), id))); |
218 &empty)); | |
219 } | 217 } |
220 | 218 |
221 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | 219 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } |
222 | 220 |
223 void AppendBlockingTask(unsigned id, base::Lock* lock) { | 221 void AppendBlockingTask(unsigned id, base::Lock* lock) { |
224 const gfx::Size size(1, 1); | 222 const gfx::Size size(1, 1); |
225 | 223 |
226 scoped_ptr<ScopedResource> resource( | 224 scoped_ptr<ScopedResource> resource( |
227 ScopedResource::Create(resource_provider_.get())); | 225 ScopedResource::Create(resource_provider_.get())); |
228 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 226 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
229 RGBA_8888); | 227 RGBA_8888); |
230 const Resource* const_resource = resource.get(); | 228 const Resource* const_resource = resource.get(); |
231 | 229 |
232 ImageDecodeTask::Vector empty; | |
233 tasks_.push_back(new BlockingTestRasterTaskImpl( | 230 tasks_.push_back(new BlockingTestRasterTaskImpl( |
234 const_resource, | 231 tile_task_worker_pool_->AsTileTaskRunner(), const_resource, |
235 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | 232 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, |
236 base::Unretained(this), base::Passed(&resource), id), | 233 base::Unretained(this), base::Passed(&resource), id), |
237 lock, &empty)); | 234 lock)); |
238 } | 235 } |
239 | 236 |
240 const std::vector<RasterTaskResult>& completed_tasks() const { | 237 const std::vector<RasterTaskResult>& completed_tasks() const { |
241 return completed_tasks_; | 238 return completed_tasks_; |
242 } | 239 } |
243 | 240 |
244 void LoseContext(ContextProvider* context_provider) { | 241 void LoseContext(ContextProvider* context_provider) { |
245 if (!context_provider) | 242 if (!context_provider) |
246 return; | 243 return; |
247 context_provider->ContextGL()->LoseContextCHROMIUM( | 244 context_provider->ContextGL()->LoseContextCHROMIUM( |
(...skipping 122 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
370 | 367 |
371 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, | 368 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, |
372 TileTaskWorkerPoolTest, | 369 TileTaskWorkerPoolTest, |
373 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 370 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, |
374 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 371 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, |
375 TILE_TASK_WORKER_POOL_TYPE_GPU, | 372 TILE_TASK_WORKER_POOL_TYPE_GPU, |
376 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | 373 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); |
377 | 374 |
378 } // namespace | 375 } // namespace |
379 } // namespace cc | 376 } // namespace cc |
OLD | NEW |