Revert of Allow LCD text to batch across colorchanges. This will always use

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 "GrBatchFontCache.h"
@@ skipping 294 matching lines @@
         SkDebugf("Cannot invert viewmatrix\n");
         return;
     }
 
     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
         SkDebugf("Could not allocate backing texture for atlas\n");
         return;
     }
 
+    bool usesDistanceFields = this->usesDistanceFields();
     GrMaskFormat maskFormat = this->maskFormat();
+    bool isLCD = this->isLCD();
 
     SkAutoTUnref<const GrGeometryProcessor> gp;
-    if (this->usesDistanceFields()) {
+    if (usesDistanceFields) {
         gp.reset(this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(),
                                         texture));
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
         gp.reset(GrBitmapTextGeoProc::Create(this->color(),
                                              texture,
                                              params,
                                              maskFormat,
                                              localMatrix,
                                              this->usesLocalCoords()));
     }
 
     FlushInfo flushInfo;
     flushInfo.fGlyphsToFlush = 0;
     size_t vertexStride = gp->getVertexStride();
-    SkASSERT(vertexStride == GetVertexStride(maskFormat));
+    SkASSERT(vertexStride == (usesDistanceFields ?
+                              GetVertexStrideDf(maskFormat, isLCD) :
+                              GetVertexStride(maskFormat)));
 
     target->initDraw(gp, this->pipeline());
 
     int glyphCount = this->numGlyphs();
     const GrVertexBuffer* vertexBuffer;
 
     void* vertices = target->makeVertexSpace(vertexStride,
                                              glyphCount * kVerticesPerGlyph,
                                              &vertexBuffer,
                                              &flushInfo.fVertexOffset);
@@ skipping 25 matching lines @@
         // generating its texture coords, we have to track whether or not the strike has
         // been abandoned.  If it hasn't been abandoned, then we can use the GrGlyph*s as is
         // otherwise we have to get the new strike, and use that to get the correct glyphs.
         // Because we do not have the packed ids, and thus can't look up our glyphs in the
         // new strike, we instead keep our ref to the old strike and use the packed ids from
         // it.  These ids will still be valid as long as we hold the ref.  When we are done
         // updating our cache of the GrGlyph*s, we drop our ref on the old strike
         bool regenerateGlyphs = info.strike()->isAbandoned();
         bool regenerateTextureCoords = info.atlasGeneration() != currentAtlasGen ||
                                        regenerateGlyphs;
-        bool regenerateColors = kARGB_GrMaskFormat != maskFormat &&
-                                run.fColor != args.fColor;
+        bool regenerateColors;
+        if (usesDistanceFields) {
+            regenerateColors = !isLCD && run.fColor != args.fColor;
+        } else {
+            regenerateColors = kA8_GrMaskFormat == maskFormat && run.fColor != args.fColor;
+        }
         bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
         int glyphCount = info.glyphCount();
 
         uint32_t regenMaskBits = kNoRegen;
         regenMaskBits |= regeneratePositions ? kRegenPos : 0;
         regenMaskBits |= regenerateColors ? kRegenCol : 0;
         regenMaskBits |= regenerateTextureCoords ? kRegenTex : 0;
         regenMaskBits |= regenerateGlyphs ? kRegenGlyph : 0;
         RegenMask regenMask = (RegenMask)regenMaskBits;
 
@@ skipping 52 matching lines @@
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }
 
     if (fMaskType != that->fMaskType) {
         return false;
     }
 
     if (!this->usesDistanceFields()) {
-        if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
+        // TODO we can often batch across LCD text if we have dual source blending and don't
+        // have to use the blend constant
+        if (kGrayscaleCoverageMask_MaskType != fMaskType && this->color() != that->color()) {
             return false;
         }
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
     } else {
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         if (fFilteredColor != that->fFilteredColor) {
             return false;
         }
 
         if (fUseBGR != that->fUseBGR) {
             return false;
         }
+
+        // TODO see note above
+        if (kLCDDistanceField_MaskType == fMaskType && this->color() != that->color()) {
+            return false;
+        }
     }
 
     fBatch.fNumGlyphs += that->numGlyphs();
 
     // Reallocate space for geo data if necessary and then import that's geo data.
     int newGeoCount = that->fGeoCount + fGeoCount;
     // We assume (and here enforce) that the allocation size is the smallest power of two that
     // is greater than or equal to the number of geometries (and at least
     // kMinGeometryAllocated).
     int newAllocSize = GrNextPow2(newGeoCount);
@@ skipping 26 matching lines @@
     GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
     bool isLCD = this->isLCD();
     // set up any flags
     uint32_t flags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
     // see if we need to create a new effect
     if (isLCD) {
         flags |= kUseLCD_DistanceFieldEffectFlag;
         flags |= viewMatrix.rectStaysRect() ? kRectToRect_DistanceFieldEffectFlag : 0;
         flags |= fUseBGR ? kBGR_DistanceFieldEffectFlag : 0;
-        flags |= kColorAttr_DistanceFieldEffectFlag;
 
         GrColor colorNoPreMul = skcolor_to_grcolor_nopremultiply(filteredColor);
 
         float redCorrection =
             (*fDistanceAdjustTable)[GrColorUnpackR(colorNoPreMul) >> kDistanceAdjustLumShift];
         float greenCorrection =
             (*fDistanceAdjustTable)[GrColorUnpackG(colorNoPreMul) >> kDistanceAdjustLumShift];
         float blueCorrection =
             (*fDistanceAdjustTable)[GrColorUnpackB(colorNoPreMul) >> kDistanceAdjustLumShift];
         GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
@@ skipping 24 matching lines @@
         return GrDistanceFieldA8TextGeoProc::Create(color,
                                                     viewMatrix,
                                                     texture,
                                                     params,
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }