Refactoring of CPU NormalMap handling out into its own class

src/core/SkLightingShader.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkLightingShader_DEFINED
 #define SkLightingShader_DEFINED
 
 #include "SkLights.h"
 #include "SkShader.h"
 
 class SkBitmap;
 class SkMatrix;
 
 class SK_API SkLightingShader {
 public:
-    /** Abstract class that generates or reads in normals for use by SkLightingShader. Currently
-        implements the GPU side only. Not to be used as part of the API yet. Used internally by
-        SkLightingShader.
+    /** Abstract class that generates or reads in normals for use by SkLightingShader. Not to be
+        used as part of the API yet. Used internally by SkLightingShader.
     */
     class NormalSource : public SkFlattenable {
     public:
         virtual ~NormalSource();
 
 #if SK_SUPPORT_GPU
 
         /** Returns a fragment processor that takes no input and outputs a normal (already rotated)
             as its output color. To be used as a child fragment processor.
         */
         virtual sk_sp<GrFragmentProcessor> asFragmentProcessor(
                 GrContext* context,
                 const SkMatrix& viewM,
                 const SkMatrix* localMatrix,
                 SkFilterQuality filterQuality,
                 SkSourceGammaTreatment gammaTreatment) const = 0;
 #endif
 
+        class Provider {
+        public:
+            virtual ~Provider(){};

[egdaniel, 2016/06/16 13:48:10]

nit: space between () and {}

[dvonbeck, 2016/06/16 22:05:40]

Done.

+
+            /** Called for each span of the object being drawn on the CPU. Your subclass should set
+                the appropriate normals that correspond to the specified device coordinates.
+            */
+            virtual void fillScanLine(int x, int y, SkPoint3 output[], int count) const = 0;
+
+            /** Returns the maximum count that can be passed into 'fillScanLine' for an output
+                buffer of size 'count'.
+            */
+            virtual int maxCountForFillScanLine(int count) const = 0;
+        };
+
+        /** Returns an instance of 'Provider' that provides normals for the CPU pipeline. The
+            necessary data will be initialized in place at 'storage'.
+        */
+        virtual Provider* asProvider(const SkShader::ContextRec& rec, void* storage) const = 0;
+
+        /** Amount of memory needed to store a provider object and its dependencies.
+         */
+        virtual size_t providerSize() const = 0;
+
         SK_DEFINE_FLATTENABLE_TYPE(NormalSource)
     };
 
     /** Returns a normal source that provides normals sourced from the the normal map argument.
         Not to be used as part of the API yet. Used internally by SkLightingShader.
 
         @param  normal                the normal map
         @param  invNormRotation       rotation applied to the normal map's normals
         @param  normLocalM            the local matrix for the normal map
 
@@ skipping 48 matching lines @@
         (127, 127, 0).
     */
     static sk_sp<SkShader> Make(const SkBitmap& diffuse, const SkBitmap& normal,
                                 sk_sp<SkLights> lights, const SkVector& invNormRotation,
                                 const SkMatrix* diffLocalMatrix, const SkMatrix* normLocalMatrix);
 
     SK_DECLARE_FLATTENABLE_REGISTRAR_GROUP()
 };
 
 #endif