Adjust heap profiler integration for ContiguousContainer.

third_party/WebKit/Source/platform/graphics/ContiguousContainer.h

 // Copyright 2015 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 ContiguousContainer_h
 #define ContiguousContainer_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Alignment.h"
 #include "wtf/Allocator.h"
@@ skipping 23 matching lines @@
 // supported operations are limited to appending to, and removing from, the end
 // of the list.
 //
 // Clients should instantiate ContiguousContainer; ContiguousContainerBase is an
 // artifact of the implementation.
 
 class PLATFORM_EXPORT ContiguousContainerBase {
     DISALLOW_NEW();
     WTF_MAKE_NONCOPYABLE(ContiguousContainerBase);
 protected:
-    explicit ContiguousContainerBase(size_t maxObjectSize, const char* typeName);
-    ContiguousContainerBase(size_t maxObjectSize, size_t initialSizeBytes, const char* typeName);
+    explicit ContiguousContainerBase(size_t maxObjectSize);
     ~ContiguousContainerBase();
 
     size_t size() const { return m_elements.size(); }
     bool isEmpty() const { return !size(); }
     size_t capacityInBytes() const;
     size_t usedCapacityInBytes() const;
     size_t memoryUsageInBytes() const;
 
     // These do not invoke constructors or destructors.
+    void reserveInitialCapacity(size_t, const char* typeName);
     void* allocate(size_t objectSize, const char* typeName);
     void removeLast();
     void clear();
     void swap(ContiguousContainerBase&);
 
     Vector<void*> m_elements;
 
 private:
     class Buffer;
 
@@ skipping 36 matching lines @@
         BaseIterator m_it;
         friend class ContiguousContainer;
     };
 
 public:
     using iterator = IteratorWrapper<Vector<void*>::iterator, BaseElementType>;
     using const_iterator = IteratorWrapper<Vector<void*>::const_iterator, const BaseElementType>;
     using reverse_iterator = IteratorWrapper<Vector<void*>::reverse_iterator, BaseElementType>;
     using const_reverse_iterator = IteratorWrapper<Vector<void*>::const_reverse_iterator, const BaseElementType>;
 
-    explicit ContiguousContainer(size_t maxObjectSize)
-        : ContiguousContainerBase(align(maxObjectSize), WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType)) {}
+    explicit ContiguousContainer(size_t maxObjectSize) : ContiguousContainerBase(align(maxObjectSize)) {}
+
     ContiguousContainer(size_t maxObjectSize, size_t initialSizeBytes)
-        : ContiguousContainerBase(align(maxObjectSize), initialSizeBytes, WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType)) {}
+        : ContiguousContainer(maxObjectSize)
+    {
+        reserveInitialCapacity(std::max(maxObjectSize, initialSizeBytes), WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType));
+    }
 
     ~ContiguousContainer()
     {
         for (auto& element : *this) {
             (void)element; // MSVC incorrectly reports this variable as unused.
             element.~BaseElementType();
         }
     }
 
     using ContiguousContainerBase::size;
@@ skipping 19 matching lines @@
     const BaseElementType& operator[](size_t index) const { return *(begin() + index); }
 
     template <class DerivedElementType, typename... Args>
     DerivedElementType& allocateAndConstruct(Args&&... args)
     {
         static_assert(WTF::IsSubclass<DerivedElementType, BaseElementType>::value,
             "Must use subclass of BaseElementType.");
         static_assert(alignment % WTF_ALIGN_OF(DerivedElementType) == 0,
             "Derived type requires stronger alignment.");
         size_t allocSize = align(sizeof(DerivedElementType));
-        return *new (allocate(allocSize, WTF_HEAP_PROFILER_TYPE_NAME(DerivedElementType))) DerivedElementType(std::forward<Args>(args)...);
+        return *new (allocate(allocSize)) DerivedElementType(std::forward<Args>(args)...);

[Ruud van Asseldonk, 2016/01/21 10:23:23]

So now instead of reporting the type as |DerivedElementType|, it will be
reported as |BaseElementType|?
Is this what you refer to here? I’m not familiar with how
|ContiguousContainerBase| is used in practice. If this makes type info more
honest then sure, go for it.

[jbroman, 2016/01/21 14:23:18]

Right.
ContiguousContainer's actual user is blink::DisplayItemList, which is a
heterogeneous container of several subclasses of DisplayItem
(DrawingDisplayItem, BeginTransformDisplayItem, EndTransformDisplayItem, etc.).
ContiguousContainerBase allocates large buffers and then gives out contiguous
chunks of memory as items are added; a buffer may contain a variety of display
items.

The most that can be said of a buffer at allocation time in a DisplayItemList is
that it will contain DisplayItems. We happen to often know what the first item
in the buffer will be, but the buffer is not reserved for that type.

     }
 
     void removeLast()
     {
         ASSERT(!isEmpty());
         last().~BaseElementType();
         ContiguousContainerBase::removeLast();
     }
 
     void clear()
     {
         for (auto& element : *this) {
             (void)element; // MSVC incorrectly reports this variable as unused.
             element.~BaseElementType();
         }
         ContiguousContainerBase::clear();
     }
 
     void swap(ContiguousContainer& other) { ContiguousContainerBase::swap(other); }
 
     // Appends a new element using memcpy, then default-constructs a base
     // element in its place. Use with care.
     BaseElementType& appendByMoving(BaseElementType& item, size_t size)
     {
         ASSERT(size >= sizeof(BaseElementType));
-        void* newItem = allocate(size, WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType));
+        void* newItem = allocate(size);
         memcpy(newItem, static_cast<void*>(&item), size);
         new (&item) BaseElementType;
         return *static_cast<BaseElementType*>(newItem);
     }
 
 private:
+    void* allocate(size_t objectSize)
+    {
+        return ContiguousContainerBase::allocate(objectSize, WTF_HEAP_PROFILER_TYPE_NAME(BaseElementType));
+    }
+
     static size_t align(size_t size)
     {
         size_t alignedSize = alignment * ((size + alignment - 1) / alignment);
         ASSERT(alignedSize % alignment == 0);
         ASSERT(alignedSize >= size);
         ASSERT(alignedSize < size + alignment);
         return alignedSize;
     }
 };
 
 } // namespace blink
 
 #endif // ContiguousContainer_h