Don't create a GXPFactory when blend is SrcOver

include/gpu/GrPaint.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrPaint_DEFINED
@@ skipping 39 matching lines @@
     void setColor(GrColor color) { fColor = color; }
     GrColor getColor() const { return fColor; }
 
     /**
      * Should primitives be anti-aliased or not. Defaults to false.
      */
     void setAntiAlias(bool aa) { fAntiAlias = aa; }
     bool isAntiAlias() const { return fAntiAlias; }
 
     const GrXPFactory* setXPFactory(const GrXPFactory* xpFactory) {
-        fXPFactory.reset(SkRef(xpFactory));
+        fXPFactory.reset(SkSafeRef(xpFactory));
         return xpFactory;
     }
 
     void setPorterDuffXPFactory(SkXfermode::Mode mode) {
         fXPFactory.reset(GrPorterDuffXPFactory::Create(mode));
     }
 
     void setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCoverage = false); 
 
     /**
@@ skipping 22 matching lines @@
     void addCoverageTextureProcessor(GrTexture*, const SkMatrix&);
     void addColorTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
     void addCoverageTextureProcessor(GrTexture*, const SkMatrix&, const GrTextureParams&);
 
     int numColorFragmentProcessors() const { return fColorFragmentProcessors.count(); }
     int numCoverageFragmentProcessors() const { return fCoverageFragmentProcessors.count(); }
     int numTotalFragmentProcessors() const { return this->numColorFragmentProcessors() +
                                               this->numCoverageFragmentProcessors(); }
 
     const GrXPFactory* getXPFactory() const {
-        if (!fXPFactory) {
-            fXPFactory.reset(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode));
-        }
-        return fXPFactory.get();
+        return fXPFactory;
     }
 
     const GrFragmentProcessor* getColorFragmentProcessor(int i) const {
         return fColorFragmentProcessors[i];
     }
     const GrFragmentProcessor* getCoverageFragmentProcessor(int i) const {
         return fCoverageFragmentProcessors[i];
     }
 
     GrPaint& operator=(const GrPaint& paint) {
         fAntiAlias = paint.fAntiAlias;
 
         fColor = paint.fColor;
         this->resetFragmentProcessors();
         fColorFragmentProcessors = paint.fColorFragmentProcessors;
         fCoverageFragmentProcessors = paint.fCoverageFragmentProcessors;
         for (int i = 0; i < fColorFragmentProcessors.count(); ++i) {
             fColorFragmentProcessors[i]->ref();
         }
         for (int i = 0; i < fCoverageFragmentProcessors.count(); ++i) {
             fCoverageFragmentProcessors[i]->ref();
         }
 
-        fXPFactory.reset(SkRef(paint.getXPFactory()));
+        fXPFactory.reset(SkSafeRef(paint.getXPFactory()));
 
         return *this;
     }
 
     /**
      * Returns true if the paint's output color will be constant after blending. If the result is
      * true, constantColor will be updated to contain the constant color. Note that we can conflate
      * coverage and color, so the actual values written to pixels with partial coverage may still
      * not seem constant, even if this function returns true.
      */
@@ skipping 14 matching lines @@
     mutable SkAutoTUnref<const GrXPFactory>         fXPFactory;
     SkSTArray<4, const GrFragmentProcessor*, true>  fColorFragmentProcessors;
     SkSTArray<2, const GrFragmentProcessor*, true>  fCoverageFragmentProcessors;
 
     bool                                            fAntiAlias;
 
     GrColor                                         fColor;
 };
 
 #endif