Use perfect forwarding in createT of SkSmallAllocator.

src/core/SkSmallAllocator.h

 /*
  * Copyright 2014 Google, Inc
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSmallAllocator_DEFINED
 #define SkSmallAllocator_DEFINED
 
 #include "SkTDArray.h"
 #include "SkTypes.h"
 
 #include <new>

[mtklein_C, 2016/11/06 13:25:16]

Probably a good idea to include <utility>

[herb_g, 2016/11/07 04:44:40]

Done.

 
 /*
  *  Template class for allocating small objects without additional heap memory
  *  allocations. kMaxObjects is a hard limit on the number of objects that can
  *  be allocated using this class. After that, attempts to create more objects
  *  with this class will assert and return nullptr.
  *
  *  kTotalBytes is the total number of bytes provided for storage for all
  *  objects created by this allocator. If an object to be created is larger
  *  than the storage (minus storage already used), it will be allocated on the
  *  heap. This class's destructor will handle calling the destructor for each
  *  object it allocated and freeing its memory.
  *
  *  Current the class always aligns each allocation to 16-bytes to be safe, but future
  *  may reduce this to only the alignment that is required per alloc.
  */
 template<uint32_t kMaxObjects, size_t kTotalBytes>
 class SkSmallAllocator : SkNoncopyable {
 public:
     SkSmallAllocator()
     : fStorageUsed(0)
-    , fNumObjects(0)
-    {}

[mtklein_C, 2016/11/06 13:25:16]

Seems unnecessary?

[herb_g, 2016/11/07 04:44:40]

Done.

+    , fNumObjects(0) { }
 
     ~SkSmallAllocator() {
         // Destruct in reverse order, in case an earlier object points to a
         // later object.
         while (fNumObjects > 0) {
             fNumObjects--;
             Rec* rec = &fRecs[fNumObjects];
             rec->fKillProc(rec->fObj);
             // Safe to do if fObj is in fStorage, since fHeapStorage will
             // point to nullptr.
             sk_free(rec->fHeapStorage);
         }
     }
 
     /*
      *  Create a new object of type T. Its lifetime will be handled by this
      *  SkSmallAllocator.
      *  Note: If kMaxObjects have been created by this SkSmallAllocator, nullptr
      *  will be returned.
      */
     template<typename T, typename... Args>
-    T* createT(const Args&... args) {
+    T* createT(Args&&... args) {
         void* buf = this->reserveT<T>();
         if (nullptr == buf) {
             return nullptr;
         }
-        return new (buf) T(args...);
+        return new (buf) T(std::forward<Args>(args)...);
     }
 
     /*
      *  Reserve a specified amount of space (must be enough space for one T).
      *  The space will be in fStorage if there is room, or on the heap otherwise.
      *  Either way, this class will call ~T() in its destructor and free the heap
      *  allocation if necessary.
      *  Unlike createT(), this method will not call the constructor of T.
      */
     template<typename T> void* reserveT(size_t storageRequired = sizeof(T)) {
@@ skipping 34 matching lines @@
     void freeLast() {
         SkASSERT(fNumObjects > 0);
         Rec* rec = &fRecs[fNumObjects - 1];
         sk_free(rec->fHeapStorage);
         fStorageUsed -= rec->fStorageSize;
 
         fNumObjects--;
     }
 
 private:
+    static constexpr size_t kAlignment = 16UL;

[mtklein_C, 2016/11/06 13:25:16]

Unused?

[herb_g, 2016/11/07 04:44:40]

Done.

     struct Rec {
         size_t fStorageSize;  // 0 if allocated on heap
         void*  fObj;
         void*  fHeapStorage;
         void   (*fKillProc)(void*);
     };
 
     // Used to call the destructor for allocated objects.
     template<typename T>
     static void DestroyT(void* ptr) {
         static_cast<T*>(ptr)->~T();
     }
 
     alignas(16) char fStorage[kTotalBytes];
-    // Number of bytes used so far.
-    size_t   fStorageUsed;
-    uint32_t fNumObjects;
-    Rec      fRecs[kMaxObjects];
+    size_t           fStorageUsed;  // Number of bytes used so far.
+    uint32_t         fNumObjects;
+    Rec              fRecs[kMaxObjects];
 };
 
 #endif // SkSmallAllocator_DEFINED