AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reland of Make draw* lines responsible for cache management (patchset #1 id:1 of https://codereview.chromium.org/1552513003/ )

Browse Source 
Reason for revert:
might have been premature

Original issue's description:
> Revert of Make draw* lines responsible for cache management (patchset #1 id:1 of https://codereview.chromium.org/1521613002/ )
>
> Reason for revert:
> seeing crashes on android and linux
>
> Original issue's description:
> > Make draw* lines responsible for cache management
> >
> > TBR=bsalomon@google.com
> > BUG=skia:
> >
> > Committed: https://skia.googlesource.com/skia/+/66957946c0c418e71c0f36bb2904cc38c334eba4
>
> TBR=bsalomon@google.com,jvanverth@google.com,joshualitt@chromium.org
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/90e293dae4990a86cb952663ccde8fae55112d7d

TBR=bsalomon@google.com,jvanverth@google.com,joshualitt@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/1551563003
This commit is contained in:
joshualitt 2015-12-28 07:23:58 -08:00 committed by Commit bot
parent 90e293dae4
commit e76b4bb3ae
7 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/core/SkPaint.h
View File

@ -1082,9 +1082,8 @@ private:
friend class SkCanvas;
friend class SkDraw;
friend class SkPDFDevice;
friend class GrBitmapTextContext;
friend class GrAtlasTextBlob;
friend class GrAtlasTextContext;
friend class GrDistanceFieldTextContext;
friend class GrStencilAndCoverTextContext;
friend class GrPathRendering;
friend class GrTextUtils;

16
src/gpu/text/GrAtlasTextBlob.cpp
View File

@ -13,9 +13,25 @@
#include "GrTextUtils.h"
#include "SkColorFilter.h"
#include "SkDrawFilter.h"
#include "SkGlyphCache.h"
#include "SkTextBlobRunIterator.h"
#include "batches/GrAtlasTextBatch.h"
SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
const SkSurfaceProps& props,
const SkPaint& skPaint,
const SkMatrix* viewMatrix,
bool noGamma) {
GrAtlasTextBlob::Run* run = &fRuns[runIndex];
// if we have an override descriptor for the run, then we should use that
SkAutoDescriptor* desc = run->fOverrideDescriptor.get() ? run->fOverrideDescriptor.get() :
&run->fDescriptor;
skPaint.getScalerContextDescriptor(desc, props, viewMatrix, noGamma);
run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
return SkGlyphCache::DetachCache(run->fTypeface, desc->getDesc());
}
void GrAtlasTextBlob::appendGlyph(int runIndex,
const SkRect& positions,
GrColor color,

6
src/gpu/text/GrAtlasTextBlob.h
View File

@ -290,6 +290,12 @@ public:
}
}
SkGlyphCache* setupCache(int runIndex,
const SkSurfaceProps& props,
const SkPaint& skPaint,
const SkMatrix* viewMatrix,
bool noGamma);
// Appends a glyph to the blob. If the glyph is too large, the glyph will be appended
// as a path.
void appendGlyph(int runIndex,

57
src/gpu/text/GrAtlasTextContext.cpp
View File

@ -105,15 +105,6 @@ bool GrAtlasTextContext::HasLCD(const SkTextBlob* blob) {
return false;
}
inline SkGlyphCache* GrAtlasTextContext::setupCache(GrAtlasTextBlob::Run* run,
const SkPaint& skPaint,
const SkMatrix* viewMatrix,
bool 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(GrDrawContext* dc,
const GrClip& clip, const SkPaint& skPaint,
const SkMatrix& viewMatrix, const SkTextBlob* blob,
@ -291,18 +282,17 @@ void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
PerSubRunInfo& subRun = runIdx.fSubRunInfo.back();
subRun.setUseLCDText(runPaint.isLCDRenderText());
subRun.setDrawAsDistanceFields();
SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], dfPaint, nullptr, true);
switch (it.positioning()) {
case SkTextBlob::kDefault_Positioning: {
this->internalDrawDFText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
this->internalDrawDFText(cacheBlob, run, dfPaint, color, viewMatrix,
(const char *)it.glyphs(), textLen,
x + offset.x(), y + offset.y(), textRatio, runPaint);
break;
}
case SkTextBlob::kHorizontal_Positioning: {
SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
(const char*)it.glyphs(), textLen, it.pos(),
1, dfOffset, textRatio,
runPaint);
@ -310,40 +300,36 @@ void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
}
case SkTextBlob::kFull_Positioning: {
SkPoint dfOffset = SkPoint::Make(x, y);
this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
(const char*)it.glyphs(), textLen, it.pos(),
2, dfOffset, textRatio, runPaint);
break;
}
}
SkGlyphCache::AttachCache(cache);
} else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
cacheBlob->fRuns[run].fDrawAsPaths = true;
} else {
cacheBlob->setHasBitmap();
SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
false);
switch (it.positioning()) {
case SkTextBlob::kDefault_Positioning:
GrTextUtils::DrawBmpText(cacheBlob, run, fContext->getBatchFontCache(),
cache, runPaint, color, viewMatrix,
fSurfaceProps, runPaint, color, viewMatrix,
(const char *)it.glyphs(), textLen,
x + offset.x(), y + offset.y());
break;
case SkTextBlob::kHorizontal_Positioning:
GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
cache, runPaint, color, viewMatrix,
fSurfaceProps, runPaint, color, viewMatrix,
(const char*)it.glyphs(), textLen, it.pos(), 1,
SkPoint::Make(x, y + offset.y()));
break;
case SkTextBlob::kFull_Positioning:
GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
cache, runPaint, color, viewMatrix,
fSurfaceProps, runPaint, color, viewMatrix,
(const char*)it.glyphs(), textLen, it.pos(), 2,
SkPoint::Make(x, y));
break;
}
SkGlyphCache::AttachCache(cache);
}
if (drawFilter) {
@ -422,14 +408,9 @@ inline void GrAtlasTextContext::fallbackDrawPosText(GrAtlasTextBlob* blob,
// Push back a new subrun to fill and set the override descriptor
run.push_back();
run.fOverrideDescriptor.reset(new SkAutoDescriptor);
skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
fSurfaceProps, &viewMatrix, false);
SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
run.fOverrideDescriptor->getDesc());
GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), cache, skPaint,
color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), fSurfaceProps,
skPaint, color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
fallbackPos.begin(), scalarsPerPosition, offset);
SkGlyphCache::AttachCache(cache);
}
inline GrAtlasTextBlob*
@ -461,19 +442,15 @@ GrAtlasTextContext::createDrawTextBlob(const GrPaint& paint, const SkPaint& skPa
SkPaint dfPaint;
SkScalar textRatio;
blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
this->internalDrawDFText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
this->internalDrawDFText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
byteLength, x, y, textRatio, skPaint);
SkGlyphCache::AttachCache(cache);
} else {
blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
blob->fViewMatrix = viewMatrix;
SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
paint.getColor(), viewMatrix, text, byteLength, x, y);
SkGlyphCache::AttachCache(cache);
}
return blob;
}
@ -491,20 +468,16 @@ GrAtlasTextContext::createDrawPosTextBlob(const GrPaint& paint, const SkPaint& s
SkPaint dfPaint;
SkScalar textRatio;
blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
this->internalDrawDFPosText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
this->internalDrawDFPosText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
byteLength, pos, scalarsPerPosition, offset, textRatio,
skPaint);
SkGlyphCache::AttachCache(cache);
} else {
blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
blob->fViewMatrix = viewMatrix;
SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
paint.getColor(), viewMatrix, text,
byteLength, pos, scalarsPerPosition, offset);
SkGlyphCache::AttachCache(cache);
}
return blob;
}
@ -539,7 +512,6 @@ void GrAtlasTextContext::onDrawPosText(GrDrawContext* dc,
}
void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache,
const SkPaint& skPaint, GrColor color,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
@ -605,12 +577,11 @@ void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
y -= alignY;
SkPoint offset = SkPoint::Make(x, y);
this->internalDrawDFPosText(blob, runIndex, cache, skPaint, color, viewMatrix, text, byteLength,
this->internalDrawDFPosText(blob, runIndex, skPaint, color, viewMatrix, text, byteLength,
positions.begin(), 2, offset, textRatio, origPaint);
}
void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache,
const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
@ -633,6 +604,7 @@ void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runInd
fCurrStrike = nullptr;
SkGlyphCache* cache = blob->setupCache(runIndex, fSurfaceProps, skPaint, nullptr, true);
SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
GrFontScaler* fontScaler = GetGrFontScaler(cache);
@ -697,6 +669,7 @@ void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runInd
}
}
SkGlyphCache::AttachCache(cache);
if (fallbackTxt.count()) {
this->fallbackDrawPosText(blob, runIndex, origPaint.getColor(), origPaint, viewMatrix,
fallbackTxt, fallbackPos, scalarsPerPosition, offset);

5
src/gpu/text/GrAtlasTextContext.h
View File

@ -74,13 +74,13 @@ private:
const SkPoint& offset);
void internalDrawDFText(GrAtlasTextBlob*, int runIndex,
SkGlyphCache*, const SkPaint&,
const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y,
SkScalar textRatio, const SkPaint& origPaint);
void internalDrawDFPosText(GrAtlasTextBlob*, int runIndex,
SkGlyphCache*, const SkPaint&,
const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
@ -90,7 +90,6 @@ private:
// sets up the descriptor on the blob and returns a detached cache. Client must attach
inline static GrColor ComputeCanonicalColor(const SkPaint&, bool lcd);
inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix* viewMatrix, bool noGamma);
void regenerateTextBlob(GrAtlasTextBlob* bmp, const SkPaint& skPaint, GrColor,
const SkMatrix& viewMatrix,
const SkTextBlob* blob, SkScalar x, SkScalar y,

10
src/gpu/text/GrTextUtils.cpp
View File

@ -23,7 +23,7 @@
void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
GrBatchFontCache* fontCache,
SkGlyphCache* cache, const SkPaint& skPaint,
const SkSurfaceProps& props, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
@ -38,6 +38,7 @@ void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
GrBatchTextStrike* currStrike = nullptr;
// Get GrFontScaler from cache
SkGlyphCache* cache = blob->setupCache(runIndex, props, skPaint, &viewMatrix, false);
GrFontScaler* fontScaler = GrTextContext::GetGrFontScaler(cache);
SkFindAndPlaceGlyph::ProcessText(
@ -52,11 +53,13 @@ void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
color, fontScaler);
}
);
SkGlyphCache::AttachCache(cache);
}
void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
GrBatchFontCache* fontCache,
SkGlyphCache* cache, const SkPaint& skPaint,
const SkSurfaceProps& props, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
@ -73,6 +76,7 @@ void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
GrBatchTextStrike* currStrike = nullptr;
// Get GrFontScaler from cache
SkGlyphCache* cache = blob->setupCache(runIndex, props, skPaint, &viewMatrix, false);
GrFontScaler* fontScaler = GrTextContext::GetGrFontScaler(cache);
SkFindAndPlaceGlyph::ProcessPosText(
@ -87,6 +91,8 @@ void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
color, fontScaler);
}
);
SkGlyphCache::AttachCache(cache);
}
void GrTextUtils::BmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,

5
src/gpu/text/GrTextUtils.h
View File

@ -35,13 +35,14 @@ class GrTextUtils {
public:
// Functions for appending BMP text to GrAtlasTextBlob
static void DrawBmpText(GrAtlasTextBlob*, int runIndex,
GrBatchFontCache*, SkGlyphCache*, const SkPaint&,
GrBatchFontCache*, const SkSurfaceProps&,
const SkPaint&,
GrColor, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y);
static void DrawBmpPosText(GrAtlasTextBlob*, int runIndex,
GrBatchFontCache*, SkGlyphCache*, const SkPaint&,
GrBatchFontCache*, const SkSurfaceProps&, const SkPaint&,
GrColor, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,