SkTArray: fix invalid reinterpret_casts over non-initialized memory.

include/private/SkTArray.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTArray_DEFINED
 #define SkTArray_DEFINED
 
@@ skipping 141 matching lines @@
      * Is the array empty.
      */
     bool empty() const { return !fCount; }
 
     /**
      * Adds 1 new default-initialized T value and returns it by reference. Note
      * the reference only remains valid until the next call that adds or removes
      * elements.
      */
     T& push_back() {
-        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
-        new (newT) T;
-        return *newT;
+        void* newT = this->push_back_raw(1);
+        return *new (newT) T;
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the new item
      */
     T& push_back(const T& t) {
-        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
-        new (newT) T(t);
-        return *newT;
+        void* newT = this->push_back_raw(1);
+        return *new (newT) T(t);
     }
 
     /**
      * Version of above that uses a move constructor to initialize the new item
      */
     T& push_back(T&& t) {
-        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
-        new (newT) T(std::move(t));
-        return *newT;
+        void* newT = this->push_back_raw(1);
+        return *new (newT) T(std::move(t));
     }
 
     /**
      *  Construct a new T at the back of this array.
      */
     template<class... Args> T& emplace_back(Args&&... args) {
-        T* newT = reinterpret_cast<T*>(this->push_back_raw(1));
+        void* newT = this->push_back_raw(1);
         return *new (newT) T(std::forward<Args>(args)...);
     }
 
     /**
      * Allocates n more default-initialized T values, and returns the address of
      * the start of that new range. Note: this address is only valid until the
      * next API call made on the array that might add or remove elements.
      */
     T* push_back_n(int n) {
         SkASSERT(n >= 0);
-        T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
+        char* newTs = static_cast<char*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
-            new (newTs + i) T;
+          new (newTs + i * sizeof(T)) T;

[bungeman-skia, 2016/04/21 15:32:20]

nit: skia uses four space indents

         }
-        return newTs;
+        return reinterpret_cast<T*>(newTs);
     }
 
     /**
      * Version of above that uses a copy constructor to initialize all n items
      * to the same T.
      */
     T* push_back_n(int n, const T& t) {
         SkASSERT(n >= 0);
-        T* newTs = reinterpret_cast<T*>(this->push_back_raw(n));
+        char* newTs = static_cast<char*>(this->push_back_raw(n));
         for (int i = 0; i < n; ++i) {
-            new (newTs + i) T(t);
+          new (newTs + i * sizeof(T)) T(t);

[bungeman-skia, 2016/04/21 15:32:20]

nit: four space

         }
-        return newTs;
+        return reinterpret_cast<T*>(newTs);
     }
 
     /**
      * Version of above that uses a copy constructor to initialize the n items
      * to separate T values.
      */
     T* push_back_n(int n, const T t[]) {
         SkASSERT(n >= 0);
         this->checkRealloc(n);
         for (int i = 0; i < n; ++i) {
@@ skipping 304 matching lines @@
     SkSTArray& operator= (const INHERITED& array) {
         INHERITED::operator=(array);
         return *this;
     }
 
 private:
     SkAlignedSTStorage<N,T> fStorage;
 };
 
 #endif