Style Change: SkNEW->new; SkDELETE->delete

src/gpu/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrBatchFontCache.h"
 #include "GrBatchFlushState.h"
@@ skipping 81 matching lines @@
     unsigned g = SkColorGetG(c);
     unsigned b = SkColorGetB(c);
     return GrColorPackRGBA(r, g, b, 0xff);
 }
 
 };
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
                                        GrDrawContext* drawContext,
                                        const SkSurfaceProps& surfaceProps)
-    : INHERITED(context, drawContext, surfaceProps)
-    , fDistanceAdjustTable(SkNEW(DistanceAdjustTable)) {
+    : INHERITED(context, drawContext, surfaceProps), fDistanceAdjustTable(new DistanceAdjustTable) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
     static_assert(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
                   "vertex_attribute_changed");
     fCurrStrike = NULL;
     fCache = context->getTextBlobCache();
 }
 
 void GrAtlasTextContext::DistanceAdjustTable::buildDistanceAdjustTable() {
 
@@ skipping 40 matching lines @@
 #else
     SkScalar contrast = 0.5f;
 #endif
     SkScalar paintGamma = SK_GAMMA_EXPONENT;
     SkScalar deviceGamma = SK_GAMMA_EXPONENT;
 
     size = SkScalerContext::GetGammaLUTSize(contrast, paintGamma, deviceGamma,
         &width, &height);
 
     SkASSERT(kExpectedDistanceAdjustTableSize == height);
-    fTable = SkNEW_ARRAY(SkScalar, height);
+    fTable = new SkScalar[height];
 
     SkAutoTArray<uint8_t> data((int)size);
     SkScalerContext::GetGammaLUTData(contrast, paintGamma, deviceGamma, data.get());
 
     // find the inverse points where we cross 0.5
     // binsearch might be better, but we only need to do this once on creation
     for (int row = 0; row < height; ++row) {
         uint8_t* rowPtr = data.get() + row*width;
         for (int col = 0; col < width - 1; ++col) {
             if (rowPtr[col] <= 127 && rowPtr[col + 1] >= 128) {
@@ skipping 12 matching lines @@
                 fTable[row] = d;
                 break;
             }
         }
     }
 }
 
 GrAtlasTextContext* GrAtlasTextContext::Create(GrContext* context,
                                                GrDrawContext* drawContext,
                                                const SkSurfaceProps& surfaceProps) {
-    return SkNEW_ARGS(GrAtlasTextContext, (context, drawContext, surfaceProps));
+    return new GrAtlasTextContext(context, drawContext, surfaceProps);
 }
 
 bool GrAtlasTextContext::canDraw(const GrRenderTarget*,
                                  const GrClip&,
                                  const GrPaint&,
                                  const SkPaint& skPaint,
                                  const SkMatrix& viewMatrix) {
     return this->canDrawAsDistanceFields(skPaint, viewMatrix) ||
            !SkDraw::ShouldDrawTextAsPaths(skPaint, viewMatrix);
 }
@@ skipping 465 matching lines @@
                                                     const SkTDArray<char>& fallbackTxt,
                                                     const SkTDArray<SkScalar>& fallbackPos,
                                                     int scalarsPerPosition,
                                                     const SkPoint& offset,
                                                     const SkIRect& clipRect) {
     SkASSERT(fallbackTxt.count());
     blob->setHasBitmap();
     Run& run = blob->fRuns[runIndex];
     // Push back a new subrun to fill and set the override descriptor
     run.push_back();
-    run.fOverrideDescriptor.reset(SkNEW(SkAutoDescriptor));
+    run.fOverrideDescriptor.reset(new SkAutoDescriptor);
     skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
                                        fSurfaceProps, &viewMatrix, false);
     SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
                                                     run.fOverrideDescriptor->getDesc());
     this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, color, viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
 }
 
@@ skipping 670 matching lines @@
 inline void GrAtlasTextContext::appendGlyphPath(GrAtlasTextBlob* blob, GrGlyph* glyph,
                                                 GrFontScaler* scaler, const SkGlyph& skGlyph,
                                                 SkScalar x, SkScalar y, SkScalar scale,
                                                 bool applyVM) {
     if (NULL == glyph->fPath) {
         const SkPath* glyphPath = scaler->getGlyphPath(skGlyph);
         if (!glyphPath) {
             return;
         }
 
-        glyph->fPath = SkNEW_ARGS(SkPath, (*glyphPath));
+        glyph->fPath = new SkPath(*glyphPath);
     }
     blob->fBigGlyphs.push_back(GrAtlasTextBlob::BigGlyph(*glyph->fPath, x, y, scale, applyVM));
 }
 
 inline void GrAtlasTextContext::appendGlyphCommon(GrAtlasTextBlob* blob, Run* run,
                                                   Run::SubRunInfo* subRun,
                                                   const SkRect& positions, GrColor color,
                                                   size_t vertexStride, bool useVertexColor,
                                                   GrGlyph* glyph) {
     blob->fGlyphs[subRun->fGlyphEndIndex] = glyph;
@@ skipping 64 matching lines @@
         Blob* fBlob;
         int fRun;
         int fSubRun;
         GrColor fColor;
         SkScalar fTransX;
         SkScalar fTransY;
     };
 
     static TextBatch* CreateBitmap(GrMaskFormat maskFormat, int glyphCount,
                                    GrBatchFontCache* fontCache) {
-        TextBatch* batch = SkNEW(TextBatch);
+        TextBatch* batch = new TextBatch;
 
         batch->initClassID<TextBatch>();
         batch->fFontCache = fontCache;
         switch (maskFormat) {
             case kA8_GrMaskFormat:
                 batch->fMaskType = kGrayscaleCoverageMask_MaskType;
                 break;
             case kA565_GrMaskFormat:
                 batch->fMaskType = kLCDCoverageMask_MaskType;
                 break;
             case kARGB_GrMaskFormat:
                 batch->fMaskType = kColorBitmapMask_MaskType;
                 break;
         }
         batch->fBatch.fNumGlyphs = glyphCount;
         batch->fGeoCount = 1;
         batch->fFilteredColor = 0;
         batch->fFontCache = fontCache;
         batch->fUseBGR = false;
         return batch;
     }
 
     static TextBatch* CreateDistanceField(int glyphCount, GrBatchFontCache* fontCache,
                                           DistanceAdjustTable* distanceAdjustTable,
                                           SkColor filteredColor, bool isLCD,
                                           bool useBGR) {
-        TextBatch* batch = SkNEW(TextBatch);
+        TextBatch* batch = new TextBatch;
         batch->initClassID<TextBatch>();
         batch->fFontCache = fontCache;
         batch->fMaskType = isLCD ? kLCDDistanceField_MaskType : kGrayscaleDistanceField_MaskType;
         batch->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable));
         batch->fFilteredColor = filteredColor;
         batch->fUseBGR = useBGR;
         batch->fBatch.fNumGlyphs = glyphCount;
         batch->fGeoCount = 1;
         return batch;
     }
@@ skipping 733 matching lines @@
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(TextBlobBatch) {
     static uint32_t gContextID = SK_InvalidGenID;
     static GrAtlasTextContext* gTextContext = NULL;
     static SkSurfaceProps gSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
 
     if (context->uniqueID() != gContextID) {
         gContextID = context->uniqueID();
-        SkDELETE(gTextContext);
+        delete gTextContext;
 
         // We don't yet test the fall back to paths in the GrTextContext base class.  This is mostly
         // because we don't really want to have a gpu device here.
         // We enable distance fields by twiddling a knob on the paint
         GrDrawContext* drawContext = context->drawContext(&gSurfaceProps);
 
         gTextContext = GrAtlasTextContext::Create(context, drawContext, gSurfaceProps);
     }
 
     // create dummy render target
@@ skipping 35 matching lines @@
             gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
                                              static_cast<size_t>(textLen), 0, 0, noClip));
 
     SkScalar transX = static_cast<SkScalar>(random->nextU());
     SkScalar transY = static_cast<SkScalar>(random->nextU());
     const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif