Make GrProcessorDataManager a noop

src/gpu/GrPipelineBuilder.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 GrPipelineBuilder_DEFINED
 #define GrPipelineBuilder_DEFINED
 
@@ skipping 62 matching lines @@
     const GrFragmentProcessor* addCoverageFragmentProcessor(const GrFragmentProcessor* processor) {
         SkASSERT(processor);
         fCoverageFragmentProcessors.push_back(SkRef(processor));
         return processor;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
-        this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+        this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
                                                                       matrix))->unref();
     }
 
     void addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
-        this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+        this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
                                                                          matrix))->unref();
     }
 
     void addColorTextureProcessor(GrTexture* texture,
                                   const SkMatrix& matrix,
                                   const GrTextureParams& params) {
-        this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+        this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
                                                                       matrix,
                                                                       params))->unref();
     }
 
     void addCoverageTextureProcessor(GrTexture* texture,
                                      const SkMatrix& matrix,
                                      const GrTextureParams& params) {
-        this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+        this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(&fProcDataManager, texture,
                                                                          matrix, params))->unref();
     }
 
     /**
      * When this object is destroyed it will remove any color/coverage FPs from the pipeline builder
      * and also remove any additions to the GrProcessorDataManager that were added after its
      * constructor.
      * This class can transiently modify its "const" GrPipelineBuilder object but will restore it
      * when done - so it is notionally "const" correct.
      */
     class AutoRestoreFragmentProcessorState : public ::SkNoncopyable {
     public:
         AutoRestoreFragmentProcessorState() 
             : fPipelineBuilder(nullptr)
             , fColorEffectCnt(0)
-            , fCoverageEffectCnt(0)
-            , fSaveMarker(0) {}
+            , fCoverageEffectCnt(0) {}
 
         AutoRestoreFragmentProcessorState(const GrPipelineBuilder& ds)
             : fPipelineBuilder(nullptr)
             , fColorEffectCnt(0)
-            , fCoverageEffectCnt(0)
-            , fSaveMarker(0) {
+            , fCoverageEffectCnt(0) {
             this->set(&ds);
         }
 
         ~AutoRestoreFragmentProcessorState() { this->set(nullptr); }
 
         void set(const GrPipelineBuilder* ds);
 
         bool isSet() const { return SkToBool(fPipelineBuilder); }
 
         GrProcessorDataManager* getProcessorDataManager() {
             SkASSERT(this->isSet());
             return fPipelineBuilder->getProcessorDataManager();
         }
 
         const GrFragmentProcessor* addCoverageFragmentProcessor(const GrFragmentProcessor* processor) {
             SkASSERT(this->isSet());
             return fPipelineBuilder->addCoverageFragmentProcessor(processor);
         }
 
     private:
         // notionally const (as marginalia)
         GrPipelineBuilder*    fPipelineBuilder;
         int                   fColorEffectCnt;
         int                   fCoverageEffectCnt;
-        uint32_t              fSaveMarker;
     };
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Blending
     ////
 
     /**
      * Installs a GrXPFactory. This object controls how src color, fractional pixel coverage,
@@ skipping 239 matching lines @@
     }
 
     const GrProcOptInfo& coverageProcInfo(const GrDrawBatch* batch) const {
         this->calcCoverageInvariantOutput(batch);
         return fCoverageProcInfo;
     }
 
     void setClip(const GrClip& clip) { fClip = clip; }
     const GrClip& clip() const { return fClip; }
 
-    GrProcessorDataManager* getProcessorDataManager() { return fProcDataManager.get(); }
-    const GrProcessorDataManager* processorDataManager() const { return fProcDataManager.get(); }
+    GrProcessorDataManager* getProcessorDataManager() { return &fProcDataManager; }
+    const GrProcessorDataManager* processorDataManager() const { return &fProcDataManager; }
 
 private:
     // Calculating invariant color / coverage information is expensive, so we partially cache the
     // results.
     //
     // canUseFracCoveragePrimProc() - Called in regular skia draw, caches results but only for a
     //                                specific color and coverage.  May be called multiple times
     // GrOptDrawState constructor - never caches results
 
     /**
      * Primproc variants of the calc functions
      * TODO remove these when batch is everywhere
      */
     void calcColorInvariantOutput(const GrPrimitiveProcessor*) const;
     void calcCoverageInvariantOutput(const GrPrimitiveProcessor*) const;
 
     /**
      * GrBatch provides the initial seed for these loops based off of its initial geometry data
      */
     void calcColorInvariantOutput(const GrDrawBatch*) const;
     void calcCoverageInvariantOutput(const GrDrawBatch*) const;
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(mutable int fBlockEffectRemovalCnt;)
 
     typedef SkSTArray<4, const GrFragmentProcessor*, true> FragmentProcessorArray;
 
-    SkAutoTUnref<GrProcessorDataManager>    fProcDataManager;
+    GrProcessorDataManager                  fProcDataManager;
     SkAutoTUnref<GrRenderTarget>            fRenderTarget;
     uint32_t                                fFlags;
     GrStencilSettings                       fStencilSettings;
     DrawFace                                fDrawFace;
     mutable SkAutoTUnref<const GrXPFactory> fXPFactory;
     FragmentProcessorArray                  fColorFragmentProcessors;
     FragmentProcessorArray                  fCoverageFragmentProcessors;
     GrClip                                  fClip;
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
 
     friend class GrPipeline;
 };
 
 #endif