Use alignas to force alignment.

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 60 matching lines @@
 
         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* 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;
-        struct SK_STRUCT_ALIGN(16) Space {
-            char space[kSize];
-        };
-        bool fIsInitialized;
-        mutable Space fSpace;
+        // This could be implemented using std::aligned_storage, but MSVC does not implement this. Use the

[mtklein_C, 2016/11/03 20:47:36]

This code is clearer and less reinterpret_cast-y than the version with
std::aligned_storage.  This is not a workaround.  It's the ideal implementation.

Let's remove this comment.

+        // work around from:
+        // https://connect.microsoft.com/VisualStudio/feedback/details/1559873/std-aligned-storage-cannot-align-type-with-16-byte
+        mutable alignas(16) char           fSpace[kSize];
+        bool                               fIsInitialized;
     };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // 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* get() const { return reinterpret_cast<Base*>(fSpace); }
         Base* operator->() const { return this->get(); }
         Base& operator*() const { return *(this->get()); }
 
     private:
-        struct SK_STRUCT_ALIGN(16) Space {
-            char space[kSize];
-        };
-        mutable Space fSpace;
-        bool          fIsInitialized;
+        mutable alignas(16) char fSpace[kSize];
+        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}.
     using MatrixStage  = Stage<PointProcessorInterface,    160, PointProcessorInterface>;
     using TileStage    = Stage<PointProcessorInterface,    160, SampleProcessorInterface>;
     using SampleStage  = Stage<SampleProcessorInterface,   160, BlendProcessorInterface>;
-    using BlenderStage = Stage<BlendProcessorInterface,     40>;
+    using BlenderStage = Stage<BlendProcessorInterface,     48>;
     using Accessor     = PolyMemory<PixelAccessorInterface, 64>;
 
 private:
     PointProcessorInterface* fFirstStage;
     MatrixStage              fMatrixStage;
     TileStage                fTileStage;
     SampleStage              fSampleStage;
     BlenderStage             fBlenderStage;
     DestinationInterface*    fLastStage;
     Accessor                 fAccessor;
@@ skipping 24 matching lines @@
 private:
     enum {
         kActualSize = sizeof(SkLinearBitmapPipeline),
         kPaddedSize = SkAlignPtr(kActualSize + 12),
     };
     void* fPipelineStorage[kPaddedSize / sizeof(void*)];
     SkLinearBitmapPipeline* fPipeline{nullptr};
 };
 
 #endif  // SkLinearBitmapPipeline_DEFINED