Remove localcoordchange functions off paint

src/gpu/GrDefaultGeoProcFactory.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultGeoProcFactory.h"
 
 #include "GrDrawState.h"
 #include "GrInvariantOutput.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 typedef GrDefaultGeoProcFactory Flag;
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(GrColor color, uint8_t coverage, uint32_t gpTypeFlags,
-                                       bool opaqueVertexColors) {
-        return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags, opaqueVertexColors));
+                                       bool opaqueVertexColors, const SkMatrix& localMatrix) {
+        return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags, opaqueVertexColors,
+                                           localMatrix));
     }
 
     virtual const char* name() const SK_OVERRIDE { return "DefaultGeometryProcessor"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inColor() const { return fInColor; }
     const GrAttribute* inLocalCoords() const { return fInLocalCoords; }
     const GrAttribute* inCoverage() const { return fInCoverage; }
     uint8_t coverage() const { return fCoverage; }
 
@@ skipping 78 matching lines @@
             } else if (kAllOnes_GrGPInput == local.fInputCoverageType) {
                 fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
             }
         }
 
         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrBatchTracker& bt,
                                   const GrGLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
-            b->add32(def.fFlags);
-
             const BatchTracker& local = bt.cast<BatchTracker>();
-            b->add32(local.fInputColorType | local.fInputCoverageType << 16);
+            uint32_t key = def.fFlags;
+            key |= local.fInputColorType << 8 | local.fInputCoverageType << 16;
+            key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24 : 0x0;
+            b->add32(key);
         }
 
         virtual void setData(const GrGLProgramDataManager& pdman,
                              const GrPrimitiveProcessor& gp,
                              const GrBatchTracker& bt) SK_OVERRIDE {
             const BatchTracker& local = bt.cast<BatchTracker>();
             if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
                 GrGLfloat c[4];
                 GrColorToRGBAFloat(local.fColor, c);
                 pdman.set4fv(fColorUniform, 1, c);
@@ skipping 18 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    DefaultGeoProc(GrColor color, uint8_t coverage, uint32_t gpTypeFlags, bool opaqueVertexColors)
-        : INHERITED(color, opaqueVertexColors)
+    DefaultGeoProc(GrColor color, uint8_t coverage, uint32_t gpTypeFlags, bool opaqueVertexColors,
+                   const SkMatrix& localMatrix)
+        : INHERITED(color, opaqueVertexColors, localMatrix)
         , fInPosition(NULL)
         , fInColor(NULL)
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fCoverage(coverage)
         , fFlags(gpTypeFlags) {
         this->initClassID<DefaultGeoProc>();
         bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
         bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
         bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
@@ skipping 58 matching lines @@
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     }
 
     return DefaultGeoProc::Create(GrRandomColor(random), GrRandomCoverage(random),
-                                  flags, random->nextBool());
+                                  flags, random->nextBool(),
+                                  GrProcessorUnitTest::TestMatrix(random));
 }
 
 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(GrColor color,
                                                            uint32_t gpTypeFlags,
                                                            bool opaqueVertexColors,
-                                                           uint8_t coverage) {
-    return DefaultGeoProc::Create(color, coverage, gpTypeFlags, opaqueVertexColors);
+                                                           uint8_t coverage,
+                                                           const SkMatrix& localMatrix) {
+    return DefaultGeoProc::Create(color, coverage, gpTypeFlags, opaqueVertexColors, localMatrix);
 }