Make an embeddable container to hold linear pipelines.

src/core/SkBitmapProcShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapProcShader.h"
 #include "SkBitmapProcState.h"
 #include "SkBitmapProvider.h"
@@ skipping 111 matching lines @@
         : INHERITED(shader, rec, info)
     {
         // Save things off in case we need to build a blitter pipeline.
         fSrcPixmap = info->fPixmap;
         fAlpha = SkColorGetA(info->fPaintColor) / 255.0f;
         fXMode = info->fTileModeX;
         fYMode = info->fTileModeY;
         fFilterQuality = info->fFilterQuality;
         fMatrixTypeMask = info->fRealInvMatrix.getType();
 
-        // Need to ensure that our pipeline is created at a 16byte aligned address
-        fShaderPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fShaderStorage);
-        new (fShaderPipeline) SkLinearBitmapPipeline(info->fRealInvMatrix, info->fFilterQuality,
-                                                     info->fTileModeX, info->fTileModeY,
-                                                     info->fPaintColor,
-                                                     info->fPixmap);
+        fShaderPipeline.init(
+            info->fRealInvMatrix, info->fFilterQuality,
+            info->fTileModeX, info->fTileModeY,
+            info->fPaintColor,
+            info->fPixmap);
 
         // To implement the old shadeSpan entry-point, we need to efficiently convert our native
         // floats into SkPMColor. The SkXfermode::D32Procs do exactly that.
         //
         sk_sp<SkXfermode> xfer(SkXfermode::Make(SkXfermode::kSrc_Mode));
         fXferProc = SkXfermode::GetD32Proc(xfer.get(), 0);
     }
 
-    ~LinearPipelineContext() override {
-        // since we did a manual new, we need to manually destroy as well.
-        fShaderPipeline->~SkLinearBitmapPipeline();
-        if (fBlitterPipeline != nullptr) {
-            fBlitterPipeline->~SkLinearBitmapPipeline();
-        }
-    }
-
     void shadeSpan4f(int x, int y, SkPM4f dstC[], int count) override {
         fShaderPipeline->shadeSpan4f(x, y, dstC, count);
     }
 
     void shadeSpan(int x, int y, SkPMColor dstC[], int count) override {
         const int N = 128;
         SkPM4f  tmp[N];
 
         while (count > 0) {
             const int n = SkTMin(count, N);
             fShaderPipeline->shadeSpan4f(x, y, tmp, n);
             fXferProc(nullptr, dstC, tmp, n, nullptr);
             dstC += n;
             x += n;
             count -= n;
         }
     }
 
     bool onChooseBlitProcs(const SkImageInfo& dstInfo, BlitState* state) override {
         SkXfermode::Mode mode;
         if (!SkXfermode::AsMode(state->fXfer, &mode)) { return false; }
 
-        // Need to ensure that our pipeline is created at a 16byte aligned address
-        fBlitterPipeline = (SkLinearBitmapPipeline*)SkAlign16((intptr_t)fBlitterStorage);
         if (SkLinearBitmapPipeline::ClonePipelineForBlitting(
-            fBlitterPipeline, *fShaderPipeline,
+            &fBlitterPipeline, *fShaderPipeline,
             fMatrixTypeMask,
             fXMode, fYMode,
             fFilterQuality, fSrcPixmap,
             fAlpha, mode, dstInfo))
         {
-            state->fStorage[0] = fBlitterPipeline;
+            state->fStorage[0] = fBlitterPipeline.get();
             state->fBlitBW = &LinearPipelineContext::ForwardToPipeline;
 
             return true;
         }
 
-        // Did not successfully create a pipeline so don't destruct it.
-        fBlitterPipeline = nullptr;
         return false;
     }
 
     static void ForwardToPipeline(BlitState* state, int x, int y, const SkPixmap& dst, int count) {
         SkLinearBitmapPipeline* pipeline = static_cast<SkLinearBitmapPipeline*>(state->fStorage[0]);
         void* addr = dst.writable_addr32(x, y);
         pipeline->blitSpan(x, y, addr, count);
     }
 
-
 private:
-    enum {
-        kActualSize = sizeof(SkLinearBitmapPipeline),
-        kPaddedSize = SkAlignPtr(kActualSize + 12),
-    };
-    void* fShaderStorage[kPaddedSize / sizeof(void*)];
-    SkLinearBitmapPipeline* fShaderPipeline;
-    void* fBlitterStorage[kPaddedSize / sizeof(void*)];
-    SkLinearBitmapPipeline* fBlitterPipeline{nullptr};
-    SkXfermode::D32Proc     fXferProc;
-    SkPixmap                fSrcPixmap;
-    float                   fAlpha;
-    SkShader::TileMode      fXMode;
-    SkShader::TileMode      fYMode;
-    SkMatrix::TypeMask      fMatrixTypeMask;
-    SkFilterQuality         fFilterQuality;
+    SkEmbeddableLinearPipeline fShaderPipeline;
+    SkEmbeddableLinearPipeline fBlitterPipeline;
+    SkXfermode::D32Proc        fXferProc;
+    SkPixmap                   fSrcPixmap;
+    float                      fAlpha;
+    SkShader::TileMode         fXMode;
+    SkShader::TileMode         fYMode;
+    SkMatrix::TypeMask         fMatrixTypeMask;
+    SkFilterQuality            fFilterQuality;
 
     typedef BitmapProcInfoContext INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static bool choose_linear_pipeline(const SkShader::ContextRec& rec, const SkImageInfo& srcInfo) {
     // If we get here, we can reasonably use either context, respect the caller's preference
     //
     return SkShader::ContextRec::kPM4f_DstType == rec.fPreferredDstType;
@@ skipping 246 matching lines @@
         inner.reset(GrSimpleTextureEffect::Create(texture, matrix, params));
     }
 
     if (kAlpha_8_SkColorType == fRawBitmap.colorType()) {
         return GrFragmentProcessor::MulOutputByInputUnpremulColor(inner);
     }
     return GrFragmentProcessor::MulOutputByInputAlpha(inner);
 }
 
 #endif