remove align16 calls in skhader context sizes. will handle this elsewhere as needed

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
 
@@ skipping 53 matching lines @@
         return new (buf) T(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 storageRequested = sizeof(T)) {
+    template<typename T> void* reserveT(size_t storageRequired = sizeof(T)) {
         SkASSERT(fNumObjects < kMaxObjects);
-        SkASSERT(storageRequested >= sizeof(T));
+        SkASSERT(storageRequired >= sizeof(T));
         if (kMaxObjects == fNumObjects) {
             return nullptr;
         }
         const size_t storageRemaining = sizeof(fStorage) - fStorageUsed;
-        const size_t storageRequired = SkAlign16(storageRequested);
         Rec* rec = &fRecs[fNumObjects];
         if (storageRequired > storageRemaining) {
             // Allocate on the heap. Ideally we want to avoid this situation,
             // but we're not sure we can catch all callers, so handle it but
             // assert false in debug mode.
             SkASSERT(false);
             rec->fStorageSize = 0;
             rec->fHeapStorage = sk_malloc_throw(storageRequired);
             rec->fObj = static_cast<void*>(rec->fHeapStorage);
         } else {
             // There is space in fStorage.
             rec->fStorageSize = storageRequired;
             rec->fHeapStorage = nullptr;
-            SkASSERT(SkIsAlign16(fStorageUsed));
             rec->fObj = static_cast<void*>(fStorage.fBytes + fStorageUsed);
             fStorageUsed += storageRequired;
         }
         rec->fKillProc = DestroyT<T>;
         fNumObjects++;
         return rec->fObj;
     }
 
     /*
      *  Free the memory reserved last without calling the destructor.
@@ skipping 30 matching lines @@
     };
 
     Storage     fStorage;
     // Number of bytes used so far.
     size_t      fStorageUsed;
     uint32_t    fNumObjects;
     Rec         fRecs[kMaxObjects];
 };
 
 #endif // SkSmallAllocator_DEFINED