adding new GM to demostrate new shadows

src/core/SkShadowShader.cpp

Index: src/core/SkShadowShader.cpp
diff --git a/src/core/SkShadowShader.cpp b/src/core/SkShadowShader.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b969383be54c24fcfe9e99b502091dc33dafaa2a
--- /dev/null
+++ b/src/core/SkShadowShader.cpp
@@ -0,0 +1,565 @@
+/*
+ * Copyright 2016 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 "SkShadowShader.h"
+#include "SkPoint3.h"
+#include "SkReadBuffer.h"
+#include "SkLights.h"
+
+////////////////////////////////////////////////////////////////////////////
+#define SK_MAX_NON_AMBIENT_LIGHTS 4
+
+/** \class SkShadowShaderImpl
+    This subclass of shader applies shadowing
+*/
+class SkShadowShaderImpl : public SkShader {
+public:
+    /** Create a new shadowing shader that shadows
+        @param to do        to do
+    */
+    SkShadowShaderImpl(sk_sp<SkShader> povDepthShader,
+                       sk_sp<SkShader> diffuseShader,
+                       sk_sp<SkLights> lights)
+            : povDepthShader(std::move(povDepthShader))
+            , diffuseShader(std::move(diffuseShader))
+            , fLights(std::move(lights)) { }
+
+    bool isOpaque() const override;
+
+#if SK_SUPPORT_GPU
+    sk_sp<GrFragmentProcessor> asFragmentProcessor(GrContext*,
+                                                   const SkMatrix& viewM,
+                                                   const SkMatrix* localMatrix,
+                                                   SkFilterQuality,
+                                                   SkSourceGammaTreatment) const override;
+#endif
+
+    class ShadowShaderContext : public SkShader::Context {
+    public:
+        // The context takes ownership of the states. It will call their destructors
+        // but will NOT free the memory.
+        ShadowShaderContext(const SkShadowShaderImpl&, const ContextRec&,
+                            SkShader::Context* povDepthContext,
+                            SkShader::Context* diffuseContext,
+                            void* heapAllocated);
+
+        ~ShadowShaderContext() override;
+
+        void shadeSpan(int x, int y, SkPMColor[], int count) override;
+
+        uint32_t getFlags() const override { return fFlags; }
+
+    private:
+        SkShader::Context*        fDiffuseContext1;
+        SkShader::Context*        fDiffuseContext2;
+        uint32_t                  fFlags;
+
+        void* fHeapAllocated;
+
+        typedef SkShader::Context INHERITED;
+    };
+

[robertphillips, 2016/07/27 18:52:59]

I think these two lines are supposed to be tabbed over

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+SK_TO_STRING_OVERRIDE()
+SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkShadowShaderImpl)
+
+protected:
+    void flatten(SkWriteBuffer&) const override;
+    size_t onContextSize(const ContextRec&) const override;
+    Context* onCreateContext(const ContextRec&, void*) const override;
+
+private:
+    sk_sp<SkShader> povDepthShader;
+    sk_sp<SkShader> diffuseShader;
+    sk_sp<SkLights> fLights;
+
+    friend class SkShadowShader;
+
+    typedef SkShader INHERITED;
+};
+
+////////////////////////////////////////////////////////////////////////////
+
+#if SK_SUPPORT_GPU
+
+#include "GrCoordTransform.h"
+#include "GrFragmentProcessor.h"
+#include "GrInvariantOutput.h"
+#include "GrTextureAccess.h"
+#include "glsl/GrGLSLFragmentProcessor.h"
+#include "glsl/GrGLSLFragmentShaderBuilder.h"
+#include "glsl/GrGLSLProgramDataManager.h"
+#include "glsl/GrGLSLUniformHandler.h"
+#include "SkGr.h"
+#include "SkGrPriv.h"
+#include "SkSpecialImage.h"
+#include "SkImage_Base.h"
+#include "SkImageInfo.h"
+#include "GrContext.h"
+#include "GrContextOptions.h"
+
+class ShadowFP : public GrFragmentProcessor {
+public:
+    ShadowFP(sk_sp<GrFragmentProcessor> povDepth,
+             sk_sp<GrFragmentProcessor> diffuse,
+             sk_sp<SkLights> lights,
+             GrContext* context) {
+
+        // fuse all ambient lights into a single one
+        fAmbientColor.set(0.0f, 0.0f, 0.0f);
+
+        fGrContext = context;

[jvanverth1, 2016/07/27 17:46:04]

Do you use this anywhere else? If not, you don't need to store it in the class.
If so, we usually just use the name fContext.

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+
+        fNumDirLights = 0; // refers to directional lights.
+        for (int i = 0; i < lights->numLights(); ++i) {
+            if (SkLights::Light::kAmbient_LightType == lights->light(i).type()) {
+                fAmbientColor += lights->light(i).color();
+            } else if (fNumDirLights < SK_MAX_NON_AMBIENT_LIGHTS){
+                fNumDirLights++;

[robertphillips, 2016/07/27 18:52:59]

I think you need to index by fNumDirLights (in the LHS) in the following
assignments (the RHS remain being indexed by 'i'). This also means you need to
defer the increment of fNumDirLights until the end of this if-block.

[vjiaoblack, 2016/07/28 17:17:52]

Done.

+                fLightColor[i] = lights->light(i).color();
+                fLightDir[i] = lights->light(i).dir();
+                SkImage_Base* shadowMap = ((SkImage_Base*)lights->light(i).getShadowMap().get());
+
+                // this sk_sp gets deleted when the ShadowFP is destroyed, and frees the GrTexture*

[robertphillips, 2016/07/27 18:52:59]

IIUC, asTextureRef returns a "GrTexture*" so I think you just need:

fTexture[i].reset(shadowMap->...);

I'm surprised the std::move isn't complaining.

[vjiaoblack, 2016/07/28 17:17:52]

Done.

+                fTexture[i] = sk_sp<GrTexture>(std::move(shadowMap->asTextureRef(fGrContext,
+                                                                        GrTextureParams::ClampNoFilter(),

[jvanverth1, 2016/07/27 17:46:04]

Still over 100 chars.

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+                                                                        SkSourceGammaTreatment::kIgnore)));
+                fDepthMapAccess[i].reset(fTexture[i].get());
+                this->addTextureAccess(&fDepthMapAccess[i]);
+            }
+        }
+
+        this->registerChildProcessor(std::move(povDepth)); 
+        this->registerChildProcessor(std::move(diffuse));
+        this->initClassID<ShadowFP>();
+    }
+
+    class GLSLShadowFP : public GrGLSLFragmentProcessor {
+    public:
+        GLSLShadowFP() { }
+
+        void emitCode(EmitArgs& args) override {
+
+            GrGLSLFragmentBuilder* fragBuilder = args.fFragBuilder;
+            GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
+
+            // add uniforms
+            int32_t numLights = args.fFp.cast<ShadowFP>().fNumDirLights;
+
+            const char* lightDirUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
+            const char* lightColorUniName[SK_MAX_NON_AMBIENT_LIGHTS] = {nullptr};
+
+            for (int i = 0; i < numLights; i++) {
+                lightDirUniName[i] = nullptr;
+                fLightDirUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                             kVec3f_GrSLType, kDefault_GrSLPrecision,

[jvanverth1, 2016/07/27 17:46:04]

Over 100 chars?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+                                                             "LightDir" + (i+1), &lightDirUniName[i]);
+
+                lightColorUniName[i] = nullptr;
+                fLightColorUni[i] = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                               kVec3f_GrSLType, kDefault_GrSLPrecision,

[jvanverth1, 2016/07/27 17:46:04]

Over 100 chars?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+                                                               "LightColor" + (i+1), &lightColorUniName[i]);
+            }
+
+            SkString povDepth("povDepth");
+            this->emitChild(0, nullptr, &povDepth, args);
+
+            SkString diffuseColor("inDiffuseColor");
+            this->emitChild(1, nullptr, &diffuseColor, args);
+
+            SkString depthMaps[SK_MAX_NON_AMBIENT_LIGHTS];
+
+            for (int i = 0; i < numLights; i++) {
+                const char* povCoord = "povCoord" + i;
+
+                // vMatrixCoord_0_1_Stage0 is the texture sampler coordinates.
+                // povDepth.b * 255 scales it to 0 - 255, bringing it to world space,

[robertphillips, 2016/07/27 18:52:59]

Is the 400 coming from the fact that the GM has a width & height of 400?

[vjiaoblack, 2016/07/28 17:17:51]

Yes. I'll pass this stuff in when I migrate to a Sample, it'll be much better to
test with.

[robertphillips, 2016/07/28 19:47:25]

Well, isn't the 400 value going to have to vary with each shadow map. That is,
do you need to be passing it up as a uniform?

For now, add a TODO?

+                // and the / 400 brings it back to a sampler coordinate, 0 - 1
+                fragBuilder->codeAppendf("vec2 %s = vMatrixCoord_0_1_Stage0 + "
+                                                   "(vec2(%s) * povDepth.b * 255 / 400);",
+                                         povCoord, lightDirUniName[i]);
+
+                fragBuilder->appendTextureLookup(&depthMaps[i], args.fTexSamplers[i],
+                                                 povCoord,
+                                                 kVec2f_GrSLType);
+            }
+
+            const char* ambientColorUniName = nullptr;
+            fAmbientColorUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
+                                                          kVec3f_GrSLType, kDefault_GrSLPrecision,
+                                                          "AmbientColor", &ambientColorUniName);
+
+            fragBuilder->codeAppendf("vec4 resultDiffuseColor = %s;", diffuseColor.c_str());
+
+            // all the normal vectors point straight up
+            SkString totalLightColor("totalLightColor");
+            fragBuilder->codeAppendf("vec3 %s = vec3(0,0,0);",
+                                     totalLightColor.c_str());
+
+            for (int i = 0; i < numLights; i++) {
+                fragBuilder->codeAppendf("if (%s.b >= %s.b) {",
+                                         povDepth.c_str(), depthMaps[i].c_str());
+                fragBuilder->codeAppendf("%s += dot(vec3(0,0,1), %s) * %s;",
+                                         totalLightColor.c_str(),
+                                         lightDirUniName[i],
+                                         lightColorUniName[i]);
+                fragBuilder->codeAppendf("}");
+            }
+
+            fragBuilder->codeAppendf("%s += %s;",
+                                     totalLightColor.c_str(),
+                                     ambientColorUniName);
+
+            fragBuilder->codeAppendf("resultDiffuseColor *= vec4(%s, 1);",
+                                     totalLightColor.c_str());
+
+            fragBuilder->codeAppendf("%s = resultDiffuseColor;", args.fOutputColor);
+        }
+
+        static void GenKey(const GrProcessor& proc, const GrGLSLCaps&,
+                           GrProcessorKeyBuilder* b) {
+            const ShadowFP& shadowFP = proc.cast<ShadowFP>();
+            b->add32(shadowFP.fNumDirLights);
+        }
+
+    protected:
+        void onSetData(const GrGLSLProgramDataManager& pdman, const GrProcessor& proc) override {
+            const ShadowFP &shadowFP = proc.cast<ShadowFP>();
+
+            fNumDirLights = shadowFP.numLights();
+
+            for (int i = 0; i < fNumDirLights; i++) {
+                const SkVector3 &lightDir = shadowFP.lightDir(i);
+                if (lightDir != fLightDir[i]) {
+                    pdman.set3fv(fLightDirUni[i], 1, &lightDir.fX);
+                    fLightDir[i] = lightDir;
+                }
+                const SkColor3f &lightColor = shadowFP.lightColor(i);
+                if (lightColor != fLightColor[i]) {
+                    pdman.set3fv(fLightColorUni[i], 1, &lightColor.fX);
+                    fLightColor[i] = lightColor;
+                }
+            }
+
+            const SkColor3f& ambientColor = shadowFP.ambientColor();
+            if (ambientColor != fAmbientColor) {
+                pdman.set3fv(fAmbientColorUni, 1, &ambientColor.fX);
+                fAmbientColor = ambientColor;
+            }
+        }
+
+    private:
+        SkVector3 fLightDir[SK_MAX_NON_AMBIENT_LIGHTS];

[robertphillips, 2016/07/27 18:52:59]

Shouldn't these other 4s be SK_MAX_NON_AMBIENT_LIGHTS too?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+        GrGLSLProgramDataManager::UniformHandle fLightDirUni[4];
+        SkColor3f fLightColor[SK_MAX_NON_AMBIENT_LIGHTS];
+        GrGLSLProgramDataManager::UniformHandle fLightColorUni[4];
+
+        SkColor3f fAmbientColor;
+        GrGLSLProgramDataManager::UniformHandle fAmbientColorUni;
+
+        int fNumDirLights;
+    };
+
+    void onGetGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
+        GLSLShadowFP::GenKey(*this, caps, b);
+    }
+
+    const char* name() const override { return "shadowFP"; }
+
+    void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
+        inout->mulByUnknownFourComponents();
+    }
+    int32_t numLights() const { return fNumDirLights; }
+    const SkColor3f& ambientColor() const { return fAmbientColor; }
+    const SkVector3& lightDir(int i) const {
+        SkASSERT(i < fNumDirLights);
+        return fLightDir[i];
+    }
+    const SkVector3& lightColor(int i) const {
+        SkASSERT(i < fNumDirLights);
+        return fLightColor[i];
+    }
+
+private:
+    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new GLSLShadowFP; }
+
+    bool onIsEqual(const GrFragmentProcessor& proc) const override {
+        const ShadowFP& shadowFP = proc.cast<ShadowFP>();

[robertphillips, 2016/07/27 18:52:59]

You could just say:

if (fAmbientColor != shadowFP.fAmbientColor || fNumDirLights !=
shadowFP.fNumDirLights) {
   return false;
}

and skip creating & using the isEqual boolean.

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+        bool isEqual = fAmbientColor == shadowFP.fAmbientColor &&
+                       fNumDirLights == shadowFP.fNumDirLights;
+
+        for (int i = 0; i < fNumDirLights && isEqual; i++) {

[robertphillips, 2016/07/27 18:52:59]

Similarly, in here you can just return false if any of the individual lights
aren't equal

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+            isEqual = isEqual && fLightDir[i] == shadowFP.fLightDir[i] &&
+                                 fLightColor[i] == shadowFP.fLightColor[i];
+        }
+
+        return isEqual;
+    }
+
+    int              fNumDirLights;
+

[robertphillips, 2016/07/27 18:52:59]

SK_MAX_NON_AMBIENT_LIGHTS ?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+    SkVector3        fLightDir[4];
+    SkColor3f        fLightColor[4];
+    GrTextureAccess  fDepthMapAccess[4];
+    sk_sp<GrTexture> fTexture[4];
+    GrContext*       fGrContext;
+
+    SkColor3f        fAmbientColor;
+};
+
+////////////////////////////////////////////////////////////////////////////
+
+sk_sp<GrFragmentProcessor> SkShadowShaderImpl::asFragmentProcessor(
+        GrContext* context,
+        const SkMatrix& viewM,
+        const SkMatrix* localMatrix,
+        SkFilterQuality filterQuality,
+        SkSourceGammaTreatment gammaTreatment) const {
+

[robertphillips, 2016/07/27 18:52:59]

Can you keep the method name next to the '->' and then wrap the parameters?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+    sk_sp<GrFragmentProcessor> povDepthFP = povDepthShader->
+            asFragmentProcessor(context, viewM, localMatrix, filterQuality, gammaTreatment);
+
+    sk_sp<GrFragmentProcessor> diffuseFP = diffuseShader->
+            asFragmentProcessor(context, viewM, localMatrix, filterQuality, gammaTreatment);
+

[robertphillips, 2016/07/27 18:52:59]

Seems like you want some std::moves for diffuseFP & povDepthFP

[vjiaoblack, 2016/07/28 17:17:52]

Done.

+    sk_sp<GrFragmentProcessor> shadowfp = sk_make_sp<ShadowFP>(povDepthFP, diffuseFP, fLights, context);

[jvanverth1, 2016/07/27 17:46:04]

100 chars

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+    return shadowfp;
+}
+
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+
+bool SkShadowShaderImpl::isOpaque() const {
+    return povDepthShader->isOpaque() || diffuseShader->isOpaque();
+}
+
+SkShadowShaderImpl::ShadowShaderContext::ShadowShaderContext(
+        const SkShadowShaderImpl& shader, const ContextRec& rec,
+        SkShader::Context* povDepthContext,
+        SkShader::Context* diffuseContext,
+        void* heapAllocated)
+        : INHERITED(shader, rec)
+        , fDiffuseContext1(povDepthContext)
+        , fDiffuseContext2(diffuseContext)
+        , fHeapAllocated(heapAllocated) {
+    bool isOpaque = shader.isOpaque();
+
+    // update fFlags
+    uint32_t flags = 0;
+    if (isOpaque && (255 == this->getPaintAlpha())) {
+        flags |= kOpaqueAlpha_Flag;
+    }
+
+    fFlags = flags;
+}
+
+SkShadowShaderImpl::ShadowShaderContext::~ShadowShaderContext() {
+    // The dependencies have been created outside of the context on memory that was allocated by
+    // the onCreateContext() method. Call the destructors and free the memory.
+    fDiffuseContext1->~Context();
+    fDiffuseContext2->~Context();
+
+    sk_free(fHeapAllocated);
+}
+
+static inline SkPMColor convert(SkColor3f color, U8CPU a) {
+    if (color.fX <= 0.0f) {
+        color.fX = 0.0f;
+    } else if (color.fX >= 255.0f) {
+        color.fX = 255.0f;
+    }
+
+    if (color.fY <= 0.0f) {
+        color.fY = 0.0f;
+    } else if (color.fY >= 255.0f) {
+        color.fY = 255.0f;
+    }
+
+    if (color.fZ <= 0.0f) {
+        color.fZ = 0.0f;
+    } else if (color.fZ >= 255.0f) {
+        color.fZ = 255.0f;
+    }

[robertphillips, 2016/07/27 18:52:59]

rm the printf

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+//    printf();
+    return SkPreMultiplyARGB(a, (int) color.fX,  (int) color.fY, (int) color.fZ);
+}
+
+// larger is better (fewer times we have to loop), but we shouldn't
+// take up too much stack-space (each one here costs 16 bytes)
+#define BUFFER_MAX 16
+void SkShadowShaderImpl::ShadowShaderContext::shadeSpan(int x, int y,
+                                                        SkPMColor result[], int count) {
+    const SkShadowShaderImpl& lightShader = static_cast<const SkShadowShaderImpl&>(fShader);
+
+    SkPMColor diffuse[BUFFER_MAX];
+    SkPoint3 normals[BUFFER_MAX];
+
+    do {
+        int n = SkTMin(count, BUFFER_MAX);
+
+        fDiffuseContext1->shadeSpan(x, y, diffuse, n);
+        fDiffuseContext2->shadeSpan(x, y, diffuse, n);
+
+        for (int i = 0; i < n; ++i) {
+
+            SkColor diffColor = SkUnPreMultiply::PMColorToColor(diffuse[i]);
+
+            SkColor3f accum = SkColor3f::Make(0.0f, 0.0f, 0.0f);
+            // This is all done in linear unpremul color space (each component 0..255.0f though)
+            for (int l = 0; l < lightShader.fLights->numLights(); ++l) {
+                const SkLights::Light& light = lightShader.fLights->light(l);
+
+                if (SkLights::Light::kAmbient_LightType == light.type()) {
+                    accum += light.color().makeScale(255.0f);
+                } else {
+                    SkScalar NdotL = normals[i].dot(light.dir());
+                    if (NdotL < 0.0f) {
+                        NdotL = 0.0f;
+                    }
+

[robertphillips, 2016/07/27 18:52:59]

It seems like pegging NdotL is going to short circuit all lighting. Why even
compute NdotL?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+                    NdotL = 1.0f;
+
+                    accum.fX += light.color().fX * SkColorGetR(diffColor) * NdotL;
+                    accum.fY += light.color().fY * SkColorGetG(diffColor) * NdotL;
+                    accum.fZ += light.color().fZ * SkColorGetB(diffColor) * NdotL;
+                }
+            }
+
+            result[i] = convert(accum, SkColorGetA(diffColor));
+        }
+
+        result += n;
+        x += n;
+        count -= n;
+    } while (count > 0);
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+#ifndef SK_IGNORE_TO_STRING
+void SkShadowShaderImpl::toString(SkString* str) const {
+    str->appendf("ShadowShader: ()");
+}
+#endif
+
+sk_sp<SkFlattenable> SkShadowShaderImpl::CreateProc(SkReadBuffer& buf) {
+
+    // Discarding SkShader flattenable params
+    bool hasLocalMatrix = buf.readBool();
+    SkAssertResult(!hasLocalMatrix);
+
+    int numLights = buf.readInt();
+
+    SkLights::Builder builder;
+
+    for (int l = 0; l < numLights; ++l) {
+        bool isAmbient = buf.readBool();
+
+        SkColor3f color;
+        if (!buf.readScalarArray(&color.fX, 3)) {
+            return nullptr;
+        }
+
+        if (isAmbient) {
+            builder.add(SkLights::Light(color));
+        } else {
+            SkVector3 dir;
+            if (!buf.readScalarArray(&dir.fX, 3)) {
+                return nullptr;
+            }
+            builder.add(SkLights::Light(color, dir));
+        }
+    }
+
+    sk_sp<SkLights> lights(builder.finish());
+
+    sk_sp<SkShader> povDepthShader(buf.readFlattenable<SkShader>());
+    sk_sp<SkShader> diffuseShader(buf.readFlattenable<SkShader>());
+
+    return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
+                                          std::move(diffuseShader),
+                                          std::move(lights));
+}
+
+void SkShadowShaderImpl::flatten(SkWriteBuffer& buf) const {
+    this->INHERITED::flatten(buf);
+
+    buf.writeInt(fLights->numLights());
+    for (int l = 0; l < fLights->numLights(); ++l) {
+        const SkLights::Light& light = fLights->light(l);
+
+        bool isAmbient = SkLights::Light::kAmbient_LightType == light.type();
+
+        buf.writeBool(isAmbient);
+        buf.writeScalarArray(&light.color().fX, 3);
+        if (!isAmbient) {
+            buf.writeScalarArray(&light.dir().fX, 3);
+        }
+    }
+
+    buf.writeFlattenable(povDepthShader.get());
+    buf.writeFlattenable(diffuseShader.get());
+}
+
+size_t SkShadowShaderImpl::onContextSize(const ContextRec& rec) const {
+    return sizeof(ShadowShaderContext);
+}
+
+SkShader::Context* SkShadowShaderImpl::onCreateContext(const ContextRec& rec,
+                                                       void* storage) const {
+    size_t heapRequired = povDepthShader->contextSize(rec) +

[robertphillips, 2016/07/27 18:52:59]

extra space ?

[vjiaoblack, 2016/07/28 17:17:52]

Done.

+                           diffuseShader->contextSize(rec);
+
+    void* heapAllocated = sk_malloc_throw(heapRequired);
+
+    void* povDepthContextStorage = heapAllocated;
+
+    SkShader::Context* povDepthContext = povDepthShader->createContext(rec, povDepthContextStorage);
+    if (!povDepthContext) {
+        sk_free(heapAllocated);
+        return nullptr;
+    }
+
+    void* diffuseContextStorage = (char*)heapAllocated + povDepthShader->contextSize(rec);
+

[robertphillips, 2016/07/27 18:52:59]

I don't think we need the '2' suffix here

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+    SkShader::Context* diffuseContext2 = diffuseShader->createContext(rec, diffuseContextStorage);
+    if (!diffuseContext2) {
+        sk_free(heapAllocated);
+        return nullptr;
+    }
+

[robertphillips, 2016/07/27 18:52:59]

extra '\n' here ?

[vjiaoblack, 2016/07/28 17:17:51]

Done.

+
+    return new (storage) ShadowShaderContext(*this, rec, povDepthContext, diffuseContext2,
+                                             heapAllocated);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+sk_sp<SkShader> SkShadowShader::Make(sk_sp<SkShader> povDepthShader,
+                                     sk_sp<SkShader> diffuseShader,
+                                     sk_sp<SkLights> lights) {
+    if (!povDepthShader || !diffuseShader) {
+        // TODO: Use paint's color in absence of a diffuseShader
+        // TODO: Use a default implementation of normalSource instead
+        return nullptr;
+    }
+
+    return sk_make_sp<SkShadowShaderImpl>(std::move(povDepthShader),
+                                          std::move(diffuseShader),
+                                          std::move(lights));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShadowShader)
+    SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkShadowShaderImpl)
+SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
+
+///////////////////////////////////////////////////////////////////////////////