Dependencies are now added between the drawTargets in GrPipeline

src/gpu/GrPipeline.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 "GrPipeline.h"
 
 #include "GrCaps.h"
+#include "GrDrawTarget.h"
 #include "GrGpu.h"
 #include "GrPipelineBuilder.h"
 #include "GrProcOptInfo.h"
 #include "GrXferProcessor.h"
 
 #include "batches/GrBatch.h"
 
 GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
                                  GrPipelineOptimizations* opts) {
     const GrPipelineBuilder& builder = *args.fPipelineBuilder;
@@ skipping 102 matching lines @@
 
     GrXPFactory::InvariantBlendedColor blendedColor;
     builder.fXPFactory->getInvariantBlendedColor(args.fColorPOI, &blendedColor);
     if (blendedColor.fWillBlendWithDst) {
         opts->fFlags |= GrPipelineOptimizations::kWillColorBlendWithDst_Flag;
     }
 
     return pipeline;
 }
 
+static void add_dependencies_for_processor(const GrFragmentProcessor* proc, GrRenderTarget* rt) {
+    for (int i = 0; i < proc->numChildProcessors(); ++i) {
+        // need to recurse
+        add_dependencies_for_processor(&proc->childProcessor(i), rt);
+    }
+
+    for (int i = 0; i < proc->numTextures(); ++i) {
+        GrTexture* texture = proc->textureAccess(i).getTexture();
+        SkASSERT(rt->getLastDrawTarget());
+        rt->getLastDrawTarget()->addDependency(texture);
+    }
+}
+
+void GrPipeline::addDependenciesTo(GrRenderTarget* rt) const {
+    for (int i = 0; i < fFragmentProcessors.count(); ++i) {
+        add_dependencies_for_processor(fFragmentProcessors[i].get(), rt);
+    }
+
+    if (fXferProcessor.get()) {
+        const GrXferProcessor* xfer = fXferProcessor.get();
+
+        for (int i = 0; i < xfer->numTextures(); ++i) {
+            GrTexture* texture = xfer->textureAccess(i).getTexture();   
+            SkASSERT(rt->getLastDrawTarget());
+            rt->getLastDrawTarget()->addDependency(texture);
+        }
+    }
+}
+
 void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelineBuilder,
                                                 GrXferProcessor::OptFlags flags,
                                                 const GrProcOptInfo& colorPOI,
                                                 const GrProcOptInfo& coveragePOI,
                                                 int* firstColorProcessorIdx,
                                                 int* firstCoverageProcessorIdx) {
     fReadsFragPosition = fXferProcessor->willReadFragmentPosition();
 
     if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) ||
         (flags & GrXferProcessor::kOverrideColor_OptFlag)) {
@@ skipping 34 matching lines @@
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }