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 3 // found in the LICENSE file. 4 5 #include "cc/resources/tile.h" 6 #include "cc/resources/tile_priority.h" 7 #include "cc/test/fake_output_surface.h" 8 #include "cc/test/fake_output_surface_client.h" 9 #include "cc/test/fake_picture_pile_impl.h" 10 #include "cc/test/fake_tile_manager.h" 11 #include "cc/test/fake_tile_manager_client.h" 12 #include "cc/test/test_tile_priorities.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 namespace cc { 16 namespace { 17 18 class TileManagerTest : public testing::TestWithParam<bool> { 19 public: 20 typedef std::vector<scoped_refptr<Tile> > TileVector; 21 22 void Initialize(int max_tiles, 23 TileMemoryLimitPolicy memory_limit_policy, 24 TreePriority tree_priority) { 25 output_surface_ = FakeOutputSurface::Create3d(); 26 CHECK(output_surface_->BindToClient(&output_surface_client_)); 27 28 resource_provider_ = 29 ResourceProvider::Create(output_surface_.get(), NULL, 0, false, 1); 30 tile_manager_ = make_scoped_ptr( 31 new FakeTileManager(&tile_manager_client_, resource_provider_.get())); 32 33 memory_limit_policy_ = memory_limit_policy; 34 max_memory_tiles_ = max_tiles; 35 GlobalStateThatImpactsTilePriority state; 36 gfx::Size tile_size = settings_.default_tile_size; 37 38 // The parametrization specifies whether the max tile limit should 39 // be applied to RAM or to tile limit. 40 if (GetParam()) { 41 state.memory_limit_in_bytes = 42 max_tiles * 4 * tile_size.width() * tile_size.height(); 43 state.num_resources_limit = 100; 44 } else { 45 state.memory_limit_in_bytes = 100 * 1000 * 1000; 46 state.num_resources_limit = max_tiles; 47 } 48 state.unused_memory_limit_in_bytes = state.memory_limit_in_bytes; 49 state.memory_limit_policy = memory_limit_policy; 50 state.tree_priority = tree_priority; 51 52 global_state_ = state; 53 tile_manager_->SetGlobalStateForTesting(state); 54 picture_pile_ = FakePicturePileImpl::CreatePile(); 55 } 56 57 void SetTreePriority(TreePriority tree_priority) { 58 GlobalStateThatImpactsTilePriority state; 59 gfx::Size tile_size = settings_.default_tile_size; 60 state.memory_limit_in_bytes = 61 max_memory_tiles_ * 4 * tile_size.width() * tile_size.height(); 62 state.unused_memory_limit_in_bytes = state.memory_limit_in_bytes; 63 state.memory_limit_policy = memory_limit_policy_; 64 state.num_resources_limit = 100; 65 state.tree_priority = tree_priority; 66 global_state_ = state; 67 } 68 69 virtual void TearDown() OVERRIDE { 70 tile_manager_.reset(NULL); 71 picture_pile_ = NULL; 72 73 testing::Test::TearDown(); 74 } 75 76 TileVector CreateTilesWithSize(int count, 77 TilePriority active_priority, 78 TilePriority pending_priority, 79 gfx::Size tile_size) { 80 TileVector tiles; 81 for (int i = 0; i < count; ++i) { 82 scoped_refptr<Tile> tile = tile_manager_->CreateTile(picture_pile_.get(), 83 tile_size, 84 gfx::Rect(), 85 gfx::Rect(), 86 1.0, 87 0, 88 0, 89 Tile::USE_LCD_TEXT); 90 tile->SetPriority(ACTIVE_TREE, active_priority); 91 tile->SetPriority(PENDING_TREE, pending_priority); 92 tiles.push_back(tile); 93 } 94 return tiles; 95 } 96 97 TileVector CreateTiles(int count, 98 TilePriority active_priority, 99 TilePriority pending_priority) { 100 return CreateTilesWithSize(count, 101 active_priority, 102 pending_priority, 103 settings_.default_tile_size); 104 } 105 106 FakeTileManager* tile_manager() { 107 return tile_manager_.get(); 108 } 109 110 int AssignedMemoryCount(const TileVector& tiles) { 111 int has_memory_count = 0; 112 for (TileVector::const_iterator it = tiles.begin(); 113 it != tiles.end(); 114 ++it) { 115 if (tile_manager_->HasBeenAssignedMemory(*it)) 116 ++has_memory_count; 117 } 118 return has_memory_count; 119 } 120 121 int TilesWithLCDCount(const TileVector& tiles) { 122 int has_lcd_count = 0; 123 for (TileVector::const_iterator it = tiles.begin(); 124 it != tiles.end(); 125 ++it) { 126 if ((*it)->GetRasterModeForTesting() == HIGH_QUALITY_RASTER_MODE) 127 ++has_lcd_count; 128 } 129 return has_lcd_count; 130 } 131 132 protected: 133 GlobalStateThatImpactsTilePriority global_state_; 134 135 private: 136 FakeTileManagerClient tile_manager_client_; 137 LayerTreeSettings settings_; 138 scoped_ptr<FakeTileManager> tile_manager_; 139 scoped_refptr<FakePicturePileImpl> picture_pile_; 140 FakeOutputSurfaceClient output_surface_client_; 141 scoped_ptr<FakeOutputSurface> output_surface_; 142 scoped_ptr<ResourceProvider> resource_provider_; 143 TileMemoryLimitPolicy memory_limit_policy_; 144 int max_memory_tiles_; 145 }; 146 147 TEST_P(TileManagerTest, EnoughMemoryAllowAnything) { 148 // A few tiles of each type of priority, with enough memory for all tiles. 149 150 Initialize(10, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 151 TileVector active_now = 152 CreateTiles(3, TilePriorityForNowBin(), TilePriority()); 153 TileVector pending_now = 154 CreateTiles(3, TilePriority(), TilePriorityForNowBin()); 155 TileVector active_pending_soon = CreateTiles( 156 3, TilePriorityForSoonBin(), TilePriorityForSoonBin()); 157 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority()); 158 159 tile_manager()->AssignMemoryToTiles(global_state_); 160 161 EXPECT_EQ(3, AssignedMemoryCount(active_now)); 162 EXPECT_EQ(3, AssignedMemoryCount(pending_now)); 163 EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon)); 164 EXPECT_EQ(0, AssignedMemoryCount(never_bin)); 165 } 166 167 TEST_P(TileManagerTest, EnoughMemoryAllowPrepaintOnly) { 168 // A few tiles of each type of priority, with enough memory for all tiles, 169 // with the exception of never bin. 170 171 Initialize(10, ALLOW_PREPAINT_ONLY, SMOOTHNESS_TAKES_PRIORITY); 172 TileVector active_now = 173 CreateTiles(3, TilePriorityForNowBin(), TilePriority()); 174 TileVector pending_now = 175 CreateTiles(3, TilePriority(), TilePriorityForNowBin()); 176 TileVector active_pending_soon = CreateTiles( 177 3, TilePriorityForSoonBin(), TilePriorityForSoonBin()); 178 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority()); 179 180 tile_manager()->AssignMemoryToTiles(global_state_); 181 182 EXPECT_EQ(3, AssignedMemoryCount(active_now)); 183 EXPECT_EQ(3, AssignedMemoryCount(pending_now)); 184 EXPECT_EQ(3, AssignedMemoryCount(active_pending_soon)); 185 EXPECT_EQ(0, AssignedMemoryCount(never_bin)); 186 } 187 188 TEST_P(TileManagerTest, EnoughMemoryAllowAbsoluteMinimum) { 189 // A few tiles of each type of priority, with enough memory for all tiles, 190 // with the exception of never and soon bins. 191 192 Initialize(10, ALLOW_ABSOLUTE_MINIMUM, SMOOTHNESS_TAKES_PRIORITY); 193 TileVector active_now = 194 CreateTiles(3, TilePriorityForNowBin(), TilePriority()); 195 TileVector pending_now = 196 CreateTiles(3, TilePriority(), TilePriorityForNowBin()); 197 TileVector active_pending_soon = CreateTiles( 198 3, TilePriorityForSoonBin(), TilePriorityForSoonBin()); 199 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority()); 200 201 tile_manager()->AssignMemoryToTiles(global_state_); 202 203 EXPECT_EQ(3, AssignedMemoryCount(active_now)); 204 EXPECT_EQ(3, AssignedMemoryCount(pending_now)); 205 EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon)); 206 EXPECT_EQ(0, AssignedMemoryCount(never_bin)); 207 } 208 209 TEST_P(TileManagerTest, EnoughMemoryAllowNothing) { 210 // A few tiles of each type of priority, with enough memory for all tiles, 211 // but allow nothing should not assign any memory. 212 213 Initialize(10, ALLOW_NOTHING, SMOOTHNESS_TAKES_PRIORITY); 214 TileVector active_now = 215 CreateTiles(3, TilePriorityForNowBin(), TilePriority()); 216 TileVector pending_now = 217 CreateTiles(3, TilePriority(), TilePriorityForNowBin()); 218 TileVector active_pending_soon = CreateTiles( 219 3, TilePriorityForSoonBin(), TilePriorityForSoonBin()); 220 TileVector never_bin = CreateTiles(1, TilePriority(), TilePriority()); 221 222 tile_manager()->AssignMemoryToTiles(global_state_); 223 224 EXPECT_EQ(0, AssignedMemoryCount(active_now)); 225 EXPECT_EQ(0, AssignedMemoryCount(pending_now)); 226 EXPECT_EQ(0, AssignedMemoryCount(active_pending_soon)); 227 EXPECT_EQ(0, AssignedMemoryCount(never_bin)); 228 } 229 230 TEST_P(TileManagerTest, PartialOOMMemoryToPending) { 231 // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are 232 // required for activation, but only enough memory for 8 tiles. The result 233 // is all pending tree tiles get memory, and 3 of the active tree tiles 234 // get memory. 235 236 Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 237 TileVector active_tree_tiles = 238 CreateTiles(5, TilePriorityForEventualBin(), TilePriority()); 239 TileVector pending_tree_tiles = 240 CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation()); 241 242 tile_manager()->AssignMemoryToTiles(global_state_); 243 244 EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles)); 245 EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles)); 246 247 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES); 248 tile_manager()->AssignMemoryToTiles(global_state_); 249 250 EXPECT_EQ(3, AssignedMemoryCount(active_tree_tiles)); 251 EXPECT_EQ(5, AssignedMemoryCount(pending_tree_tiles)); 252 } 253 254 TEST_P(TileManagerTest, PartialOOMMemoryToActive) { 255 // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin, 256 // but only enough memory for 8 tiles. The result is all active tree tiles 257 // get memory, and 3 of the pending tree tiles get memory. 258 259 Initialize(8, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 260 TileVector active_tree_tiles = 261 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 262 TileVector pending_tree_tiles = 263 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 264 265 tile_manager()->AssignMemoryToTiles(global_state_); 266 267 EXPECT_EQ(5, AssignedMemoryCount(active_tree_tiles)); 268 EXPECT_EQ(3, AssignedMemoryCount(pending_tree_tiles)); 269 } 270 271 TEST_P(TileManagerTest, TotalOOMMemoryToPending) { 272 // 5 tiles on active tree eventually bin, 5 tiles on pending tree that are 273 // required for activation, but only enough memory for 4 tiles. The result 274 // is 4 pending tree tiles get memory, and none of the active tree tiles 275 // get memory. 276 277 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 278 TileVector active_tree_tiles = 279 CreateTiles(5, TilePriorityForEventualBin(), TilePriority()); 280 TileVector pending_tree_tiles = 281 CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation()); 282 283 tile_manager()->AssignMemoryToTiles(global_state_); 284 285 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles)); 286 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles)); 287 288 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES); 289 tile_manager()->AssignMemoryToTiles(global_state_); 290 291 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles)); 292 EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles)); 293 } 294 295 TEST_P(TileManagerTest, TotalOOMActiveSoonMemoryToPending) { 296 // 5 tiles on active tree soon bin, 5 tiles on pending tree that are 297 // required for activation, but only enough memory for 4 tiles. The result 298 // is 4 pending tree tiles get memory, and none of the active tree tiles 299 // get memory. 300 301 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 302 TileVector active_tree_tiles = 303 CreateTiles(5, TilePriorityForSoonBin(), TilePriority()); 304 TileVector pending_tree_tiles = 305 CreateTiles(5, TilePriority(), TilePriorityRequiredForActivation()); 306 307 tile_manager()->AssignMemoryToTiles(global_state_); 308 309 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles)); 310 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles)); 311 312 SetTreePriority(SAME_PRIORITY_FOR_BOTH_TREES); 313 tile_manager()->AssignMemoryToTiles(global_state_); 314 315 EXPECT_EQ(0, AssignedMemoryCount(active_tree_tiles)); 316 EXPECT_EQ(4, AssignedMemoryCount(pending_tree_tiles)); 317 } 318 319 TEST_P(TileManagerTest, TotalOOMMemoryToActive) { 320 // 5 tiles on active tree eventually bin, 5 tiles on pending tree now bin, 321 // but only enough memory for 4 tiles. The result is 5 active tree tiles 322 // get memory, and none of the pending tree tiles get memory. 323 324 Initialize(4, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 325 TileVector active_tree_tiles = 326 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 327 TileVector pending_tree_tiles = 328 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 329 330 tile_manager()->AssignMemoryToTiles(global_state_); 331 332 EXPECT_EQ(4, AssignedMemoryCount(active_tree_tiles)); 333 EXPECT_EQ(0, AssignedMemoryCount(pending_tree_tiles)); 334 } 335 336 337 338 TEST_P(TileManagerTest, RasterAsLCD) { 339 Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 340 TileVector active_tree_tiles = 341 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 342 TileVector pending_tree_tiles = 343 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 344 345 tile_manager()->AssignMemoryToTiles(global_state_); 346 347 EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles)); 348 EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles)); 349 } 350 351 TEST_P(TileManagerTest, RasterAsNoLCD) { 352 Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 353 TileVector active_tree_tiles = 354 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 355 TileVector pending_tree_tiles = 356 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 357 358 for (TileVector::iterator it = active_tree_tiles.begin(); 359 it != active_tree_tiles.end(); 360 ++it) { 361 (*it)->set_can_use_lcd_text(false); 362 } 363 for (TileVector::iterator it = pending_tree_tiles.begin(); 364 it != pending_tree_tiles.end(); 365 ++it) { 366 (*it)->set_can_use_lcd_text(false); 367 } 368 369 tile_manager()->AssignMemoryToTiles(global_state_); 370 371 EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles)); 372 EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles)); 373 } 374 375 TEST_P(TileManagerTest, ReRasterAsNoLCD) { 376 Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 377 TileVector active_tree_tiles = 378 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 379 TileVector pending_tree_tiles = 380 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 381 382 tile_manager()->AssignMemoryToTiles(global_state_); 383 384 EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles)); 385 EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles)); 386 387 for (TileVector::iterator it = active_tree_tiles.begin(); 388 it != active_tree_tiles.end(); 389 ++it) { 390 (*it)->set_can_use_lcd_text(false); 391 } 392 for (TileVector::iterator it = pending_tree_tiles.begin(); 393 it != pending_tree_tiles.end(); 394 ++it) { 395 (*it)->set_can_use_lcd_text(false); 396 } 397 398 tile_manager()->AssignMemoryToTiles(global_state_); 399 400 EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles)); 401 EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles)); 402 } 403 404 TEST_P(TileManagerTest, NoTextDontReRasterAsNoLCD) { 405 Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 406 TileVector active_tree_tiles = 407 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 408 TileVector pending_tree_tiles = 409 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 410 411 tile_manager()->AssignMemoryToTiles(global_state_); 412 413 EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles)); 414 EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles)); 415 416 for (TileVector::iterator it = active_tree_tiles.begin(); 417 it != active_tree_tiles.end(); 418 ++it) { 419 ManagedTileState::TileVersion& tile_version = 420 (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE); 421 tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0)); 422 (*it)->set_can_use_lcd_text(false); 423 EXPECT_TRUE((*it)->IsReadyToDraw()); 424 } 425 for (TileVector::iterator it = pending_tree_tiles.begin(); 426 it != pending_tree_tiles.end(); 427 ++it) { 428 ManagedTileState::TileVersion& tile_version = 429 (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE); 430 tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0)); 431 (*it)->set_can_use_lcd_text(false); 432 EXPECT_TRUE((*it)->IsReadyToDraw()); 433 } 434 435 tile_manager()->AssignMemoryToTiles(global_state_); 436 437 EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles)); 438 EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles)); 439 } 440 441 TEST_P(TileManagerTest, TextReRasterAsNoLCD) { 442 Initialize(20, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 443 TileVector active_tree_tiles = 444 CreateTiles(5, TilePriorityForNowBin(), TilePriority()); 445 TileVector pending_tree_tiles = 446 CreateTiles(5, TilePriority(), TilePriorityForNowBin()); 447 448 tile_manager()->AssignMemoryToTiles(global_state_); 449 450 EXPECT_EQ(5, TilesWithLCDCount(active_tree_tiles)); 451 EXPECT_EQ(5, TilesWithLCDCount(pending_tree_tiles)); 452 453 for (TileVector::iterator it = active_tree_tiles.begin(); 454 it != active_tree_tiles.end(); 455 ++it) { 456 ManagedTileState::TileVersion& tile_version = 457 (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE); 458 tile_version.SetSolidColorForTesting(SkColorSetARGB(0, 0, 0, 0)); 459 tile_version.SetHasTextForTesting(true); 460 (*it)->set_can_use_lcd_text(false); 461 462 EXPECT_TRUE((*it)->IsReadyToDraw()); 463 } 464 for (TileVector::iterator it = pending_tree_tiles.begin(); 465 it != pending_tree_tiles.end(); 466 ++it) { 467 ManagedTileState::TileVersion& tile_version = 468 (*it)->GetTileVersionForTesting(HIGH_QUALITY_RASTER_MODE); 469 tile_version.SetSolidColorForTesting( 470 SkColorSetARGB(0, 0, 0, 0)); 471 tile_version.SetHasTextForTesting(true); 472 (*it)->set_can_use_lcd_text(false); 473 474 EXPECT_TRUE((*it)->IsReadyToDraw()); 475 } 476 477 tile_manager()->AssignMemoryToTiles(global_state_); 478 479 EXPECT_EQ(0, TilesWithLCDCount(active_tree_tiles)); 480 EXPECT_EQ(0, TilesWithLCDCount(pending_tree_tiles)); 481 } 482 483 TEST_P(TileManagerTest, RespectMemoryLimit) { 484 Initialize(5, ALLOW_ANYTHING, SMOOTHNESS_TAKES_PRIORITY); 485 TileVector large_tiles = CreateTiles( 486 5, TilePriorityForNowBin(), TilePriority()); 487 488 size_t memory_required_bytes; 489 size_t memory_nice_to_have_bytes; 490 size_t memory_allocated_bytes; 491 size_t memory_used_bytes; 492 493 tile_manager()->AssignMemoryToTiles(global_state_); 494 tile_manager()->GetMemoryStats(&memory_required_bytes, 495 &memory_nice_to_have_bytes, 496 &memory_allocated_bytes, 497 &memory_used_bytes); 498 // Allocated bytes should never be more than the memory limit. 499 EXPECT_LE(memory_allocated_bytes, global_state_.memory_limit_in_bytes); 500 501 // Finish raster of large tiles. 502 tile_manager()->UpdateVisibleTiles(); 503 504 // Remove all large tiles. This will leave the memory currently 505 // used by these tiles as unused when AssignMemoryToTiles() is called. 506 large_tiles.clear(); 507 508 // Create a new set of tiles using a different size. These tiles 509 // can use the memory currently assigned to the lerge tiles but 510 // they can't use the same resources as the size doesn't match. 511 TileVector small_tiles = CreateTilesWithSize( 512 5, TilePriorityForNowBin(), TilePriority(), gfx::Size(128, 128)); 513 514 tile_manager()->AssignMemoryToTiles(global_state_); 515 tile_manager()->GetMemoryStats(&memory_required_bytes, 516 &memory_nice_to_have_bytes, 517 &memory_allocated_bytes, 518 &memory_used_bytes); 519 // Allocated bytes should never be more than the memory limit. 520 EXPECT_LE(memory_allocated_bytes, global_state_.memory_limit_in_bytes); 521 } 522 523 // If true, the max tile limit should be applied as bytes; if false, 524 // as num_resources_limit. 525 INSTANTIATE_TEST_CASE_P(TileManagerTests, 526 TileManagerTest, 527 ::testing::Values(true, false)); 528 529 } // namespace 530 } // namespace cc 531
