Add mixedtextblob gm and a simple bench

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 350 matching lines @@
 
         if (glyph.fWidth) {
             this->appendGlyph(blob,
                               runIndex,
                               GrGlyph::Pack(glyph.getGlyphID(),
                                             glyph.getSubXFixed(),
                                             glyph.getSubYFixed(),
                                             GrGlyph::kCoverage_MaskStyle),
                               Sk48Dot16FloorToInt(fx),
                               Sk48Dot16FloorToInt(fy),
+                              skPaint.getColor(),
                               fontScaler,
                               clipRect);
         }
 
         fx += glyph.fAdvanceX;
         fy += glyph.fAdvanceY;
     }
 }
 
 void GrAtlasTextContext::onDrawPosText(GrRenderTarget* rt, const GrClip& clip,
@@ skipping 71 matching lines @@
 
                 if (glyph.fWidth) {
                     this->appendGlyph(blob,
                                       runIndex,
                                       GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed(),
                                                     GrGlyph::kCoverage_MaskStyle),
                                       Sk48Dot16FloorToInt(fx),
                                       Sk48Dot16FloorToInt(fy),
+                                      skPaint.getColor(),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
                 const char* currentText = text;
                 const SkGlyph& metricGlyph = glyphCacheProc(cache, &text, 0, 0);
 
@@ skipping 17 matching lines @@
                     SkASSERT(glyph.fWidth);
 
                     this->appendGlyph(blob,
                                       runIndex,
                                       GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed(),
                                                     GrGlyph::kCoverage_MaskStyle),
                                       Sk48Dot16FloorToInt(fx),
                                       Sk48Dot16FloorToInt(fy),
+                                      skPaint.getColor(),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     } else {    // not subpixel
 
         if (SkPaint::kLeft_Align == skPaint.getTextAlign()) {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
                     Sk48Dot16 fx = SkScalarTo48Dot16(tmsLoc.fX + SK_ScalarHalf); //halfSampleX;
                     Sk48Dot16 fy = SkScalarTo48Dot16(tmsLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->appendGlyph(blob,
                                       runIndex,
                                       GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed(),
                                                     GrGlyph::kCoverage_MaskStyle),
                                       Sk48Dot16FloorToInt(fx),
                                       Sk48Dot16FloorToInt(fy),
+                                      skPaint.getColor(),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         } else {
             while (text < stop) {
                 // the last 2 parameters are ignored
                 const SkGlyph& glyph = glyphCacheProc(cache, &text, 0, 0);
 
                 if (glyph.fWidth) {
                     SkPoint tmsLoc;
                     tmsProc(pos, &tmsLoc);
 
                     SkPoint alignLoc;
                     alignProc(tmsLoc, glyph, &alignLoc);
 
                     Sk48Dot16 fx = SkScalarTo48Dot16(alignLoc.fX + SK_ScalarHalf); //halfSampleX;
                     Sk48Dot16 fy = SkScalarTo48Dot16(alignLoc.fY + SK_ScalarHalf); //halfSampleY;
                     this->appendGlyph(blob,
                                       runIndex,
                                       GrGlyph::Pack(glyph.getGlyphID(),
                                                     glyph.getSubXFixed(),
                                                     glyph.getSubYFixed(),
                                                     GrGlyph::kCoverage_MaskStyle),
                                       Sk48Dot16FloorToInt(fx),
                                       Sk48Dot16FloorToInt(fy),
+                                      skPaint.getColor(),
                                       fontScaler,
                                       clipRect);
                 }
                 pos += scalarsPerPosition;
             }
         }
     }
 }
 
 void GrAtlasTextContext::appendGlyph(BitmapTextBlob* blob, int runIndex, GrGlyph::PackedID packed,
-                                     int vx, int vy, GrFontScaler* scaler,
+                                     int vx, int vy, GrColor color, GrFontScaler* scaler,
                                      const SkIRect& clipRect) {
     if (NULL == fCurrStrike) {
         fCurrStrike = fContext->getBatchFontCache()->getStrike(scaler);
     }
 
     GrGlyph* glyph = fCurrStrike->getGlyph(packed, scaler);
     if (NULL == glyph || glyph->fBounds.isEmpty()) {
         return;
     }
 
@@ skipping 47 matching lines @@
 
     size_t vertexStride = get_vertex_stride(format);
 
     SkRect r;
     r.fLeft = SkIntToScalar(x);
     r.fTop = SkIntToScalar(y);
     r.fRight = r.fLeft + SkIntToScalar(width);
     r.fBottom = r.fTop + SkIntToScalar(height);
 
     run.fVertexBounds.joinNonEmptyArg(r);
-    GrColor color = fPaint.getColor();
     run.fColor = color;
 
     intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + subRun->fVertexEndIndex);
 
     // V0
     SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
     position->set(r.fLeft, r.fTop);
     if (kA8_GrMaskFormat == format) {
         SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
         *colorPtr = color;
@@ skipping 96 matching lines @@
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override {
         // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
         // TODO actually only invert if we don't have RGBA
         SkMatrix localMatrix;
         if (this->usesLocalCoords() && !this->viewMatrix().invert(&localMatrix)) {
             SkDebugf("Cannot invert viewmatrix\n");
             return;
         }
 
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
+
         // This will be ignored in the non A8 case
         bool opaqueVertexColors = GrColorIsOpaque(this->color());
         SkAutoTUnref<const GrGeometryProcessor> gp(
                 GrBitmapTextGeoProc::Create(this->color(),
                                             fFontCache->getTexture(fMaskFormat),
                                             params,
                                             fMaskFormat,
                                             opaqueVertexColors,
                                             localMatrix));
 
@@ skipping 261 matching lines @@
     GrColor color = paint.getColor();
     for (uint32_t run = 0; run < blob->fRunCount; run++) {
         for (int subRun = 0; subRun < blob->fRuns[run].fSubRunInfo.count(); subRun++) {
             PerSubRunInfo& info = blob->fRuns[run].fSubRunInfo[subRun];
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
             if (0 == glyphCount) {
                 continue;
             }
 
             GrMaskFormat format = info.fMaskFormat;
-            if (kARGB_GrMaskFormat == format) {
-                color = SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha);
-            }
+            GrColor subRunColor = kARGB_GrMaskFormat == format ?
+                                  SkColorSetARGB(paintAlpha, paintAlpha, paintAlpha, paintAlpha) :
+                                  color;
 
             BitmapTextBatch::Geometry geometry;
             geometry.fBlob.reset(SkRef(blob));
             geometry.fRun = run;
             geometry.fSubRun = subRun;
             geometry.fColor = color;
-            SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, color, format, glyphCount,
+            SkAutoTUnref<GrBatch> batch(BitmapTextBatch::Create(geometry, subRunColor, format,
+                                                                glyphCount,
                                                                 fContext->getBatchFontCache()));
 
             target->drawBatch(&pipelineBuilder, batch, &blob->fRuns[run].fVertexBounds);
         }
     }
 
     // Now flush big glyphs
     for (int i = 0; i < blob->fBigGlyphs.count(); i++) {
         BitmapTextBlob::BigGlyph& bigGlyph = blob->fBigGlyphs[i];
         SkMatrix translate;
         translate.setTranslate(SkIntToScalar(bigGlyph.fVx), SkIntToScalar(bigGlyph.fVy));
         SkPath tmpPath(bigGlyph.fPath);
         tmpPath.transform(translate);
         GrStrokeInfo strokeInfo(SkStrokeRec::kFill_InitStyle);
         fContext->drawPath(rt, clip, paint, SkMatrix::I(), tmpPath, strokeInfo);
     }
 }