cc/quads/list_container_unittest.cc

   1 // Copyright 2014 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/quads/list_container.h"
   6
   7 #include <vector>
   8 #include "cc/quads/draw_quad.h"
   9 #include "cc/quads/largest_draw_quad.h"
  10 #include "cc/quads/render_pass_draw_quad.h"
  11 #include "cc/quads/shared_quad_state.h"
  12 #include "cc/quads/stream_video_draw_quad.h"
  13 #include "testing/gmock/include/gmock/gmock.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace cc {
  17 namespace {
  18
  19 int kMagicNumberToUseForDrawQuadOne = 42;
  20 int kMagicNumberToUseForDrawQuadTwo = 314;
  21
  22 bool isConstSharedQuadStatePointer(const SharedQuadState* ptr) {
  23   return true;
  24 }
  25
  26 bool isConstSharedQuadStatePointer(SharedQuadState* ptr) {
  27   return false;
  28 }
  29
  30 class SimpleDrawQuad : public DrawQuad {
  31  public:
  32   ~SimpleDrawQuad() override {}
  33   void IterateResources(const ResourceIteratorCallback& callback) override {}
  34
  35   void set_value(int val) { value = val; }
  36   int get_value() { return value; }
  37   void ExtendValue(base::debug::TracedValue* value) const override {}
  38
  39  private:
  40   int value;
  41 };
  42
  43 class SimpleDrawQuadConstructMagicNumberOne : public SimpleDrawQuad {
  44  public:
  45   SimpleDrawQuadConstructMagicNumberOne() : SimpleDrawQuad() {
  46     set_value(kMagicNumberToUseForDrawQuadOne);
  47   }
  48 };
  49
  50 class SimpleDrawQuadConstructMagicNumberTwo : public SimpleDrawQuad {
  51  public:
  52   SimpleDrawQuadConstructMagicNumberTwo() : SimpleDrawQuad() {
  53     set_value(kMagicNumberToUseForDrawQuadTwo);
  54   }
  55 };
  56
  57 class MockDrawQuad : public DrawQuad {
  58  public:
  59   virtual ~MockDrawQuad() { Destruct(); }
  60   virtual void IterateResources(
  61       const ResourceIteratorCallback& callback) override {}
  62   virtual void ExtendValue(base::debug::TracedValue* value) const override {}
  63   MOCK_METHOD0(Destruct, void());
  64 };
  65
  66 TEST(ListContainerTest, ConstructorCalledInAllocateAndConstruct) {
  67   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
  68
  69   size_t size = 2;
  70   SimpleDrawQuadConstructMagicNumberOne* dq_1 =
  71       list.AllocateAndConstruct<SimpleDrawQuadConstructMagicNumberOne>();
  72   SimpleDrawQuadConstructMagicNumberTwo* dq_2 =
  73       list.AllocateAndConstruct<SimpleDrawQuadConstructMagicNumberTwo>();
  74
  75   EXPECT_EQ(size, list.size());
  76   EXPECT_EQ(dq_1, list.front());
  77   EXPECT_EQ(dq_2, list.back());
  78
  79   EXPECT_EQ(kMagicNumberToUseForDrawQuadOne, dq_1->get_value());
  80   EXPECT_EQ(kMagicNumberToUseForDrawQuadTwo, dq_2->get_value());
  81 }
  82
  83 TEST(ListContainerTest, DestructorCalled) {
  84   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
  85
  86   size_t size = 1;
  87   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
  88
  89   EXPECT_CALL(*dq_1, Destruct());
  90   EXPECT_EQ(size, list.size());
  91   EXPECT_EQ(dq_1, list.front());
  92 }
  93
  94 TEST(ListContainerTest, DestructorCalledOnceWhenClear) {
  95   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
  96   size_t size = 1;
  97   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
  98
  99   EXPECT_EQ(size, list.size());
 100   EXPECT_EQ(dq_1, list.front());
 101
 102   // Make sure destructor is called once during clear, and won't be called
 103   // again.
 104   testing::MockFunction<void()> separator;
 105   {
 106     testing::InSequence s;
 107     EXPECT_CALL(*dq_1, Destruct());
 108     EXPECT_CALL(separator, Call());
 109     EXPECT_CALL(*dq_1, Destruct()).Times(0);
 110   }
 111
 112   list.clear();
 113   separator.Call();
 114 }
 115
 116 TEST(ListContainerTest, DestructorCalledOnceWhenErase) {
 117   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
 118   size_t size = 1;
 119   MockDrawQuad* dq_1 = list.AllocateAndConstruct<MockDrawQuad>();
 120
 121   EXPECT_EQ(size, list.size());
 122   EXPECT_EQ(dq_1, list.front());
 123
 124   // Make sure destructor is called once during clear, and won't be called
 125   // again.
 126   testing::MockFunction<void()> separator;
 127   {
 128     testing::InSequence s;
 129     EXPECT_CALL(*dq_1, Destruct());
 130     EXPECT_CALL(separator, Call());
 131     EXPECT_CALL(*dq_1, Destruct()).Times(0);
 132   }
 133
 134   list.EraseAndInvalidateAllPointers(list.begin());
 135   separator.Call();
 136 }
 137
 138 TEST(ListContainerTest, SimpleIndexAccessSharedQuadState) {
 139   ListContainer<SharedQuadState> list;
 140
 141   size_t size = 3;
 142   SharedQuadState* sqs_1 = list.AllocateAndConstruct<SharedQuadState>();
 143   SharedQuadState* sqs_2 = list.AllocateAndConstruct<SharedQuadState>();
 144   SharedQuadState* sqs_3 = list.AllocateAndConstruct<SharedQuadState>();
 145
 146   EXPECT_EQ(size, list.size());
 147   EXPECT_EQ(sqs_1, list.front());
 148   EXPECT_EQ(sqs_3, list.back());
 149   EXPECT_EQ(list.front(), list.ElementAt(0));
 150   EXPECT_EQ(sqs_2, list.ElementAt(1));
 151   EXPECT_EQ(list.back(), list.ElementAt(2));
 152 }
 153
 154 TEST(ListContainerTest, SimpleInsertionSharedQuadState) {
 155   ListContainer<SharedQuadState> list;
 156
 157   size_t size = 3;
 158   SharedQuadState* sqs_1 = list.AllocateAndConstruct<SharedQuadState>();
 159   list.AllocateAndConstruct<SharedQuadState>();
 160   SharedQuadState* sqs_3 = list.AllocateAndConstruct<SharedQuadState>();
 161
 162   EXPECT_EQ(size, list.size());
 163   EXPECT_EQ(sqs_1, list.front());
 164   EXPECT_EQ(sqs_3, list.back());
 165 }
 166
 167 TEST(ListContainerTest, SimpleInsertionAndClearSharedQuadState) {
 168   ListContainer<SharedQuadState> list;
 169   EXPECT_TRUE(list.empty());
 170   EXPECT_EQ(0u, list.size());
 171
 172   size_t size = 3;
 173   SharedQuadState* sqs_1 = list.AllocateAndConstruct<SharedQuadState>();
 174   list.AllocateAndConstruct<SharedQuadState>();
 175   SharedQuadState* sqs_3 = list.AllocateAndConstruct<SharedQuadState>();
 176
 177   EXPECT_EQ(size, list.size());
 178   EXPECT_EQ(sqs_1, list.front());
 179   EXPECT_EQ(sqs_3, list.back());
 180   EXPECT_FALSE(list.empty());
 181
 182   list.clear();
 183   EXPECT_TRUE(list.empty());
 184   EXPECT_EQ(0u, list.size());
 185 }
 186
 187 TEST(ListContainerTest, SimpleInsertionClearAndInsertAgainSharedQuadState) {
 188   ListContainer<SharedQuadState> list;
 189   EXPECT_TRUE(list.empty());
 190   EXPECT_EQ(0u, list.size());
 191
 192   size_t size = 2;
 193   SharedQuadState* sqs_front = list.AllocateAndConstruct<SharedQuadState>();
 194   SharedQuadState* sqs_back = list.AllocateAndConstruct<SharedQuadState>();
 195
 196   EXPECT_EQ(size, list.size());
 197   EXPECT_EQ(sqs_front, list.front());
 198   EXPECT_EQ(sqs_back, list.back());
 199   EXPECT_FALSE(list.empty());
 200
 201   list.clear();
 202   EXPECT_TRUE(list.empty());
 203   EXPECT_EQ(0u, list.size());
 204
 205   size = 3;
 206   sqs_front = list.AllocateAndConstruct<SharedQuadState>();
 207   list.AllocateAndConstruct<SharedQuadState>();
 208   sqs_back = list.AllocateAndConstruct<SharedQuadState>();
 209
 210   EXPECT_EQ(size, list.size());
 211   EXPECT_EQ(sqs_front, list.front());
 212   EXPECT_EQ(sqs_back, list.back());
 213   EXPECT_FALSE(list.empty());
 214 }
 215
 216 // This test is used to test when there is more than one allocation needed
 217 // for, ListContainer can still perform like normal vector.
 218 TEST(ListContainerTest,
 219      SimpleInsertionTriggerMoreThanOneAllocationSharedQuadState) {
 220   ListContainer<SharedQuadState> list(sizeof(SharedQuadState), 2);
 221   std::vector<SharedQuadState*> sqs_list;
 222   size_t size = 10;
 223   for (size_t i = 0; i < size; ++i) {
 224     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 225   }
 226   EXPECT_EQ(size, list.size());
 227
 228   ListContainer<SharedQuadState>::Iterator iter = list.begin();
 229   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
 230            sqs_list.begin();
 231        sqs_iter != sqs_list.end();
 232        ++sqs_iter) {
 233     EXPECT_EQ(*sqs_iter, &*iter);
 234     ++iter;
 235   }
 236 }
 237
 238 TEST(ListContainerTest,
 239      CorrectAllocationSizeForMoreThanOneAllocationSharedQuadState) {
 240   // Constructor sets the allocation size to 2. Every time ListContainer needs
 241   // to allocate again, it doubles allocation size. In this test, 10 elements is
 242   // needed, thus ListContainerShould allocate spaces 2, 4 and 8 elements.
 243   ListContainer<SharedQuadState> list(sizeof(SharedQuadState), 2);
 244   std::vector<SharedQuadState*> sqs_list;
 245   size_t size = 10;
 246   for (size_t i = 0; i < size; ++i) {
 247     // Before asking for a new element, space available without another
 248     // allocation follows.
 249     switch (i) {
 250       case 2:
 251       case 6:
 252         EXPECT_EQ(0u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 253         break;
 254       case 1:
 255       case 5:
 256         EXPECT_EQ(1u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 257         break;
 258       case 0:
 259       case 4:
 260         EXPECT_EQ(2u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 261         break;
 262       case 3:
 263         EXPECT_EQ(3u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 264         break;
 265       case 9:
 266         EXPECT_EQ(5u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 267         break;
 268       case 8:
 269         EXPECT_EQ(6u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 270         break;
 271       case 7:
 272         EXPECT_EQ(7u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 273         break;
 274       default:
 275         break;
 276     }
 277     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 278     // After asking for a new element, space available without another
 279     // allocation follows.
 280     switch (i) {
 281       case 1:
 282       case 5:
 283         EXPECT_EQ(0u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 284         break;
 285       case 0:
 286       case 4:
 287         EXPECT_EQ(1u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 288         break;
 289       case 3:
 290         EXPECT_EQ(2u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 291         break;
 292       case 2:
 293         EXPECT_EQ(3u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 294         break;
 295       case 9:
 296         EXPECT_EQ(4u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 297         break;
 298       case 8:
 299         EXPECT_EQ(5u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 300         break;
 301       case 7:
 302         EXPECT_EQ(6u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 303         break;
 304       case 6:
 305         EXPECT_EQ(7u, list.AvailableSizeWithoutAnotherAllocationForTesting());
 306         break;
 307       default:
 308         break;
 309     }
 310   }
 311   EXPECT_EQ(size, list.size());
 312
 313   ListContainer<SharedQuadState>::Iterator iter = list.begin();
 314   for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
 315            sqs_list.begin();
 316        sqs_iter != sqs_list.end();
 317        ++sqs_iter) {
 318     EXPECT_EQ(*sqs_iter, &*iter);
 319     ++iter;
 320   }
 321 }
 322
 323 TEST(ListContainerTest, SimpleIterationSharedQuadState) {
 324   ListContainer<SharedQuadState> list;
 325   std::vector<SharedQuadState*> sqs_list;
 326   size_t size = 10;
 327   for (size_t i = 0; i < size; ++i) {
 328     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 329   }
 330   EXPECT_EQ(size, list.size());
 331
 332   size_t num_iters_in_list = 0;
 333   {
 334     std::vector<SharedQuadState*>::const_iterator sqs_iter = sqs_list.begin();
 335     for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
 336          iter != list.end();
 337          ++iter) {
 338       EXPECT_EQ(*sqs_iter, &*iter);
 339       ++num_iters_in_list;
 340       ++sqs_iter;
 341     }
 342   }
 343
 344   size_t num_iters_in_vector = 0;
 345   {
 346     ListContainer<SharedQuadState>::Iterator iter = list.begin();
 347     for (std::vector<SharedQuadState*>::const_iterator sqs_iter =
 348              sqs_list.begin();
 349          sqs_iter != sqs_list.end();
 350          ++sqs_iter) {
 351       EXPECT_EQ(*sqs_iter, &*iter);
 352       ++num_iters_in_vector;
 353       ++iter;
 354     }
 355   }
 356
 357   EXPECT_EQ(num_iters_in_vector, num_iters_in_list);
 358 }
 359
 360 TEST(ListContainerTest, SimpleConstIteratorIterationSharedQuadState) {
 361   ListContainer<SharedQuadState> list;
 362   std::vector<const SharedQuadState*> sqs_list;
 363   size_t size = 10;
 364   for (size_t i = 0; i < size; ++i) {
 365     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 366   }
 367   EXPECT_EQ(size, list.size());
 368
 369   {
 370     std::vector<const SharedQuadState*>::const_iterator sqs_iter =
 371         sqs_list.begin();
 372     for (ListContainer<SharedQuadState>::ConstIterator iter = list.begin();
 373          iter != list.end();
 374          ++iter) {
 375       EXPECT_TRUE(isConstSharedQuadStatePointer(&*iter));
 376       EXPECT_EQ(*sqs_iter, &*iter);
 377       ++sqs_iter;
 378     }
 379   }
 380
 381   {
 382     std::vector<const SharedQuadState*>::const_iterator sqs_iter =
 383         sqs_list.begin();
 384     for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
 385          iter != list.end();
 386          ++iter) {
 387       EXPECT_FALSE(isConstSharedQuadStatePointer(&*iter));
 388       EXPECT_EQ(*sqs_iter, &*iter);
 389       ++sqs_iter;
 390     }
 391   }
 392
 393   {
 394     ListContainer<SharedQuadState>::ConstIterator iter = list.begin();
 395     for (std::vector<const SharedQuadState*>::const_iterator sqs_iter =
 396              sqs_list.begin();
 397          sqs_iter != sqs_list.end();
 398          ++sqs_iter) {
 399       EXPECT_EQ(*sqs_iter, &*iter);
 400       ++iter;
 401     }
 402   }
 403 }
 404
 405 TEST(ListContainerTest, SimpleReverseInsertionSharedQuadState) {
 406   ListContainer<SharedQuadState> list;
 407   std::vector<SharedQuadState*> sqs_list;
 408   size_t size = 10;
 409   for (size_t i = 0; i < size; ++i) {
 410     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 411   }
 412   EXPECT_EQ(size, list.size());
 413
 414   {
 415     std::vector<SharedQuadState*>::const_reverse_iterator sqs_iter =
 416         sqs_list.rbegin();
 417     for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
 418          iter != list.rend();
 419          ++iter) {
 420       EXPECT_EQ(*sqs_iter, &(*iter));
 421       ++sqs_iter;
 422     }
 423   }
 424
 425   {
 426     ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
 427     for (std::vector<SharedQuadState*>::reverse_iterator sqs_iter =
 428              sqs_list.rbegin();
 429          sqs_iter != sqs_list.rend();
 430          ++sqs_iter) {
 431       EXPECT_EQ(*sqs_iter, &(*iter));
 432       ++iter;
 433     }
 434   }
 435 }
 436
 437 TEST(ListContainerTest, SimpleDeletion) {
 438   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
 439   std::vector<SimpleDrawQuad*> sdq_list;
 440   size_t size = 10;
 441   for (size_t i = 0; i < size; ++i) {
 442     sdq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
 443     sdq_list.back()->set_value(i);
 444   }
 445   EXPECT_EQ(size, list.size());
 446
 447   list.EraseAndInvalidateAllPointers(list.begin());
 448   --size;
 449   EXPECT_EQ(size, list.size());
 450   int i = 1;
 451   for (ListContainer<DrawQuad>::Iterator iter = list.begin();
 452        iter != list.end();
 453        ++iter) {
 454     EXPECT_EQ(i, static_cast<SimpleDrawQuad*>(&*iter)->get_value());
 455     ++i;
 456   }
 457 }
 458
 459 TEST(ListContainerTest, SimpleIterationAndManipulation) {
 460   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
 461   std::vector<SimpleDrawQuad*> sdq_list;
 462   size_t size = 10;
 463   for (size_t i = 0; i < size; ++i) {
 464     SimpleDrawQuad* simple_dq = list.AllocateAndConstruct<SimpleDrawQuad>();
 465     sdq_list.push_back(simple_dq);
 466   }
 467   EXPECT_EQ(size, list.size());
 468
 469   ListContainer<DrawQuad>::Iterator iter = list.begin();
 470   for (int i = 0; i < 10; ++i) {
 471     static_cast<SimpleDrawQuad*>(&*iter)->set_value(i);
 472     ++iter;
 473   }
 474
 475   int i = 0;
 476   for (std::vector<SimpleDrawQuad*>::const_iterator sdq_iter = sdq_list.begin();
 477        sdq_iter < sdq_list.end();
 478        ++sdq_iter) {
 479     EXPECT_EQ(i, (*sdq_iter)->get_value());
 480     ++i;
 481   }
 482 }
 483
 484 TEST(ListContainerTest, SimpleManipulationWithIndexSimpleDrawQuad) {
 485   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad));
 486   std::vector<SimpleDrawQuad*> dq_list;
 487   size_t size = 10;
 488   for (size_t i = 0; i < size; ++i) {
 489     dq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
 490   }
 491   EXPECT_EQ(size, list.size());
 492
 493   for (size_t i = 0; i < size; ++i) {
 494     static_cast<SimpleDrawQuad*>(list.ElementAt(i))->set_value(i);
 495   }
 496
 497   int i = 0;
 498   for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
 499        dq_iter != dq_list.end();
 500        ++dq_iter, ++i) {
 501     EXPECT_EQ(i, (*dq_iter)->get_value());
 502   }
 503 }
 504
 505 TEST(ListContainerTest,
 506      SimpleManipulationWithIndexMoreThanOneAllocationSimpleDrawQuad) {
 507   ListContainer<DrawQuad> list(sizeof(kLargestDrawQuad), 2);
 508   std::vector<SimpleDrawQuad*> dq_list;
 509   size_t size = 10;
 510   for (size_t i = 0; i < size; ++i) {
 511     dq_list.push_back(list.AllocateAndConstruct<SimpleDrawQuad>());
 512   }
 513   EXPECT_EQ(size, list.size());
 514
 515   for (size_t i = 0; i < size; ++i) {
 516     static_cast<SimpleDrawQuad*>(list.ElementAt(i))->set_value(i);
 517   }
 518
 519   int i = 0;
 520   for (std::vector<SimpleDrawQuad*>::const_iterator dq_iter = dq_list.begin();
 521        dq_iter != dq_list.end();
 522        ++dq_iter, ++i) {
 523     EXPECT_EQ(i, (*dq_iter)->get_value());
 524   }
 525 }
 526
 527 TEST(ListContainerTest,
 528      SimpleIterationAndReverseIterationWithIndexSharedQuadState) {
 529   ListContainer<SharedQuadState> list;
 530   std::vector<SharedQuadState*> sqs_list;
 531   size_t size = 10;
 532   for (size_t i = 0; i < size; ++i) {
 533     sqs_list.push_back(list.AllocateAndConstruct<SharedQuadState>());
 534   }
 535   EXPECT_EQ(size, list.size());
 536
 537   size_t i = 0;
 538   for (ListContainer<SharedQuadState>::Iterator iter = list.begin();
 539        iter != list.end();
 540        ++iter) {
 541     EXPECT_EQ(i, iter.index());
 542     ++i;
 543   }
 544
 545   i = 0;
 546   for (ListContainer<SharedQuadState>::ReverseIterator iter = list.rbegin();
 547        iter != list.rend();
 548        ++iter) {
 549     EXPECT_EQ(i, iter.index());
 550     ++i;
 551   }
 552 }
 553
 554 }  // namespace
 555 }  // namespace cc