Use Custome ListContainer to Allocate SharedQuadState

cc/quads/list_container.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CC_QUADS_LIST_CONTAINER_H_
 #define CC_QUADS_LIST_CONTAINER_H_
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
@@ skipping 15 matching lines @@
  public:
   // BaseElementType is the type of raw pointers this class hands out; however,
   // its derived classes might require different memory sizes.
   // max_size_for_derived_class the largest memory size required for all the
   // derived classes to use for allocation.
   explicit ListContainer(size_t max_size_for_derived_class);
   // This constructor omits input variable for max_size_for_derived_class. This
   // is used when there is no derived classes from BaseElementType we need to
   // worry about, and allocation size is just sizeof(BaseElementType).
   ListContainer();
-  // This constructor reserves the requested memory up front so only a single
-  // allocation is needed.
+  // This constructor reserves the requested memory up front so only single
+  // allocation is needed. When num_of_elements_to_reserve_for is zero, use the
+  // default size.
   ListContainer(size_t max_size_for_derived_class,
                 size_t num_of_elements_to_reserve_for);
 
   ~ListContainer();
 
   // This class deals only with char* and void*. It does allocation and passing
   // out raw pointers, as well as memory deallocation when being destroyed.
   class CC_EXPORT ListContainerCharAllocator;
 
   // This class points to a certain position inside memory of
@@ skipping 18 matching lines @@
   };
 
   // Iterator classes that can be used to access data.
   /////////////////////////////////////////////////////////////////
   class CC_EXPORT Iterator : public PositionInListContainerCharAllocator {
     // This class is only defined to forward iterate through
     // ListContainerCharAllocator.
    public:
     Iterator(ListContainerCharAllocator* container,
              size_t vector_ind,
-             char* item_iter);
+             char* item_iter,
+             size_t index);
     ~Iterator();
     BaseElementType* operator->() const;
     BaseElementType& operator*() const;
     Iterator operator++(int unused_post_increment);
     Iterator operator++();
+
+    size_t index() const;
+
+   private:
+    // This is used to track how many increment has happened since begin(). It
+    // is

[danakj, 2014/10/02 15:32:48]

fix formatting

[weiliangc, 2014/10/02 22:01:39]

Done.

+    // used to avoid doulble increment at places an index reference is needed.
+    // For iterator this means begin() corresponds to index 0 and end()
+    // corresponds to index |size|.
+    size_t index_;
   };
 
   class CC_EXPORT ConstIterator : public PositionInListContainerCharAllocator {
     // This class is only defined to forward iterate through
     // ListContainerCharAllocator.
    public:
     ConstIterator(ListContainerCharAllocator* container,
                   size_t vector_ind,
-                  char* item_iter);
+                  char* item_iter,
+                  size_t index);
     ConstIterator(const Iterator& other);  // NOLINT
     ~ConstIterator();
     const BaseElementType* operator->() const;
     const BaseElementType& operator*() const;
     ConstIterator operator++(int unused_post_increment);
     ConstIterator operator++();
+
+    size_t index() const;
+
+   private:
+    // This is used to track how many increment has happened since begin(). It
+    // is

[danakj, 2014/10/02 15:32:48]

formatting

[weiliangc, 2014/10/02 22:01:40]

Done.

+    // used to avoid doulble increment at places an index reference is needed.
+    // For iterator this means begin() corresponds to index 0 and end()
+    // corresponds to index |size|.
+    size_t index_;
   };
 
   class CC_EXPORT ReverseIterator
       : public PositionInListContainerCharAllocator {
     // This class is only defined to reverse iterate through
     // ListContainerCharAllocator.
    public:
     ReverseIterator(ListContainerCharAllocator* container,
                     size_t vector_ind,
-                    char* item_iter);
+                    char* item_iter,
+                    size_t index);
     ~ReverseIterator();
     BaseElementType* operator->() const;
     BaseElementType& operator*() const;
     ReverseIterator operator++(int unused_post_increment);
     ReverseIterator operator++();
+
+    size_t index() const;
+
+   private:
+    // This is used to track how many increment has happened since rbegin(). It
+    // is used to avoid doulble increment at places an index reference is
+    // needed.
+    // For reverse iterator this means rbegin() corresponds to index 0 and
+    // rend()

[danakj, 2014/10/02 15:32:48]

formatting

[weiliangc, 2014/10/02 22:01:39]

Done.

+    // corresponds to index |size|.
+    size_t index_;
   };
 
   class CC_EXPORT ConstReverseIterator
       : public PositionInListContainerCharAllocator {
     // This class is only defined to reverse iterate through
     // ListContainerCharAllocator.
    public:
     ConstReverseIterator(ListContainerCharAllocator* container,
                          size_t vector_ind,
-                         char* item_iter);
+                         char* item_iter,
+                         size_t index);
     ConstReverseIterator(const ReverseIterator& other);  // NOLINT
     ~ConstReverseIterator();
     const BaseElementType* operator->() const;
     const BaseElementType& operator*() const;
     ConstReverseIterator operator++(int unused_post_increment);
     ConstReverseIterator operator++();
+
+    size_t index() const;
+
+   private:
+    // This is used to track how many increment has happened since rbegin(). It
+    // is used to avoid doulble increment at places an index reference is
+    // needed.
+    // For reverse iterator this means rbegin() corresponds to index 0 and
+    // rend()

[danakj, 2014/10/02 15:32:48]

formattting

[weiliangc, 2014/10/02 22:01:40]

Done.

+    // corresponds to index |size|.
+    size_t index_;
   };
 
   // When called, all raw pointers that have been handed out are no longer
   // valid. Use with caution.
   // This function does not deallocate memory.
   void EraseAndInvalidateAllPointers(Iterator position);
 
   ConstReverseIterator rbegin() const;
   ConstReverseIterator rend() const;
   ReverseIterator rbegin();
@@ skipping 40 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ListContainer);
 };
 
 #if !defined(COMPILER_MSVC)
 extern template class ListContainer<SharedQuadState>;
 extern template class ListContainer<DrawQuad>;
 #endif
 }  // namespace cc
 
 #endif  // CC_QUADS_LIST_CONTAINER_H_