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/raster_buffer_provider.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/memory/ptr_util.h" | 17 #include "base/memory/ptr_util.h" |
18 #include "base/single_thread_task_runner.h" | 18 #include "base/single_thread_task_runner.h" |
19 #include "base/thread_task_runner_handle.h" | 19 #include "base/thread_task_runner_handle.h" |
20 #include "cc/base/unique_notifier.h" | 20 #include "cc/base/unique_notifier.h" |
21 #include "cc/raster/bitmap_tile_task_worker_pool.h" | 21 #include "cc/raster/bitmap_raster_buffer_provider.h" |
| 22 #include "cc/raster/gpu_raster_buffer_provider.h" |
22 #include "cc/raster/gpu_rasterizer.h" | 23 #include "cc/raster/gpu_rasterizer.h" |
23 #include "cc/raster/gpu_tile_task_worker_pool.h" | 24 #include "cc/raster/one_copy_raster_buffer_provider.h" |
24 #include "cc/raster/one_copy_tile_task_worker_pool.h" | |
25 #include "cc/raster/synchronous_task_graph_runner.h" | 25 #include "cc/raster/synchronous_task_graph_runner.h" |
26 #include "cc/raster/zero_copy_tile_task_worker_pool.h" | 26 #include "cc/raster/zero_copy_raster_buffer_provider.h" |
27 #include "cc/resources/resource_pool.h" | 27 #include "cc/resources/resource_pool.h" |
28 #include "cc/resources/resource_provider.h" | 28 #include "cc/resources/resource_provider.h" |
29 #include "cc/resources/scoped_resource.h" | 29 #include "cc/resources/scoped_resource.h" |
30 #include "cc/test/fake_output_surface.h" | 30 #include "cc/test/fake_output_surface.h" |
31 #include "cc/test/fake_output_surface_client.h" | 31 #include "cc/test/fake_output_surface_client.h" |
32 #include "cc/test/fake_raster_source.h" | 32 #include "cc/test/fake_raster_source.h" |
33 #include "cc/test/fake_resource_provider.h" | 33 #include "cc/test/fake_resource_provider.h" |
34 #include "cc/test/test_gpu_memory_buffer_manager.h" | 34 #include "cc/test/test_gpu_memory_buffer_manager.h" |
35 #include "cc/test/test_shared_bitmap_manager.h" | 35 #include "cc/test/test_shared_bitmap_manager.h" |
36 #include "cc/test/test_web_graphics_context_3d.h" | 36 #include "cc/test/test_web_graphics_context_3d.h" |
| 37 #include "cc/tiles/tile_task_manager.h" |
37 #include "gpu/GLES2/gl2extchromium.h" | 38 #include "gpu/GLES2/gl2extchromium.h" |
38 #include "testing/gtest/include/gtest/gtest.h" | 39 #include "testing/gtest/include/gtest/gtest.h" |
39 | 40 |
40 namespace cc { | 41 namespace cc { |
41 namespace { | 42 namespace { |
42 | 43 |
43 const size_t kMaxBytesPerCopyOperation = 1000U; | 44 const size_t kMaxBytesPerCopyOperation = 1000U; |
44 const size_t kMaxStagingBuffers = 32U; | 45 const size_t kMaxStagingBuffers = 32U; |
45 | 46 |
46 enum TileTaskWorkerPoolType { | 47 enum RasterBufferProviderType { |
47 TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 48 RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, |
48 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 49 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, |
49 TILE_TASK_WORKER_POOL_TYPE_GPU, | 50 RASTER_BUFFER_PROVIDER_TYPE_GPU, |
50 TILE_TASK_WORKER_POOL_TYPE_BITMAP | 51 RASTER_BUFFER_PROVIDER_TYPE_BITMAP |
51 }; | 52 }; |
52 | 53 |
53 class TestRasterTaskImpl : public TileTask { | 54 class TestRasterTaskImpl : public TileTask { |
54 public: | 55 public: |
55 typedef base::Callback<void(bool was_canceled)> Reply; | 56 typedef base::Callback<void(bool was_canceled)> Reply; |
56 | 57 |
57 TestRasterTaskImpl(const Resource* resource, | 58 TestRasterTaskImpl(const Resource* resource, |
58 const Reply& reply, | 59 const Reply& reply, |
59 TileTask::Vector* dependencies) | 60 TileTask::Vector* dependencies) |
60 : TileTask(true, dependencies), | 61 : TileTask(true, dependencies), |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
109 | 110 |
110 protected: | 111 protected: |
111 ~BlockingTestRasterTaskImpl() override {} | 112 ~BlockingTestRasterTaskImpl() override {} |
112 | 113 |
113 private: | 114 private: |
114 base::Lock* lock_; | 115 base::Lock* lock_; |
115 | 116 |
116 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); | 117 DISALLOW_COPY_AND_ASSIGN(BlockingTestRasterTaskImpl); |
117 }; | 118 }; |
118 | 119 |
119 class TileTaskWorkerPoolTest | 120 class RasterBufferProviderTest |
120 : public testing::TestWithParam<TileTaskWorkerPoolType> { | 121 : public testing::TestWithParam<RasterBufferProviderType> { |
121 public: | 122 public: |
122 struct RasterTaskResult { | 123 struct RasterTaskResult { |
123 unsigned id; | 124 unsigned id; |
124 bool canceled; | 125 bool canceled; |
125 }; | 126 }; |
126 | 127 |
127 typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector; | 128 typedef std::vector<scoped_refptr<TileTask>> RasterTaskVector; |
128 | 129 |
129 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; | 130 enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL }; |
130 | 131 |
131 TileTaskWorkerPoolTest() | 132 RasterBufferProviderTest() |
132 : context_provider_(TestContextProvider::Create()), | 133 : context_provider_(TestContextProvider::Create()), |
133 worker_context_provider_(TestContextProvider::CreateWorker()), | 134 worker_context_provider_(TestContextProvider::CreateWorker()), |
134 all_tile_tasks_finished_( | 135 all_tile_tasks_finished_( |
135 base::ThreadTaskRunnerHandle::Get() | 136 base::ThreadTaskRunnerHandle::Get().get(), |
136 .get(), | 137 base::Bind(&RasterBufferProviderTest::AllTileTasksFinished, |
137 base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished, | |
138 base::Unretained(this))), | 138 base::Unretained(this))), |
139 timeout_seconds_(5), | 139 timeout_seconds_(5), |
140 timed_out_(false) {} | 140 timed_out_(false) {} |
141 | 141 |
142 // Overridden from testing::Test: | 142 // Overridden from testing::Test: |
143 void SetUp() override { | 143 void SetUp() override { |
| 144 std::unique_ptr<RasterBufferProvider> raster_buffer_provider; |
144 switch (GetParam()) { | 145 switch (GetParam()) { |
145 case TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY: | 146 case RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY: |
146 Create3dOutputSurfaceAndResourceProvider(); | 147 Create3dOutputSurfaceAndResourceProvider(); |
147 tile_task_worker_pool_ = ZeroCopyTileTaskWorkerPool::Create( | 148 raster_buffer_provider = ZeroCopyRasterBufferProvider::Create( |
148 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
149 resource_provider_.get(), PlatformColor::BestTextureFormat()); | 149 resource_provider_.get(), PlatformColor::BestTextureFormat()); |
150 break; | 150 break; |
151 case TILE_TASK_WORKER_POOL_TYPE_ONE_COPY: | 151 case RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY: |
152 Create3dOutputSurfaceAndResourceProvider(); | 152 Create3dOutputSurfaceAndResourceProvider(); |
153 tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create( | 153 raster_buffer_provider = OneCopyRasterBufferProvider::Create( |
154 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | 154 base::ThreadTaskRunnerHandle::Get().get(), context_provider_.get(), |
155 context_provider_.get(), resource_provider_.get(), | 155 resource_provider_.get(), kMaxBytesPerCopyOperation, false, |
156 kMaxBytesPerCopyOperation, false, kMaxStagingBuffers, | 156 kMaxStagingBuffers, PlatformColor::BestTextureFormat()); |
157 PlatformColor::BestTextureFormat()); | |
158 break; | 157 break; |
159 case TILE_TASK_WORKER_POOL_TYPE_GPU: | 158 case RASTER_BUFFER_PROVIDER_TYPE_GPU: |
160 Create3dOutputSurfaceAndResourceProvider(); | 159 Create3dOutputSurfaceAndResourceProvider(); |
161 tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create( | 160 raster_buffer_provider = GpuRasterBufferProvider::Create( |
162 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | |
163 context_provider_.get(), resource_provider_.get(), false, 0); | 161 context_provider_.get(), resource_provider_.get(), false, 0); |
164 break; | 162 break; |
165 case TILE_TASK_WORKER_POOL_TYPE_BITMAP: | 163 case RASTER_BUFFER_PROVIDER_TYPE_BITMAP: |
166 CreateSoftwareOutputSurfaceAndResourceProvider(); | 164 CreateSoftwareOutputSurfaceAndResourceProvider(); |
167 tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create( | 165 raster_buffer_provider = |
168 base::ThreadTaskRunnerHandle::Get().get(), &task_graph_runner_, | 166 BitmapRasterBufferProvider::Create(resource_provider_.get()); |
169 resource_provider_.get()); | |
170 break; | 167 break; |
171 } | 168 } |
172 | 169 |
173 DCHECK(tile_task_worker_pool_); | 170 DCHECK(raster_buffer_provider); |
| 171 |
| 172 tile_task_manager_ = TileTaskManagerImpl::Create( |
| 173 std::move(raster_buffer_provider), &task_graph_runner_); |
174 } | 174 } |
175 | 175 |
176 void TearDown() override { | 176 void TearDown() override { |
177 tile_task_worker_pool_->Shutdown(); | 177 tile_task_manager_->Shutdown(); |
178 tile_task_worker_pool_->CheckForCompletedTasks(); | 178 tile_task_manager_->CheckForCompletedTasks(); |
179 } | 179 } |
180 | 180 |
181 void AllTileTasksFinished() { | 181 void AllTileTasksFinished() { |
182 tile_task_worker_pool_->CheckForCompletedTasks(); | 182 tile_task_manager_->CheckForCompletedTasks(); |
183 base::MessageLoop::current()->QuitWhenIdle(); | 183 base::MessageLoop::current()->QuitWhenIdle(); |
184 } | 184 } |
185 | 185 |
186 void RunMessageLoopUntilAllTasksHaveCompleted() { | 186 void RunMessageLoopUntilAllTasksHaveCompleted() { |
187 task_graph_runner_.RunUntilIdle(); | 187 task_graph_runner_.RunUntilIdle(); |
188 tile_task_worker_pool_->CheckForCompletedTasks(); | 188 tile_task_manager_->CheckForCompletedTasks(); |
189 } | 189 } |
190 | 190 |
191 void ScheduleTasks() { | 191 void ScheduleTasks() { |
192 graph_.Reset(); | 192 graph_.Reset(); |
193 | 193 |
194 size_t priority = 0; | 194 size_t priority = 0; |
195 | 195 |
196 for (RasterTaskVector::const_iterator it = tasks_.begin(); | 196 for (RasterTaskVector::const_iterator it = tasks_.begin(); |
197 it != tasks_.end(); ++it) { | 197 it != tasks_.end(); ++it) { |
198 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, | 198 graph_.nodes.emplace_back(it->get(), 0 /* group */, priority++, |
199 0 /* dependencies */); | 199 0 /* dependencies */); |
200 } | 200 } |
201 | 201 |
202 tile_task_worker_pool_->ScheduleTasks(&graph_); | 202 tile_task_manager_->ScheduleTasks(&graph_); |
203 } | 203 } |
204 | 204 |
205 void AppendTask(unsigned id, const gfx::Size& size) { | 205 void AppendTask(unsigned id, const gfx::Size& size) { |
206 std::unique_ptr<ScopedResource> resource( | 206 std::unique_ptr<ScopedResource> resource( |
207 ScopedResource::Create(resource_provider_.get())); | 207 ScopedResource::Create(resource_provider_.get())); |
208 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 208 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
209 RGBA_8888); | 209 RGBA_8888); |
210 const Resource* const_resource = resource.get(); | 210 const Resource* const_resource = resource.get(); |
211 | 211 |
212 TileTask::Vector empty; | 212 TileTask::Vector empty; |
213 tasks_.push_back(new TestRasterTaskImpl( | 213 tasks_.push_back(new TestRasterTaskImpl( |
214 const_resource, | 214 const_resource, |
215 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | 215 base::Bind(&RasterBufferProviderTest::OnTaskCompleted, |
216 base::Unretained(this), base::Passed(&resource), id), | 216 base::Unretained(this), base::Passed(&resource), id), |
217 &empty)); | 217 &empty)); |
218 } | 218 } |
219 | 219 |
220 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } | 220 void AppendTask(unsigned id) { AppendTask(id, gfx::Size(1, 1)); } |
221 | 221 |
222 void AppendBlockingTask(unsigned id, base::Lock* lock) { | 222 void AppendBlockingTask(unsigned id, base::Lock* lock) { |
223 const gfx::Size size(1, 1); | 223 const gfx::Size size(1, 1); |
224 | 224 |
225 std::unique_ptr<ScopedResource> resource( | 225 std::unique_ptr<ScopedResource> resource( |
226 ScopedResource::Create(resource_provider_.get())); | 226 ScopedResource::Create(resource_provider_.get())); |
227 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, | 227 resource->Allocate(size, ResourceProvider::TEXTURE_HINT_IMMUTABLE, |
228 RGBA_8888); | 228 RGBA_8888); |
229 const Resource* const_resource = resource.get(); | 229 const Resource* const_resource = resource.get(); |
230 | 230 |
231 TileTask::Vector empty; | 231 TileTask::Vector empty; |
232 tasks_.push_back(new BlockingTestRasterTaskImpl( | 232 tasks_.push_back(new BlockingTestRasterTaskImpl( |
233 const_resource, | 233 const_resource, |
234 base::Bind(&TileTaskWorkerPoolTest::OnTaskCompleted, | 234 base::Bind(&RasterBufferProviderTest::OnTaskCompleted, |
235 base::Unretained(this), base::Passed(&resource), id), | 235 base::Unretained(this), base::Passed(&resource), id), |
236 lock, &empty)); | 236 lock, &empty)); |
237 } | 237 } |
238 | 238 |
239 const std::vector<RasterTaskResult>& completed_tasks() const { | 239 const std::vector<RasterTaskResult>& completed_tasks() const { |
240 return completed_tasks_; | 240 return completed_tasks_; |
241 } | 241 } |
242 | 242 |
243 void LoseContext(ContextProvider* context_provider) { | 243 void LoseContext(ContextProvider* context_provider) { |
244 if (!context_provider) | 244 if (!context_provider) |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
280 timed_out_ = true; | 280 timed_out_ = true; |
281 base::MessageLoop::current()->QuitWhenIdle(); | 281 base::MessageLoop::current()->QuitWhenIdle(); |
282 } | 282 } |
283 | 283 |
284 protected: | 284 protected: |
285 scoped_refptr<TestContextProvider> context_provider_; | 285 scoped_refptr<TestContextProvider> context_provider_; |
286 scoped_refptr<TestContextProvider> worker_context_provider_; | 286 scoped_refptr<TestContextProvider> worker_context_provider_; |
287 FakeOutputSurfaceClient output_surface_client_; | 287 FakeOutputSurfaceClient output_surface_client_; |
288 std::unique_ptr<FakeOutputSurface> output_surface_; | 288 std::unique_ptr<FakeOutputSurface> output_surface_; |
289 std::unique_ptr<ResourceProvider> resource_provider_; | 289 std::unique_ptr<ResourceProvider> resource_provider_; |
290 std::unique_ptr<TileTaskWorkerPool> tile_task_worker_pool_; | 290 std::unique_ptr<TileTaskManager> tile_task_manager_; |
291 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; | 291 TestGpuMemoryBufferManager gpu_memory_buffer_manager_; |
292 TestSharedBitmapManager shared_bitmap_manager_; | 292 TestSharedBitmapManager shared_bitmap_manager_; |
293 SynchronousTaskGraphRunner task_graph_runner_; | 293 SynchronousTaskGraphRunner task_graph_runner_; |
294 base::CancelableClosure timeout_; | 294 base::CancelableClosure timeout_; |
295 UniqueNotifier all_tile_tasks_finished_; | 295 UniqueNotifier all_tile_tasks_finished_; |
296 int timeout_seconds_; | 296 int timeout_seconds_; |
297 bool timed_out_; | 297 bool timed_out_; |
298 RasterTaskVector tasks_; | 298 RasterTaskVector tasks_; |
299 std::vector<RasterTaskResult> completed_tasks_; | 299 std::vector<RasterTaskResult> completed_tasks_; |
300 TaskGraph graph_; | 300 TaskGraph graph_; |
301 }; | 301 }; |
302 | 302 |
303 TEST_P(TileTaskWorkerPoolTest, Basic) { | 303 TEST_P(RasterBufferProviderTest, Basic) { |
304 AppendTask(0u); | 304 AppendTask(0u); |
305 AppendTask(1u); | 305 AppendTask(1u); |
306 ScheduleTasks(); | 306 ScheduleTasks(); |
307 | 307 |
308 RunMessageLoopUntilAllTasksHaveCompleted(); | 308 RunMessageLoopUntilAllTasksHaveCompleted(); |
309 | 309 |
310 ASSERT_EQ(2u, completed_tasks().size()); | 310 ASSERT_EQ(2u, completed_tasks().size()); |
311 EXPECT_FALSE(completed_tasks()[0].canceled); | 311 EXPECT_FALSE(completed_tasks()[0].canceled); |
312 EXPECT_FALSE(completed_tasks()[1].canceled); | 312 EXPECT_FALSE(completed_tasks()[1].canceled); |
313 } | 313 } |
314 | 314 |
315 TEST_P(TileTaskWorkerPoolTest, FailedMapResource) { | 315 TEST_P(RasterBufferProviderTest, FailedMapResource) { |
316 if (GetParam() == TILE_TASK_WORKER_POOL_TYPE_BITMAP) | 316 if (GetParam() == RASTER_BUFFER_PROVIDER_TYPE_BITMAP) |
317 return; | 317 return; |
318 | 318 |
319 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); | 319 TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d(); |
320 context3d->set_times_map_buffer_chromium_succeeds(0); | 320 context3d->set_times_map_buffer_chromium_succeeds(0); |
321 AppendTask(0u); | 321 AppendTask(0u); |
322 ScheduleTasks(); | 322 ScheduleTasks(); |
323 | 323 |
324 RunMessageLoopUntilAllTasksHaveCompleted(); | 324 RunMessageLoopUntilAllTasksHaveCompleted(); |
325 | 325 |
326 ASSERT_EQ(1u, completed_tasks().size()); | 326 ASSERT_EQ(1u, completed_tasks().size()); |
327 EXPECT_FALSE(completed_tasks()[0].canceled); | 327 EXPECT_FALSE(completed_tasks()[0].canceled); |
328 } | 328 } |
329 | 329 |
330 // This test checks that replacing a pending raster task with another does | 330 // This test checks that replacing a pending raster task with another does |
331 // not prevent the DidFinishRunningTileTasks notification from being sent. | 331 // not prevent the DidFinishRunningTileTasks notification from being sent. |
332 TEST_P(TileTaskWorkerPoolTest, FalseThrottling) { | 332 TEST_P(RasterBufferProviderTest, FalseThrottling) { |
333 base::Lock lock; | 333 base::Lock lock; |
334 | 334 |
335 // Schedule a task that is prevented from completing with a lock. | 335 // Schedule a task that is prevented from completing with a lock. |
336 lock.Acquire(); | 336 lock.Acquire(); |
337 AppendBlockingTask(0u, &lock); | 337 AppendBlockingTask(0u, &lock); |
338 ScheduleTasks(); | 338 ScheduleTasks(); |
339 | 339 |
340 // Schedule another task to replace the still-pending task. Because the old | 340 // Schedule another task to replace the still-pending task. Because the old |
341 // task is not a throttled task in the new task set, it should not prevent | 341 // task is not a throttled task in the new task set, it should not prevent |
342 // DidFinishRunningTileTasks from getting signaled. | 342 // DidFinishRunningTileTasks from getting signaled. |
343 RasterTaskVector tasks; | 343 RasterTaskVector tasks; |
344 tasks.swap(tasks_); | 344 tasks.swap(tasks_); |
345 AppendTask(1u); | 345 AppendTask(1u); |
346 ScheduleTasks(); | 346 ScheduleTasks(); |
347 | 347 |
348 // Unblock the first task to allow the second task to complete. | 348 // Unblock the first task to allow the second task to complete. |
349 lock.Release(); | 349 lock.Release(); |
350 | 350 |
351 RunMessageLoopUntilAllTasksHaveCompleted(); | 351 RunMessageLoopUntilAllTasksHaveCompleted(); |
352 } | 352 } |
353 | 353 |
354 TEST_P(TileTaskWorkerPoolTest, LostContext) { | 354 TEST_P(RasterBufferProviderTest, LostContext) { |
355 LoseContext(output_surface_->context_provider()); | 355 LoseContext(output_surface_->context_provider()); |
356 LoseContext(output_surface_->worker_context_provider()); | 356 LoseContext(output_surface_->worker_context_provider()); |
357 | 357 |
358 AppendTask(0u); | 358 AppendTask(0u); |
359 AppendTask(1u); | 359 AppendTask(1u); |
360 ScheduleTasks(); | 360 ScheduleTasks(); |
361 | 361 |
362 RunMessageLoopUntilAllTasksHaveCompleted(); | 362 RunMessageLoopUntilAllTasksHaveCompleted(); |
363 | 363 |
364 ASSERT_EQ(2u, completed_tasks().size()); | 364 ASSERT_EQ(2u, completed_tasks().size()); |
365 EXPECT_FALSE(completed_tasks()[0].canceled); | 365 EXPECT_FALSE(completed_tasks()[0].canceled); |
366 EXPECT_FALSE(completed_tasks()[1].canceled); | 366 EXPECT_FALSE(completed_tasks()[1].canceled); |
367 } | 367 } |
368 | 368 |
369 INSTANTIATE_TEST_CASE_P(TileTaskWorkerPoolTests, | 369 INSTANTIATE_TEST_CASE_P(RasterBufferProviderTests, |
370 TileTaskWorkerPoolTest, | 370 RasterBufferProviderTest, |
371 ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY, | 371 ::testing::Values(RASTER_BUFFER_PROVIDER_TYPE_ZERO_COPY, |
372 TILE_TASK_WORKER_POOL_TYPE_ONE_COPY, | 372 RASTER_BUFFER_PROVIDER_TYPE_ONE_COPY, |
373 TILE_TASK_WORKER_POOL_TYPE_GPU, | 373 RASTER_BUFFER_PROVIDER_TYPE_GPU, |
374 TILE_TASK_WORKER_POOL_TYPE_BITMAP)); | 374 RASTER_BUFFER_PROVIDER_TYPE_BITMAP)); |
375 | 375 |
376 } // namespace | 376 } // namespace |
377 } // namespace cc | 377 } // namespace cc |
OLD | NEW |