Refugee from Dead Machine 4: MDB Monster

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 372 matching lines @@
 
     SkIRect clipRect;
     clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
 
     SkScalar transX = 0.f;
     SkScalar transY = 0.f;
 
     // Though for the time being runs in the textblob can override the paint, they only touch font
     // info.
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(fContext, skPaint, viewMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(fContext, skPaint, viewMatrix, &grPaint, rt)) {
         return;
     }
 
     if (cacheBlob) {
         if (MustRegenerateBlob(&transX, &transY, *cacheBlob, skPaint, grPaint.getColor(), blurRec,
                                viewMatrix, x, y)) {
             // We have to remake the blob because changes may invalidate our masks.
             // TODO we could probably get away reuse most of the time if the pointer is unique,
             // but we'd have to clear the subrun information
             fCache->remove(cacheBlob);
@@ skipping 1042 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;
         }
 
+        // This guy is only ever uploaded to
+        texture->setException(true);
+
         bool usesDistanceFields = this->usesDistanceFields();
         GrMaskFormat maskFormat = this->maskFormat();
         bool isLCD = this->isLCD();
 
         SkAutoTUnref<const GrGeometryProcessor> gp;
         if (usesDistanceFields) {
             gp.reset(this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(),
-                                            texture));
+                                            texture, this->rt2()));
         } else {
             GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
             gp.reset(GrBitmapTextGeoProc::Create(this->color(),
                                                  texture,
                                                  params,
                                                  maskFormat,
                                                  localMatrix,
-                                                 this->usesLocalCoords()));
+                                                 this->usesLocalCoords(), this->rt2()));
         }
 
         FlushInfo flushInfo;
         flushInfo.fGlyphsToFlush = 0;
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(vertexStride == (usesDistanceFields ?
                                   get_vertex_stride_df(maskFormat, isLCD) :
                                   get_vertex_stride(maskFormat)));
 
         target->initDraw(gp, this->pipeline());
@@ skipping 117 matching lines @@
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                                 glyph,
                                                                                 scaler,
                                                                                 skGlyph,
                                                                                 maskFormat);
                             SkASSERT(success);
                         }
                         fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
-                                                                 target->currentToken());
+                                                                 target->currentToken1());
 
                         // Texture coords are the last vertex attribute so we get a pointer to the
                         // first one and then map with stride in regenerateTextureCoords
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
                         vertex += vertexStride - sizeof(SkIPoint16);
 
                         this->regenerateTextureCoords(glyph, vertex, vertexStride);
                     }
@@ skipping 23 matching lines @@
                         info.fStrike.reset(SkRef(strike));
                     }
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(maskFormat);
                 }
             } else {
                 flushInfo.fGlyphsToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
-                fFontCache->setUseTokenBulk(info.fBulkUseToken, target->currentToken(), maskFormat);
+                fFontCache->setUseTokenBulk(info.fBulkUseToken, target->currentToken1(), maskFormat);
             }
 
             // now copy all vertices
             size_t byteCount = info.fVertexEndIndex - info.fVertexStartIndex;
             memcpy(currVertex, blob->fVertices + info.fVertexStartIndex, byteCount);
 
             currVertex += byteCount;
         }
         // Make sure to attach the last cache if applicable
         if (cache) {
@@ skipping 171 matching lines @@
         that->fGeoCount = 0;
         fGeoCount = newGeoCount;
 
         this->joinBounds(that->bounds());
         return true;
     }
 
     // TODO just use class params
     // TODO trying to figure out why lcd is so whack
     GrGeometryProcessor* setupDfProcessor(const SkMatrix& viewMatrix, SkColor filteredColor,
-                                          GrColor color, GrTexture* texture) {
+                                          GrColor color, GrTexture* texture, GrRenderTarget* dst) {
         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;
@@ skipping 10 matching lines @@
                 GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(redCorrection,
                                                                     greenCorrection,
                                                                     blueCorrection);
 
             return GrDistanceFieldLCDTextGeoProc::Create(color,
                                                          viewMatrix,
                                                          texture,
                                                          params,
                                                          widthAdjust,
                                                          flags,
-                                                         this->usesLocalCoords());
+                                                         this->usesLocalCoords(), dst);
         } else {
             flags |= kColorAttr_DistanceFieldEffectFlag;
 #ifdef SK_GAMMA_APPLY_TO_A8
             U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, filteredColor);
             float correction = (*fDistanceAdjustTable)[lum >> kDistanceAdjustLumShift];
             return GrDistanceFieldA8TextGeoProc::Create(color,
                                                         viewMatrix,
                                                         texture,
                                                         params,
                                                         correction,
                                                         flags,
-                                                        this->usesLocalCoords());
+                                                        this->usesLocalCoords(), dst);
 #else
             return GrDistanceFieldA8TextGeoProc::Create(color,
                                                         viewMatrix,
                                                         texture,
                                                         params,
                                                         flags,
                                                         this->usesLocalCoords());
 #endif
         }
 
@@ skipping 108 matching lines @@
     geometry.fTransX = transX;
     geometry.fTransY = transY;
     batch->init();
 
     return batch;
 }
 
 inline void GrAtlasTextContext::flushRun(GrDrawContext* dc, GrPipelineBuilder* pipelineBuilder,
                                          GrAtlasTextBlob* cacheBlob, int run, GrColor color,
                                          SkScalar transX, SkScalar transY,
-                                         const SkPaint& skPaint) {
+                                         const SkPaint& skPaint,
+                                         GrRenderTarget* rt) {
     for (int subRun = 0; subRun < cacheBlob->fRuns[run].fSubRunInfo.count(); subRun++) {
         const PerSubRunInfo& info = cacheBlob->fRuns[run].fSubRunInfo[subRun];
         int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
         if (0 == glyphCount) {
             continue;
         }
 
         SkAutoTUnref<GrDrawBatch> batch(this->createBatch(cacheBlob, info, glyphCount, run,
                                                           subRun, color, transX, transY,
                                                           skPaint));
@@ skipping 46 matching lines @@
 
     SkTextBlobRunIterator it(blob);
     for (int run = 0; !it.done(); it.next(), run++) {
         if (cacheBlob->fRuns[run].fDrawAsPaths) {
             this->flushRunAsPaths(dc, rt, it, clip, skPaint,
                                   drawFilter, viewMatrix, clipBounds, x, y);
             continue;
         }
         cacheBlob->fRuns[run].fVertexBounds.offset(transX, transY);
         this->flushRun(dc, &pipelineBuilder, cacheBlob, run, color,
-                       transX, transY, skPaint);
+                       transX, transY, skPaint, rt);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, dc, rt, clip, skPaint, transX, transY, clipBounds);
 }
 
 void GrAtlasTextContext::flush(GrAtlasTextBlob* cacheBlob,
                                GrDrawContext* dc,
                                GrRenderTarget* rt,
                                const SkPaint& skPaint,
                                const GrPaint& grPaint,
                                const GrClip& clip,
                                const SkIRect& clipBounds) {
     GrPipelineBuilder pipelineBuilder(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
-        this->flushRun(dc, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
+        this->flushRun(dc, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint, rt);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, dc, rt, clip, skPaint, 0, 0, clipBounds);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
@@ skipping 27 matching lines @@
     // Setup dummy SkPaint / GrPaint
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPaint skPaint;
     skPaint.setColor(color);
     skPaint.setLCDRenderText(random->nextBool());
     skPaint.setAntiAlias(skPaint.isLCDRenderText() ? true : random->nextBool());
     skPaint.setSubpixelText(random->nextBool());
 
     GrPaint grPaint;
-    if (!SkPaintToGrPaint(context, skPaint, viewMatrix, &grPaint)) {
+    if (!SkPaintToGrPaint(context, skPaint, viewMatrix, &grPaint, rt)) {
         SkFAIL("couldn't convert paint\n");
     }
 
     const char* text = "The quick brown fox jumps over the lazy dog.";
     int textLen = (int)strlen(text);
 
     // Setup clip
     GrClip clip;
     SkIRect noClip = SkIRect::MakeLargest();
 
     // right now we don't handle textblobs, nor do we handle drawPosText.  Since we only
     // intend to test the batch with this unit test, that is okay.
     SkAutoTUnref<GrAtlasTextBlob> blob(
             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