Stop flattening GrCoordTransforms in parent GrFragmentProcessors.

src/gpu/batches/GrAnalyticRectBatch.cpp

 /*
  * 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 "GrAnalyticRectBatch.h"
 
 #include "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrGeometryProcessor.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrResourceProvider.h"
 #include "SkRRect.h"
 #include "SkStrokeRec.h"
 #include "batches/GrVertexBatch.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
+#include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLUtil.h"
 
 namespace {
 
 struct RectVertex {
     SkPoint  fPos;
@@ skipping 82 matching lines @@
             // Setup position
             this->setupPosition(vertBuilder, gpArgs, rgp.inPosition()->fName);
 
             // emit transforms
             this->emitTransforms(vertBuilder,
                                  varyingHandler,
                                  uniformHandler,
                                  gpArgs->fPositionVar,
                                  rgp.inPosition()->fName,
                                  rgp.localMatrix(),
-                                 args.fTransformsIn,
-                                 args.fTransformsOut);
+                                 args.fFPCoordTransformHandler);
 
             // TODO: compute all these offsets, spans, and scales in the VS
             fragBuilder->codeAppendf("float insetW = min(1.0, %s.x) - 0.5;",
                                      widthHeightVary.fsIn());
             fragBuilder->codeAppendf("float insetH = min(1.0, %s.y) - 0.5;",
                                      widthHeightVary.fsIn());
             fragBuilder->codeAppend("float outset = 0.5;");
             // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
             // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
             fragBuilder->codeAppend("float spanW = insetW + outset;");
@@ skipping 52 matching lines @@
 
             }
         }
 
         static void GenKey(const GrGeometryProcessor& gp,
                            const GrGLSLCaps&,
                            GrProcessorKeyBuilder* b) {
             b->add32(0x0);
         }
 
-        void setData(const GrGLSLProgramDataManager& pdman,
-                     const GrPrimitiveProcessor& gp) override {}
-
-        void setTransformData(const GrPrimitiveProcessor& primProc,
-                              const GrGLSLProgramDataManager& pdman,
-                              int index,
-                              const SkTArray<const GrCoordTransform*, true>& transforms) override {
-            this->setTransformDataHelper(primProc.cast<RectGeometryProcessor>().fLocalMatrix, pdman,
-                                         index, transforms);
+        void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor& primProc,
+                     FPCoordTransformIter&& transformIter) override {
+            const RectGeometryProcessor& rgp = primProc.cast<RectGeometryProcessor>();
+            this->setTransformDataHelper(rgp.fLocalMatrix, pdman,&transformIter);
         }
 
     private:
         typedef GrGLSLGeometryProcessor INHERITED;
     };
 
     void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {
         GLSLProcessor::GenKey(*this, caps, b);
     }
 
@@ skipping 189 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AnalyticRectBatch) {
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrColor color = GrRandomColor(random);
     SkRect rect = GrTest::TestSquare(random);
     SkRect croppedRect = GrTest::TestSquare(random);
     SkRect bounds = GrTest::TestSquare(random);
     return new AnalyticRectBatch(color, viewMatrix, rect, croppedRect, bounds);
 }
 
 #endif