Style bikeshed - remove extraneous whitespace

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"
@@ skipping 28 matching lines @@
                                                                         builder.hasMixedSamples(),
                                                                         &args.fDstTexture));
     }
    GrColor overrideColor = GrColor_ILLEGAL;
     if (args.fOpts.fColorPOI.firstEffectiveProcessorIndex() != 0) {
         overrideColor = args.fOpts.fColorPOI.inputColorToFirstEffectiveProccesor();
     }
 
     GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
 
-    const GrXferProcessor* xpForOpts = xferProcessor ? xferProcessor.get() : 
+    const GrXferProcessor* xpForOpts = xferProcessor ? xferProcessor.get() :
                                                        &GrPorterDuffXPFactory::SimpleSrcOverXP();
     optFlags = xpForOpts->getOptimizations(args.fOpts,
                                            builder.getStencil().doesWrite(),
                                            &overrideColor,
                                            *args.fCaps);
 
     // When path rendering the stencil settings are not always set on the GrPipelineBuilder
     // so we must check the draw type. In cases where we will skip drawing we simply return a
     // null GrPipeline.
     if (GrXferProcessor::kSkipDraw_OptFlag & optFlags) {
@@ skipping 25 matching lines @@
         pipeline->fFlags |= kDisableOutputConversionToSRGB_Flag;
     }
 
     int firstColorProcessorIdx = args.fOpts.fColorPOI.firstEffectiveProcessorIndex();
 
     // TODO: Once we can handle single or four channel input into coverage GrFragmentProcessors
     // then we can use GrPipelineBuilder's coverageProcInfo (like color above) to set this initial
     // information.
     int firstCoverageProcessorIdx = 0;
 
-    pipeline->adjustProgramFromOptimizations(builder, optFlags, args.fOpts.fColorPOI, 
-                                             args.fOpts.fCoveragePOI, &firstColorProcessorIdx, 
+    pipeline->adjustProgramFromOptimizations(builder, optFlags, args.fOpts.fColorPOI,
+                                             args.fOpts.fCoveragePOI, &firstColorProcessorIdx,
                                              &firstCoverageProcessorIdx);
 
     bool usesLocalCoords = false;
 
     // Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline
     pipeline->fNumColorProcessors = builder.numColorFragmentProcessors() - firstColorProcessorIdx;
     int numTotalProcessors = pipeline->fNumColorProcessors +
                              builder.numCoverageFragmentProcessors() - firstCoverageProcessorIdx;
     pipeline->fFragmentProcessors.reset(numTotalProcessors);
     int currFPIdx = 0;
@@ skipping 20 matching lines @@
         overrides->fFlags |= GrXPOverridesForBatch::kUseOverrideColor_Flag;
         overrides->fOverrideColor = overrideColor;
     }
     if (!SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag)) {
         overrides->fFlags |= GrXPOverridesForBatch::kReadsCoverage_Flag;
     }
     if (usesLocalCoords) {
         overrides->fFlags |= GrXPOverridesForBatch::kReadsLocalCoords_Flag;
     }
     if (SkToBool(optFlags & GrXferProcessor::kCanTweakAlphaForCoverage_OptFlag)) {
-        overrides->fFlags |= GrXPOverridesForBatch::kCanTweakAlphaForCoverage_Flag; 
+        overrides->fFlags |= GrXPOverridesForBatch::kCanTweakAlphaForCoverage_Flag;
     }
 
     GrXPFactory::InvariantBlendedColor blendedColor;
     if (xpFactory) {
         xpFactory->getInvariantBlendedColor(args.fOpts.fColorPOI, &blendedColor);
     } else {
         GrPorterDuffXPFactory::SrcOverInvariantBlendedColor(args.fOpts.fColorPOI.color(),
                                                             args.fOpts.fColorPOI.validFlags(),
                                                             args.fOpts.fColorPOI.isOpaque(),
-                                                            &blendedColor); 
+                                                            &blendedColor);
     }
     if (blendedColor.fWillBlendWithDst) {
         overrides->fFlags |= GrXPOverridesForBatch::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);
     }
 
     const GrXferProcessor& xfer = this->getXferProcessor();
 
     for (int i = 0; i < xfer.numTextures(); ++i) {
-        GrTexture* texture = xfer.textureAccess(i).getTexture();   
+        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,
@@ skipping 33 matching lines @@
         }
     }
 
     for (int i = 0; i < a.numFragmentProcessors(); i++) {
         if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
             return false;
         }
     }
     return true;
 }
-