sk_sp for gpu.

src/gpu/batches/GrAtlasTextBatch.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 "GrAtlasTextBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 82 matching lines @@
     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
         SkDebugf("Could not allocate backing texture for atlas\n");
         return;
     }
 
     GrMaskFormat maskFormat = this->maskFormat();
 
     FlushInfo flushInfo;
     if (this->usesDistanceFields()) {
-        flushInfo.fGeometryProcessor.reset(
-            this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(), texture));
+        flushInfo.fGeometryProcessor =
+            this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(), texture);
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
-        flushInfo.fGeometryProcessor.reset(
-            GrBitmapTextGeoProc::Create(this->color(),
-                                        texture,
-                                        params,
-                                        maskFormat,
-                                        localMatrix,
-                                        this->usesLocalCoords()));
+        flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(this->color(),
+                                                                 texture,
+                                                                 params,
+                                                                 maskFormat,
+                                                                 localMatrix,
+                                                                 this->usesLocalCoords());
     }
 
     flushInfo.fGlyphsToFlush = 0;
     size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
     SkASSERT(vertexStride == GrAtlasTextBlob::GetVertexStride(maskFormat));
 
     int glyphCount = this->numGlyphs();
     const GrBuffer* vertexBuffer;
 
     void* vertices = target->makeVertexSpace(vertexStride,
@@ skipping 47 matching lines @@
 }
 
 void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
     GrMesh mesh;
     int maxGlyphsPerDraw =
         static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
     mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
                        flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
                        kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
                        maxGlyphsPerDraw);
-    target->draw(flushInfo->fGeometryProcessor, mesh);
+    target->draw(flushInfo->fGeometryProcessor.get(), mesh);
     flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
     flushInfo->fGlyphsToFlush = 0;
 }
 
 bool GrAtlasTextBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
     GrAtlasTextBatch* that = t->cast<GrAtlasTextBatch>();
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }
@@ skipping 47 matching lines @@
 #endif
     that->fGeoCount = 0;
     fGeoCount = newGeoCount;
 
     this->joinBounds(that->bounds());
     return true;
 }
 
 // TODO just use class params
 // TODO trying to figure out why lcd is so whack
-GrGeometryProcessor* GrAtlasTextBatch::setupDfProcessor(const SkMatrix& viewMatrix,
-                                                        SkColor filteredColor,
-                                                        GrColor color, GrTexture* texture) const {
+sk_sp<GrGeometryProcessor> GrAtlasTextBatch::setupDfProcessor(const SkMatrix& viewMatrix,
+                                                              SkColor filteredColor,
+                                                              GrColor color,
+                                                              GrTexture* texture) const {
     GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
     bool isLCD = this->isLCD();
     // set up any flags
     uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
     flags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
     flags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;
 
     // see if we need to create a new effect
     if (isLCD) {
         flags |= kUseLCD_DistanceFieldEffectFlag;
         flags |= fUseBGR ? kBGR_DistanceFieldEffectFlag : 0;
 
         GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);
 
         float redCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackR(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         float greenCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackG(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         float blueCorrection = fDistanceAdjustTable->getAdjustment(
             GrColorUnpackB(colorNoPreMul) >> kDistanceAdjustLumShift,
             fUseGammaCorrectDistanceTable);
         GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
             GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(redCorrection,
                                                                 greenCorrection,
                                                                 blueCorrection);
 
-        return GrDistanceFieldLCDTextGeoProc::Create(color,
-                                                     viewMatrix,
-                                                     texture,
-                                                     params,
-                                                     widthAdjust,
-                                                     flags,
-                                                     this->usesLocalCoords());
+        return GrDistanceFieldLCDTextGeoProc::Make(color,
+                                                   viewMatrix,
+                                                   texture,
+                                                   params,
+                                                   widthAdjust,
+                                                   flags,
+                                                   this->usesLocalCoords());
     } else {
 #ifdef SK_GAMMA_APPLY_TO_A8
         U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, filteredColor);
         float correction = fDistanceAdjustTable->getAdjustment(
             lum >> kDistanceAdjustLumShift, fUseGammaCorrectDistanceTable);
-        return GrDistanceFieldA8TextGeoProc::Create(color,
-                                                    viewMatrix,
-                                                    texture,
-                                                    params,
-                                                    correction,
-                                                    flags,
-                                                    this->usesLocalCoords());
+        return GrDistanceFieldA8TextGeoProc::Make(color,
+                                                  viewMatrix,
+                                                  texture,
+                                                  params,
+                                                  correction,
+                                                  flags,
+                                                  this->usesLocalCoords());
 #else
-        return GrDistanceFieldA8TextGeoProc::Create(color,
-                                                    viewMatrix,
-                                                    texture,
-                                                    params,
-                                                    flags,
-                                                    this->usesLocalCoords());
+        return GrDistanceFieldA8TextGeoProc::Make(color,
+                                                  viewMatrix,
+                                                  texture,
+                                                  params,
+                                                  flags,
+                                                  this->usesLocalCoords());
 #endif
     }
 
 }
 
 void GrBlobRegenHelper::flush() {
     fBatch->flush(fTarget, fFlushInfo);
 }