remove SkDeviceProperties

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 "GrBatch.h"
 #include "GrBatchFontCache.h"
@@ skipping 79 matching lines @@
     return GrColorPackRGBA(r, g, b, 0xff);
 }
 
 };
 
 // TODO
 // Distance field text in textblobs
 
 GrAtlasTextContext::GrAtlasTextContext(GrContext* context,
                                        GrDrawContext* drawContext,
-                                       const SkDeviceProperties& properties)
-    : INHERITED(context, drawContext, properties)
+                                       const SkSurfaceProps& surfaceProps)
+    : INHERITED(context, drawContext, surfaceProps)
     , fDistanceAdjustTable(SkNEW(DistanceAdjustTable)) {
     // We overallocate vertices in our textblobs based on the assumption that A8 has the greatest
     // vertexStride
     SK_COMPILE_ASSERT(kGrayTextVASize >= kColorTextVASize && kGrayTextVASize >= kLCDTextVASize,
                       vertex_attribute_changed);
     fCurrStrike = NULL;
     fCache = context->getTextBlobCache();
 }
 
 void GrAtlasTextContext::DistanceAdjustTable::buildDistanceAdjustTable() {
@@ skipping 73 matching lines @@
 
                 fTable[row] = d;
                 break;
             }
         }
     }
 }
 
 GrAtlasTextContext* GrAtlasTextContext::Create(GrContext* context,
                                                GrDrawContext* drawContext,
-                                               const SkDeviceProperties& props) {
-    return SkNEW_ARGS(GrAtlasTextContext, (context, drawContext, props));
+                                               const SkSurfaceProps& surfaceProps) {
+    return SkNEW_ARGS(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 120 matching lines @@
     // the blob anyways at flush time, so no need to regenerate explicitly
 
     return false;
 }
 
 
 inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
                                                     const SkPaint& skPaint,
                                                     const SkMatrix* viewMatrix,
                                                     bool noGamma) {
-    skPaint.getScalerContextDescriptor(&run->fDescriptor, &fDeviceProperties, viewMatrix, noGamma);
+    skPaint.getScalerContextDescriptor(&run->fDescriptor, fSurfaceProps, viewMatrix, noGamma);
     run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
     return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
 }
 
 void GrAtlasTextContext::drawTextBlob(GrRenderTarget* rt,
                                       const GrClip& clip, const SkPaint& skPaint,
                                       const SkMatrix& viewMatrix, const SkTextBlob* blob,
                                       SkScalar x, SkScalar y,
                                       SkDrawFilter* drawFilter, const SkIRect& clipBounds) {
     // If we have been abandoned, then don't draw
     if (fContext->abandoned()) {
         return;
     }
 
     SkAutoTUnref<BitmapTextBlob> cacheBlob;
     SkMaskFilter::BlurRec blurRec;
     BitmapTextBlob::Key key;
     // It might be worth caching these things, but its not clear at this time
     // TODO for animated mask filters, this will fill up our cache.  We need a safeguard here
     const SkMaskFilter* mf = skPaint.getMaskFilter();
     bool canCache = !(skPaint.getPathEffect() ||
                       (mf && !mf->asABlur(&blurRec)) ||
                       drawFilter);
 
     if (canCache) {
         bool hasLCD = HasLCD(blob);
 
         // We canonicalize all non-lcd draws to use kUnknown_SkPixelGeometry
-        SkPixelGeometry pixelGeometry = hasLCD ? fDeviceProperties.pixelGeometry() :
+        SkPixelGeometry pixelGeometry = hasLCD ? fSurfaceProps.pixelGeometry() :
                                                  kUnknown_SkPixelGeometry;
 
         // TODO we want to figure out a way to be able to use the canonical color on LCD text,
         // see the note on ComputeCanonicalColor above.  We pick a dummy value for LCD text to
         // ensure we always match the same key
         GrColor canonicalColor = hasLCD ? SK_ColorTRANSPARENT :
                                           ComputeCanonicalColor(skPaint, hasLCD);
 
         key.fPixelGeometry = pixelGeometry;
         key.fUniqueID = blob->uniqueID();
@@ skipping 58 matching lines @@
     }
 
     SkScalar maxScale = viewMatrix.getMaxScale();
     SkScalar scaledTextSize = maxScale*skPaint.getTextSize();
     // Hinted text looks far better at small resolutions
     // Scaling up beyond 2x yields undesireable artifacts
     if (scaledTextSize < kMinDFFontSize || scaledTextSize > kLargeDFFontLimit) {
         return false;
     }
 
-    bool useDFT = fDeviceProperties.useDFT();
+    bool useDFT = fSurfaceProps.isUseDistanceFieldFonts();
 #if SK_FORCE_DISTANCE_FIELD_TEXT
     useDFT = true;
 #endif
 
     if (!useDFT && !skPaint.isDistanceFieldTextTEMP() && scaledTextSize < kLargeDFFontSize) {
         return false;
     }
 
     // rasterizers and mask filters modify alpha, which doesn't
     // translate well to distance
@@ skipping 31 matching lines @@
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint for this reason.
         it.applyFontToPaint(&runPaint);
 
         if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
             // A false return from filter() means we should abort the current draw.
             runPaint = skPaint;
             continue;
         }
 
-        runPaint.setFlags(FilterTextFlags(fDeviceProperties, runPaint));
+        runPaint.setFlags(FilterTextFlags(fSurfaceProps, runPaint));
 
         // setup vertex / glyphIndex for the new run
         if (run > 0) {
             PerSubRunInfo& newRun = cacheBlob->fRuns[run].fSubRunInfo.back();
             PerSubRunInfo& lastRun = cacheBlob->fRuns[run - 1].fSubRunInfo.back();
 
             newRun.fVertexStartIndex = lastRun.fVertexEndIndex;
             newRun.fVertexEndIndex = lastRun.fVertexEndIndex;
 
             newRun.fGlyphStartIndex = lastRun.fGlyphEndIndex;
@@ skipping 147 matching lines @@
                                                     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));
     skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
-                                       &fDeviceProperties, &viewMatrix, false);
+                                       fSurfaceProps, &viewMatrix, false);
     SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
                                                     run.fOverrideDescriptor->getDesc());
     this->internalDrawBMPPosText(blob, runIndex, cache, skPaint, paint.getColor(), viewMatrix,
                                  fallbackTxt.begin(), fallbackTxt.count(),
                                  fallbackPos.begin(), scalarsPerPosition, offset, clipRect);
     SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextContext::BitmapTextBlob*
 GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
@@ skipping 390 matching lines @@
                                             const SkPaint& origPaint) {
     SkASSERT(byteLength == 0 || text != NULL);
 
     // nothing to draw
     if (text == NULL || byteLength == 0) {
         return;
     }
 
     SkDrawCacheProc glyphCacheProc = origPaint.getDrawCacheProc();
     SkAutoDescriptor desc;
-    origPaint.getScalerContextDescriptor(&desc, &fDeviceProperties, NULL, true);
+    origPaint.getScalerContextDescriptor(&desc, fSurfaceProps, NULL, true);
     SkGlyphCache* origPaintCache = SkGlyphCache::DetachCache(origPaint.getTypeface(),
                                                              desc.getDesc());
 
     SkTArray<SkScalar> positions;
 
     const char* textPtr = text;
     SkFixed stopX = 0;
     SkFixed stopY = 0;
     SkFixed origin = 0;
     switch (origPaint.getTextAlign()) {
@@ skipping 948 matching lines @@
 
     size_t textLen = it.glyphCount() * sizeof(uint16_t);
     const SkPoint& offset = it.offset();
 
     it.applyFontToPaint(&runPaint);
 
     if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
         return;
     }
 
-    runPaint.setFlags(FilterTextFlags(fDeviceProperties, runPaint));
+    runPaint.setFlags(FilterTextFlags(fSurfaceProps, runPaint));
 
     switch (it.positioning()) {
         case SkTextBlob::kDefault_Positioning:
             this->drawTextAsPath(rt, clip, runPaint, viewMatrix,
                                  (const char *)it.glyphs(),
                                  textLen, x + offset.x(), y + offset.y(), clipBounds);
             break;
         case SkTextBlob::kHorizontal_Positioning:
             this->drawPosTextAsPath(rt, clip, runPaint, viewMatrix,
                                     (const char*)it.glyphs(),
@@ skipping 25 matching lines @@
 
     BitmapTextBatch* batch;
     if (info.fDrawAsDistanceFields) {
         SkColor filteredColor;
         SkColorFilter* colorFilter = skPaint.getColorFilter();
         if (colorFilter) {
             filteredColor = colorFilter->filterColor(skPaint.getColor());
         } else {
             filteredColor = skPaint.getColor();
         }
-        bool useBGR = SkPixelGeometryIsBGR(fDeviceProperties.pixelGeometry());
+        bool useBGR = SkPixelGeometryIsBGR(fSurfaceProps.pixelGeometry());
         batch = BitmapTextBatch::Create(format, glyphCount, fContext->getBatchFontCache(),
                                         fDistanceAdjustTable, filteredColor,
                                         info.fUseLCDText, useBGR);
     } else {
         batch = BitmapTextBatch::Create(format, glyphCount, fContext->getBatchFontCache());
     }
     BitmapTextBatch::Geometry& geometry = batch->geometry();
     geometry.fBlob = SkRef(cacheBlob);
     geometry.fRun = run;
     geometry.fSubRun = subRun;
@@ skipping 101 matching lines @@
     this->flushBigGlyphs(cacheBlob, rt, clip, skPaint, 0, 0, clipBounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(TextBlobBatch) {
     static uint32_t gContextID = SK_InvalidGenID;
     static GrAtlasTextContext* gTextContext = NULL;
-    static SkDeviceProperties gDevProperties;
+    static SkSurfaceProps gSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
 
     if (context->uniqueID() != gContextID) {
         gContextID = context->uniqueID();
         SkDELETE(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(&gDevProperties);
+        GrDrawContext* drawContext = context->drawContext(&gSurfaceProps);
 
-        gTextContext = GrAtlasTextContext::Create(context, drawContext, gDevProperties);
+        gTextContext = GrAtlasTextContext::Create(context, drawContext, gSurfaceProps);
     }
 
     // create dummy render target
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = 1024;
     desc.fHeight = 1024;
     desc.fConfig = kRGBA_8888_GrPixelConfig;
     desc.fSampleCnt = 0;
     SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, true, NULL, 0));
@@ skipping 29 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 GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
     return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
 }
 
 #endif