fix some small bugs with GrAtlasTextContext

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 "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 33 matching lines @@
 static const size_t kColorTextVASize = sizeof(SkPoint) + sizeof(SkIPoint16);
 
 static const size_t kGrayTextVASize = sizeof(SkPoint) + sizeof(GrColor) + sizeof(SkIPoint16);
 
 static const int kMinDFFontSize = 18;
 static const int kSmallDFFontSize = 32;
 static const int kSmallDFFontLimit = 32;
 static const int kMediumDFFontSize = 72;
 static const int kMediumDFFontLimit = 72;
 static const int kLargeDFFontSize = 162;
+static const int kLargeDFFontLimit = 2 * kLargeDFFontSize;
 
 SkDEBUGCODE(static const int kExpectedDistanceAdjustTableSize = 8;)
 static const int kDistanceAdjustLumShift = 5;
 
 static const int kVerticesPerGlyph = 4;
 static const int kIndicesPerGlyph = 6;
 
 static size_t get_vertex_stride(GrMaskFormat maskFormat) {
     switch (maskFormat) {
         case kA8_GrMaskFormat:
@@ skipping 255 matching lines @@
         // bounds above on translation
         blob.fTotalXError += SkScalarAbs(SkScalarFraction(transX));
         blob.fTotalYError += SkScalarAbs(SkScalarFraction(transY));
         if (blob.fTotalXError > kMinDiscernableTranslation ||
             blob.fTotalYError > kMinDiscernableTranslation) {
             SkDebugf("Exceeding error threshold for bitmap text translation");
         }
 #endif
         (*outTransX) = transX;
         (*outTransY) = transY;
-    } else {
-        SkASSERT(blob.hasDistanceField());
+    } else if (blob.hasDistanceField()) {
         // A scale outside of [blob.fMaxMinScale, blob.fMinMaxScale] would result in a different
         // distance field being generated, so we have to regenerate in those cases
         SkScalar newMaxScale = viewMatrix.getMaxScale();
         SkScalar oldMaxScale = blob.fViewMatrix.getMaxScale();
         SkScalar scaleAdjust = newMaxScale / oldMaxScale;
         if (scaleAdjust < blob.fMaxMinScale || scaleAdjust > blob.fMinMaxScale) {
             return true;
         }
 
         (*outTransX) = x - blob.fX;
         (*outTransY) = y - blob.fY;
     }
+    // It is possible that a blob has neither distanceField nor bitmaptext.  This is in the case
+    // when all of the runs inside the blob are drawn as paths.  In this case, we always regenerate
+    // 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);
@@ skipping 81 matching lines @@
                                                         const SkMatrix& viewMatrix) {
     // TODO: support perspective (need getMaxScale replacement)
     if (viewMatrix.hasPerspective()) {
         return false;
     }
 
     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 > 2 * kLargeDFFontSize) {
+    if (scaledTextSize < kMinDFFontSize || scaledTextSize > kLargeDFFontLimit) {
         return false;
     }
 
     if (!fEnableDFRendering && !skPaint.isDistanceFieldTextTEMP() &&
         scaledTextSize < kLargeDFFontSize) {
         return false;
     }
 
     // rasterizers and mask filters modify alpha, which doesn't
     // translate well to distance
@@ skipping 149 matching lines @@
     if (maxScale > 0 && !SkScalarNearlyEqual(maxScale, SK_Scalar1)) {
         scaledTextSize *= maxScale;
     }
 
     // We have three sizes of distance field text, and within each size 'bucket' there is a floor
     // and ceiling.  A scale outside of this range would require regenerating the distance fields
     SkScalar dfMaskScaleFloor;
     SkScalar dfMaskScaleCeil;
     if (scaledTextSize <= kSmallDFFontLimit) {
         dfMaskScaleFloor = kMinDFFontSize;
-        dfMaskScaleCeil = kMediumDFFontLimit;
+        dfMaskScaleCeil = kSmallDFFontLimit;
         *textRatio = textSize / kSmallDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kSmallDFFontSize));
     } else if (scaledTextSize <= kMediumDFFontLimit) {
-        dfMaskScaleFloor = kMediumDFFontLimit;
-        dfMaskScaleCeil = kLargeDFFontSize;
+        dfMaskScaleFloor = kSmallDFFontLimit;
+        dfMaskScaleCeil = kMediumDFFontLimit;
         *textRatio = textSize / kMediumDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kMediumDFFontSize));
     } else {
-        dfMaskScaleFloor = kLargeDFFontSize;
-        dfMaskScaleCeil = 2 * kLargeDFFontSize;
+        dfMaskScaleFloor = kMediumDFFontLimit;
+        dfMaskScaleCeil = kLargeDFFontLimit;
         *textRatio = textSize / kLargeDFFontSize;
         skPaint->setTextSize(SkIntToScalar(kLargeDFFontSize));
     }
 
     // Because there can be multiple runs in the blob, we want the overall maxMinScale, and
     // minMaxScale to make regeneration decisions.  Specifically, we want the maximum minimum scale
     // we can tolerate before we'd drop to a lower mip size, and the minimum maximum scale we can
     // tolerate before we'd have to move to a large mip size.  When we actually test these values
     // we look at the delta in scale between the new viewmatrix and the old viewmatrix, and test
     // against these values to decide if we can reuse or not(ie, will a given scale change our mip
     // level)
+    SkASSERT(dfMaskScaleFloor <= scaledTextSize && scaledTextSize <= dfMaskScaleCeil);
     blob->fMaxMinScale = SkMaxScalar(dfMaskScaleFloor / scaledTextSize, blob->fMaxMinScale);
     blob->fMinMaxScale = SkMinScalar(dfMaskScaleCeil / scaledTextSize, blob->fMinMaxScale);
 
     skPaint->setLCDRenderText(false);
     skPaint->setAutohinted(false);
     skPaint->setHinting(SkPaint::kNormal_Hinting);
     skPaint->setSubpixelText(true);
 }
 
 inline void GrAtlasTextContext::fallbackDrawPosText(BitmapTextBlob* blob,
@@ skipping 1514 matching lines @@
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }