Revert of Try to use only std::aligned_storage.

src/core/SkLinearBitmapPipeline.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLinearBitmapPipeline_DEFINED
 #define SkLinearBitmapPipeline_DEFINED
 
@@ skipping 39 matching lines @@
         const SkPixmap& srcPixmap,
         float finalAlpha,
         SkXfermode::Mode xferMode,
         const SkImageInfo& dstInfo);
 
     ~SkLinearBitmapPipeline();
 
     void shadeSpan4f(int x, int y, SkPM4f* dst, int count);
     void blitSpan(int32_t x, int32_t y, void* dst, int count);
 
-    template <size_t N>
-    using Storage = typename std::aligned_storage<N, 16>::type;
-
     template<typename Base, size_t kSize, typename Next = void>
     class Stage {
     public:
         Stage() : fIsInitialized{false} {}
         ~Stage();
 
         template<typename Variant, typename... Args>
         void initStage(Next* next, Args&& ... args);
 
         template<typename Variant, typename... Args>
         void initSink(Args&& ... args);
 
         template <typename To, typename From>
         To* getInterface();
 
         // Copy this stage to `cloneToStage` with `next` as its next stage
         // (not necessarily the same as our next, you see), returning `cloneToStage`.
         // Note: There is no cloneSinkTo method because the code usually places the top part of
         // the pipeline on a new sampler.
         Base* cloneStageTo(Next* next, Stage* cloneToStage) const;
 
         Base* get() const { return reinterpret_cast<Base*>(&fSpace); }
         Base* operator->() const { return this->get(); }
         Base& operator*() const { return *(this->get()); }
 
     private:
         std::function<void (Next*, void*)> fStageCloner;
-        mutable Storage<kSize>             fSpace;
-        bool                               fIsInitialized;
+        struct SK_STRUCT_ALIGN(16) Space {
+            char space[kSize];
+        };
+        bool fIsInitialized;
+        mutable Space fSpace;
     };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PolyMemory
     template <typename Base, size_t kSize>
     class PolyMemory {
     public:
         PolyMemory() : fIsInitialized{false} { }
         ~PolyMemory() {
             if (fIsInitialized) {
                 this->get()->~Base();
             }
         }
         template<typename Variant, typename... Args>
         void init(Args&& ... args) {
             SkASSERTF(sizeof(Variant) <= sizeof(fSpace),
                       "Size Variant: %d, Space: %d", sizeof(Variant), sizeof(fSpace));
 
             new (&fSpace) Variant(std::forward<Args>(args)...);
             fIsInitialized = true;
         }
 
         Base* get() const { return reinterpret_cast<Base*>(&fSpace); }
         Base* operator->() const { return this->get(); }
         Base& operator*() const { return *(this->get()); }
 
     private:
-        mutable Storage<kSize> fSpace;
-        bool                   fIsInitialized;
+        struct SK_STRUCT_ALIGN(16) Space {
+            char space[kSize];
+        };
+        mutable Space fSpace;
+        bool          fIsInitialized;
 
     };
 
     class PointProcessorInterface;
     class SampleProcessorInterface;
     class BlendProcessorInterface;
     class DestinationInterface;
     class PixelAccessorInterface;
 
     // These values were generated by the assert above in Stage::init{Sink|Stage}.
@@ skipping 38 matching lines @@
 private:
     enum {
         kActualSize = sizeof(SkLinearBitmapPipeline),
         kPaddedSize = SkAlignPtr(kActualSize + 12),
     };
     void* fPipelineStorage[kPaddedSize / sizeof(void*)];
     SkLinearBitmapPipeline* fPipeline{nullptr};
 };
 
 #endif  // SkLinearBitmapPipeline_DEFINED