Revert of Stop flattening GrCoordTransforms in parent GrFragmentProcessors.

src/gpu/GrFragmentProcessor.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
-#include "GrPipeline.h"
 #include "GrProcOptInfo.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 
 GrFragmentProcessor::~GrFragmentProcessor() {
     // If we got here then our ref count must have reached zero, so we will have converted refs
@@ skipping 53 matching lines @@
 }
 
 void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
     // Can't add transforms after registering any children since their transforms have already been
     // bubbled up into our fCoordTransforms array
     SkASSERT(fChildProcessors.empty());
 
     fCoordTransforms.push_back(transform);
     fUsesLocalCoords = fUsesLocalCoords || transform->sourceCoords() == kLocal_GrCoordSet;
     SkDEBUGCODE(transform->setInProcessor();)
+    fNumTransformsExclChildren++;
 }
 
 int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
-    // Append the child's textures array to our textures array
+    // Append the child's transforms to our transforms array and the child's textures array to our
+    // textures array
+    if (!child->fCoordTransforms.empty()) {
+        fCoordTransforms.push_back_n(child->fCoordTransforms.count(),
+                                     child->fCoordTransforms.begin());
+    }
     if (!child->fTextureAccesses.empty()) {
         fTextureAccesses.push_back_n(child->fTextureAccesses.count(),
                                      child->fTextureAccesses.begin());
     }
 
     this->combineRequiredFeatures(*child);
 
     if (child->usesLocalCoords()) {
         fUsesLocalCoords = true;
     }
     if (child->usesDistanceVectorField()) {
         fUsesDistanceVectorField = true;
     }
 
     int index = fChildProcessors.count();
     fChildProcessors.push_back(child.release());
 
     return index;
 }
 
 void GrFragmentProcessor::notifyRefCntIsZero() const {
     // See comment above GrProgramElement for a detailed explanation of why we do this.
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         fChildProcessors[i]->addPendingExecution();
         fChildProcessors[i]->unref();
     }
 }
 
 bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
-    if (this->numCoordTransforms() != that.numCoordTransforms()) {
+    if (this->numTransforms() != that.numTransforms()) {
         return false;
     }
-    int count = this->numCoordTransforms();
+    int count = this->numTransforms();
     for (int i = 0; i < count; ++i) {
         if (this->coordTransform(i) != that.coordTransform(i)) {
             return false;
         }
     }
     return true;
 }
 
 sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
     sk_sp<GrFragmentProcessor> fp) {
@@ skipping 264 matching lines @@
     } else {
         series += firstIdx;
         cnt -= firstIdx;
     }
 
     if (1 == cnt) {
         return series[0];
     }
     return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
 }
-
-//////////////////////////////////////////////////////////////////////////////
-
-GrFragmentProcessor::Iter::Iter(const GrPipeline& pipeline) {
-    for (int i = pipeline.numFragmentProcessors() - 1; i >= 0; --i) {
-        fFPStack.push_back(&pipeline.getFragmentProcessor(i));
-    }
-}
-
-const GrFragmentProcessor* GrFragmentProcessor::Iter::next() {
-    if (fFPStack.empty()) {
-        return nullptr;
-    }
-    const GrFragmentProcessor* back = fFPStack.back();
-    fFPStack.pop_back();
-    for (int i = back->numChildProcessors() - 1; i >= 0; --i) {
-        fFPStack.push_back(&back->childProcessor(i));
-    }
-    return back;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-const GrCoordTransform* GrFragmentProcessor::CoordTransformIter::next() {
-    if (!fCurrFP) {
-        return nullptr;
-    }
-    while (fCTIdx == fCurrFP->numCoordTransforms()) {
-        fCTIdx = 0;
-        fCurrFP = fFPIter.next();
-        if (!fCurrFP) {
-            return nullptr;
-        }
-    }
-    return &fCurrFP->coordTransform(fCTIdx++);
-}