Reland "Have draw(Text|PosText|PosTextH) use a single entry on the device"
This reverts commit 74b390d6b136a60f1df15ac5ecd19bd8ad5a394b.
Reason for revert: reverting to add patch for valgrind
Original change's description:
> Revert "Have draw(Text|PosText|PosTextH) use a single entry on the device"
>
> This reverts commit 4225b3220ef4bf50f0d9403f812ea94d50c4ee59.
>
> Reason for revert: made valgrind unhappy.
>
> Original change's description:
> > Have draw(Text|PosText|PosTextH) use a single entry on the device
> >
> > Handle the positioning of drawText at the canvas layer. Simplify
> > the code by removing similar implementations.
> >
> > Change-Id: I8b711783435072f560e29fca1dd934fa2e345ed2
> > Reviewed-on: https://skia-review.googlesource.com/127131
> > Reviewed-by: Ben Wagner <bungeman@google.com>
> > Commit-Queue: Herb Derby <herb@google.com>
>
> TBR=jvanverth@google.com,bungeman@google.com,herb@google.com
>
> Change-Id: I65c9d30ae6ecb1f87e8660e56d8f8ce5daab7551
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://skia-review.googlesource.com/132403
> Reviewed-by: Hal Canary <halcanary@google.com>
> Commit-Queue: Hal Canary <halcanary@google.com>
TBR=jvanverth@google.com,halcanary@google.com,bungeman@google.com,herb@google.com
Change-Id: I9bbb73aac447b51eb8215ac42331759fa4c9fa45
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/132580
Reviewed-by: Herb Derby <herb@google.com>
Commit-Queue: Herb Derby <herb@google.com>
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 71b85af..cbd9a7c 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -565,12 +565,6 @@
BDDraw(this).drawSprite(bitmap, x, y, paint);
}
-void SkBitmapDevice::drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) {
- SkBitmapDeviceFilteredSurfaceProps props(fBitmap, paint, fSurfaceProps);
- LOOP_TILER( drawText((const char*)text, len, x, y, paint, &props()), nullptr)
-}
-
void SkBitmapDevice::drawPosText(const void* text, size_t len, const SkScalar xpos[],
int scalarsPerPos, const SkPoint& offset, const SkPaint& paint) {
SkBitmapDeviceFilteredSurfaceProps props(fBitmap, paint, fSurfaceProps);
diff --git a/src/core/SkBitmapDevice.h b/src/core/SkBitmapDevice.h
index c36bc28..ba7846c 100644
--- a/src/core/SkBitmapDevice.h
+++ b/src/core/SkBitmapDevice.h
@@ -111,8 +111,6 @@
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
- void drawText(const void* text, size_t len, SkScalar x, SkScalar y,
- const SkPaint&) override;
void drawPosText(const void* text, size_t len, const SkScalar pos[],
int scalarsPerPos, const SkPoint& offset, const SkPaint& paint) override;
void drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) override;
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 8230fb3..dcff1b0 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -15,6 +15,8 @@
#include "SkDrawable.h"
#include "SkDrawFilter.h"
#include "SkDrawLooper.h"
+#include "SkGlyphCache.h"
+#include "SkGlyphRun.h"
#include "SkImage.h"
#include "SkImage_Base.h"
#include "SkImageFilter.h"
@@ -34,6 +36,7 @@
#include "SkRasterHandleAllocator.h"
#include "SkRRect.h"
#include "SkSpecialImage.h"
+#include "SkStrikeCache.h"
#include "SkString.h"
#include "SkSurface_Base.h"
#include "SkTextBlob.h"
@@ -1075,7 +1078,8 @@
const bool preserveLCDText = kOpaque_SkAlphaType == info.alphaType() ||
(saveLayerFlags & kPreserveLCDText_SaveLayerFlag);
const SkBaseDevice::TileUsage usage = SkBaseDevice::kNever_TileUsage;
- const bool trackCoverage = SkToBool(saveLayerFlags & kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag);
+ const bool trackCoverage =
+ SkToBool(saveLayerFlags & kMaskAgainstCoverage_EXPERIMENTAL_DONT_USE_SaveLayerFlag);
const SkBaseDevice::CreateInfo createInfo = SkBaseDevice::CreateInfo(info, usage, geo,
preserveLCDText,
trackCoverage,
@@ -2439,10 +2443,13 @@
void SkCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
const SkPaint& paint) {
+
LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
- iter.fDevice->drawText(text, byteLength, x, y, looper.paint());
+ auto glyphRun = SkGlyphRun::MakeFromDrawText(
+ looper.paint(), text, byteLength, SkPoint::Make(x, y));
+ iter.fDevice->drawGlyphRun(looper.paint(), &glyphRun);
}
LOOPER_END
@@ -2450,12 +2457,12 @@
void SkCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
const SkPaint& paint) {
- SkPoint textOffset = SkPoint::Make(0, 0);
LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
- iter.fDevice->drawPosText(text, byteLength, &pos->fX, 2, textOffset, looper.paint());
+ auto glyphRun = SkGlyphRun::MakeFromDrawPosText(looper.paint(), text, byteLength, pos);
+ iter.fDevice->drawGlyphRun(looper.paint(), &glyphRun);
}
LOOPER_END
@@ -2464,12 +2471,12 @@
void SkCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
SkScalar constY, const SkPaint& paint) {
- SkPoint textOffset = SkPoint::Make(0, constY);
-
LOOPER_BEGIN(paint, SkDrawFilter::kText_Type, nullptr)
while (iter.next()) {
- iter.fDevice->drawPosText(text, byteLength, xpos, 1, textOffset, looper.paint());
+ auto glyphRun =
+ SkGlyphRun::MakeFromDrawPosTextH(looper.paint(), text, byteLength, xpos, constY);
+ iter.fDevice->drawGlyphRun(looper.paint(), &glyphRun);
}
LOOPER_END
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 35cfc9a..1bad6db 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -9,12 +9,14 @@
#include "SkColorFilter.h"
#include "SkDraw.h"
#include "SkDrawFilter.h"
+#include "SkGlyphRun.h"
#include "SkImageFilter.h"
#include "SkImageFilterCache.h"
#include "SkImagePriv.h"
#include "SkImage_Base.h"
#include "SkLatticeIter.h"
#include "SkLocalMatrixShader.h"
+#include "SkMakeUnique.h"
#include "SkMatrixPriv.h"
#include "SkPatchUtils.h"
#include "SkPathMeasure.h"
@@ -157,9 +159,16 @@
}
switch (it.positioning()) {
- case SkTextBlob::kDefault_Positioning:
- this->drawText(it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint);
- break;
+ case SkTextBlob::kDefault_Positioning: {
+ auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
+ auto glyphRun =
+ SkGlyphRun::MakeFromDrawText(runPaint,
+ (const char*) it.glyphs(), textLen, origin);
+ this->drawPosText(
+ it.glyphs(), textLen, glyphRun.getPositions(), 2,
+ SkPoint::Make(0, 0), runPaint);
+ }
+ break;
case SkTextBlob::kHorizontal_Positioning:
this->drawPosText(it.glyphs(), textLen, it.pos(), 1,
SkPoint::Make(x, y + offset.y()), runPaint);
@@ -243,6 +252,17 @@
}
}
+void SkBaseDevice::drawGlyphRun(const SkPaint& paint, SkGlyphRun* info) {
+ SkPaint glyphPaint(paint);
+ glyphPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+
+ auto glyphs = info->copyGlyphIDs();
+
+ this->drawPosText(
+ glyphs.get(), info->runSize() * 2,
+ info->getPositions(), 2, SkPoint::Make(0, 0), glyphPaint);
+}
+
void SkBaseDevice::drawBitmapLattice(const SkBitmap& bitmap,
const SkCanvas::Lattice& lattice, const SkRect& dst,
const SkPaint& paint) {
@@ -496,6 +516,8 @@
SkPaint localPaint(paint);
SkShader* shader = paint.getShader();
+ SkScalar pos[2] = {0.0f, 0.0f};
+ SkPoint origin = SkPoint::Make(0, 0);
SkMatrix localM, currM;
const void* stopText = (const char*)text + len;
@@ -517,7 +539,7 @@
}
int subLen = proc((const char*)text);
- this->drawText(text, subLen, 0, 0, localPaint);
+ this->drawPosText(text, subLen, pos, 2, origin, localPaint);
text = (const char*)text + subLen;
}
}
diff --git a/src/core/SkDevice.h b/src/core/SkDevice.h
index 40b9589..d36dc4d 100644
--- a/src/core/SkDevice.h
+++ b/src/core/SkDevice.h
@@ -17,6 +17,7 @@
class SkBitmap;
class SkDrawFilter;
struct SkDrawShadowRec;
+class SkGlyphRun;
class SkImageFilterCache;
struct SkIRect;
class SkMatrix;
@@ -222,11 +223,7 @@
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
- virtual void drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) = 0;
- virtual void drawPosText(const void* text, size_t len,
- const SkScalar pos[], int scalarsPerPos,
- const SkPoint& offset, const SkPaint& paint) = 0;
+ virtual void drawGlyphRun(const SkPaint& paint, SkGlyphRun* info);
virtual void drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) = 0;
virtual void drawShadow(const SkPath&, const SkDrawShadowRec&);
@@ -349,6 +346,10 @@
friend class SkSurface_Raster;
friend class DeviceTestingAccess;
+ virtual void drawPosText(const void* text, size_t len,
+ const SkScalar pos[], int scalarsPerPos,
+ const SkPoint& offset, const SkPaint& paint) = 0;
+
// used to change the backend's pixels (and possibly config/rowbytes)
// but cannot change the width/height, so there should be no change to
// any clip information.
@@ -427,7 +428,6 @@
void drawSprite(const SkBitmap&, int, int, const SkPaint&) override {}
void drawBitmapRect(const SkBitmap&, const SkRect*, const SkRect&, const SkPaint&,
SkCanvas::SrcRectConstraint) override {}
- void drawText(const void*, size_t, SkScalar, SkScalar, const SkPaint&) override {}
void drawPosText(const void*, size_t, const SkScalar[], int, const SkPoint&,
const SkPaint&) override {}
void drawDevice(SkBaseDevice*, int, int, const SkPaint&) override {}
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index b7150f8..e975ea2 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -1537,37 +1537,6 @@
return flags;
}
-void SkDraw::drawText(const char text[], size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint& paint, const SkSurfaceProps* props) const {
- SkASSERT(byteLength == 0 || text != nullptr);
-
- SkDEBUGCODE(this->validate();)
-
- // nothing to draw
- if (text == nullptr || byteLength == 0 || fRC->isEmpty()) {
- return;
- }
-
- // SkScalarRec doesn't currently have a way of representing hairline stroke and
- // will fill if its frame-width is 0.
- if (ShouldDrawTextAsPaths(paint, *fMatrix)) {
- this->drawText_asPaths(text, byteLength, x, y, paint);
- return;
- }
-
- auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(
- paint, props, this->scalerContextFlags(), fMatrix);
-
- // The Blitter Choose needs to be live while using the blitter below.
- SkAutoBlitterChoose blitterChooser(*this, nullptr, paint);
- SkAAClipBlitterWrapper wrapper(*fRC, blitterChooser.get());
- DrawOneGlyph drawOneGlyph(*this, paint, cache.get(), wrapper.getBlitter());
-
- SkFindAndPlaceGlyph::ProcessText(
- paint.getTextEncoding(), text, byteLength,
- {x, y}, *fMatrix, paint.getTextAlign(), cache.get(), drawOneGlyph);
-}
-
//////////////////////////////////////////////////////////////////////////////
void SkDraw::drawPosText_asPaths(const char text[], size_t byteLength, const SkScalar pos[],
diff --git a/src/core/SkDraw.h b/src/core/SkDraw.h
index eabccf0..266960e 100644
--- a/src/core/SkDraw.h
+++ b/src/core/SkDraw.h
@@ -62,8 +62,6 @@
void drawBitmap(const SkBitmap&, const SkMatrix&, const SkRect* dstOrNull,
const SkPaint&) const;
void drawSprite(const SkBitmap&, int x, int y, const SkPaint&) const;
- void drawText(const char text[], size_t byteLength, SkScalar x,
- SkScalar y, const SkPaint& paint, const SkSurfaceProps*) const;
void drawPosText(const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkPaint&, const SkSurfaceProps*) const;
diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp
index bf5f77c..3734b96 100644
--- a/src/core/SkGlyphCache.cpp
+++ b/src/core/SkGlyphCache.cpp
@@ -130,6 +130,13 @@
return *this->lookupByPackedGlyphID(packedGlyphID, kFull_MetricsType);
}
+void SkGlyphCache::getAdvances(SkSpan<SkGlyphID> glyphIDs, SkPoint advances[]) {
+ for (ptrdiff_t i = 0; i < glyphIDs.size(); i++) {
+ auto glyph = this->getGlyphIDAdvance(glyphIDs[i]);
+ advances[i] = SkPoint::Make(glyph.fAdvanceX, glyph.fAdvanceY);
+ }
+}
+
SkGlyph* SkGlyphCache::lookupByChar(SkUnichar charCode, MetricsType type, SkFixed x, SkFixed y) {
SkPackedUnicharID id(charCode, x, y);
CharGlyphRec* rec = this->getCharGlyphRec(id);
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index 2e73557..e904c6e 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -10,6 +10,7 @@
#include "SkArenaAlloc.h"
#include "SkDescriptor.h"
#include "SkGlyph.h"
+#include "SkGlyphRun.h"
#include "SkPaint.h"
#include "SkTHash.h"
#include "SkScalerContext.h"
@@ -67,6 +68,8 @@
const SkGlyph& getUnicharMetrics(SkUnichar, SkFixed x, SkFixed y);
const SkGlyph& getGlyphIDMetrics(uint16_t, SkFixed x, SkFixed y);
+ void getAdvances(SkSpan<SkGlyphID>, SkPoint[]);
+
/** Return the glyphID for the specified Unichar. If the char has already been seen, use the
existing cache entry. If not, ask the scalercontext to compute it for us.
*/
diff --git a/src/core/SkGlyphRun.cpp b/src/core/SkGlyphRun.cpp
new file mode 100644
index 0000000..a25b9af
--- /dev/null
+++ b/src/core/SkGlyphRun.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkGlyphRun.h"
+
+#include <algorithm>
+#include <tuple>
+
+#include "SkDraw.h"
+#include "SkGlyphCache.h"
+#include "SkMakeUnique.h"
+#include "SkMSAN.h"
+#include "SkPaint.h"
+#include "SkPaintPriv.h"
+#include "SkStrikeCache.h"
+#include "SkUtils.h"
+
+namespace {
+
+// A faster set implementation that does not need any initialization, and reading the set items
+// is order the number of items, and not the size of the universe.
+// This implementation is based on the paper by Briggs and Torczon, "An Efficient Representation
+// for Sparse Sets"
+class GlyphSet {
+public:
+ GlyphSet(uint32_t glyphUniverseSize)
+ : fUniverseSize{glyphUniverseSize}
+ , fIndexes{skstd::make_unique_default<uint16_t[]>(2 * glyphUniverseSize)}
+ , fUniqueGlyphIDs{&fIndexes[glyphUniverseSize]} {
+ SkASSERT(glyphUniverseSize <= (1 << 16));
+ sk_msan_mark_initialized(fIndexes.get(), &fIndexes[glyphUniverseSize], "works with uninited");
+ }
+
+ uint16_t add(SkGlyphID glyphID) {
+ if (glyphID >= fUniverseSize) {
+ glyphID = kUndefGlyph;
+ }
+ auto index = fIndexes[glyphID];
+ if (index < fUniqueCount && fUniqueGlyphIDs[index] == glyphID) {
+ return index;
+ }
+
+ fUniqueGlyphIDs[fUniqueCount] = glyphID;
+ fIndexes[glyphID] = fUniqueCount;
+ fUniqueCount += 1;
+ return fUniqueCount - 1;
+ }
+
+ std::tuple<uint16_t, std::unique_ptr<SkGlyphID[]>> uniqueGlyphIDs() const {
+ auto uniqueGlyphs = skstd::make_unique_default<SkGlyphID[]>(fUniqueCount);
+ memcpy(uniqueGlyphs.get(), fUniqueGlyphIDs, fUniqueCount * sizeof(SkGlyphID));
+ return std::make_tuple(fUniqueCount, std::move(uniqueGlyphs));
+ }
+
+private:
+ static constexpr SkGlyphID kUndefGlyph{0};
+ const uint32_t fUniverseSize;
+ uint16_t fUniqueCount{0};
+ std::unique_ptr<uint16_t[]> fIndexes;
+ SkGlyphID* fUniqueGlyphIDs;
+ };
+
+template<typename T>
+bool is_aligned(const void* ptr) {
+ uintptr_t bits = reinterpret_cast<uintptr_t>(ptr);
+ return (bits & (alignof(T) - 1)) == 0;
+}
+
+template<typename T>
+bool is_aligned_size(size_t size) {
+ return size % sizeof(T) == 0;
+}
+
+SkTypeface::Encoding convert_encoding(SkPaint::TextEncoding encoding) {
+ switch (encoding) {
+ case SkPaint::kUTF8_TextEncoding: return SkTypeface::kUTF8_Encoding;
+ case SkPaint::kUTF16_TextEncoding: return SkTypeface::kUTF16_Encoding;
+ case SkPaint::kUTF32_TextEncoding: return SkTypeface::kUTF32_Encoding;
+ default: return SkTypeface::kUTF32_Encoding;
+ }
+}
+
+using Core = std::tuple<size_t, std::unique_ptr<uint16_t[]>,
+ uint16_t, std::unique_ptr<SkGlyphID[]>>;
+
+Core make_from_glyphids(size_t glyphCount, const SkGlyphID* glyphs, SkGlyphID maxGlyphID) {
+ if (glyphCount == 0) { return Core(0, nullptr, 0, nullptr); }
+
+ GlyphSet glyphSet{maxGlyphID};
+
+ auto denseIndex = skstd::make_unique_default<uint16_t[]>(glyphCount);
+ for (size_t i = 0; i < glyphCount; i++) {
+ denseIndex[i] = glyphSet.add(glyphs[i]);
+ }
+
+ std::unique_ptr<SkGlyphID[]> uniqueGlyphIDs;
+ uint16_t uniqueCount;
+ std::tie(uniqueCount, uniqueGlyphIDs) = glyphSet.uniqueGlyphIDs();
+
+ return Core(glyphCount, std::move(denseIndex), uniqueCount, std::move(uniqueGlyphIDs));
+}
+
+Core make_from_utfn(size_t byteLength, const void* utfN, const SkTypeface& typeface,
+ SkTypeface::Encoding encoding) {
+ auto count = SkUTFN_CountUnichars(encoding, utfN, byteLength);
+
+ if (count <= 0) {
+ return Core(0, nullptr, 0, nullptr);
+ }
+
+ auto glyphs = skstd::make_unique_default<SkGlyphID[]>(count);
+
+ // TODO: move to using cached version.
+ typeface.charsToGlyphs(utfN, encoding, glyphs.get(), count);
+
+ return make_from_glyphids(count, glyphs.get(), typeface.countGlyphs());
+}
+
+Core make_core(const SkPaint& paint, const void* bytes, size_t byteLength) {
+ auto encoding = paint.getTextEncoding();
+ auto typeface = SkPaintPriv::GetTypefaceOrDefault(paint);
+ if (encoding == SkPaint::kGlyphID_TextEncoding) {
+ return make_from_glyphids(
+ byteLength / 2, reinterpret_cast<const SkGlyphID*>(bytes), typeface->countGlyphs());
+ } else {
+ return make_from_utfn(byteLength, bytes, *typeface, convert_encoding(encoding));
+ }
+}
+
+} // namespace
+
+SkGlyphRun SkGlyphRun::MakeFromDrawText(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ const SkPoint origin) {
+ size_t runSize;
+ std::unique_ptr<uint16_t[]> denseIndex;
+ uint16_t uniqueSize;
+ std::unique_ptr<SkGlyphID[]> uniqueGlyphIDs;
+ std::tie(runSize, denseIndex, uniqueSize, uniqueGlyphIDs) = make_core(paint, bytes, byteLength);
+
+ if (runSize == 0) { return SkGlyphRun{}; }
+
+ auto advances = skstd::make_unique_default<SkPoint[]>(uniqueSize);
+
+ {
+ auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(paint);
+ cache->getAdvances(SkSpan<SkGlyphID>{uniqueGlyphIDs.get(), uniqueSize}, advances.get());
+ }
+
+ auto positions = skstd::make_unique_default<SkPoint[]>(runSize);
+
+ SkPoint endOfLastGlyph = origin;
+
+ for (size_t i = 0; i < runSize; i++) {
+ positions[i] = endOfLastGlyph;
+ endOfLastGlyph += advances[denseIndex[i]];
+ }
+
+ if (paint.getTextAlign() != SkPaint::kLeft_Align) {
+ SkVector len = endOfLastGlyph - origin;
+ if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+ len.scale(SK_ScalarHalf);
+ }
+ for (size_t i = 0; i < runSize; i++) {
+ positions[i] -= len;
+ }
+ }
+
+ return SkGlyphRun{
+ runSize, std::move(denseIndex), std::move(positions), uniqueSize, std::move(uniqueGlyphIDs)};
+}
+
+SkGlyphRun SkGlyphRun::MakeFromDrawPosTextH(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ const SkScalar xpos[], SkScalar constY) {
+ size_t runSize;
+ std::unique_ptr<uint16_t[]> denseIndex;
+ uint16_t uniqueSize;
+ std::unique_ptr<SkGlyphID[]> uniqueGlyphIDs;
+ std::tie(runSize, denseIndex, uniqueSize, uniqueGlyphIDs) = make_core(paint, bytes, byteLength);
+
+ if (runSize == 0) { return SkGlyphRun{}; }
+
+ auto positions = skstd::make_unique_default<SkPoint[]>(runSize);
+
+ for (size_t i = 0; i < runSize; i++) {
+ positions[i] = SkPoint::Make(xpos[i], constY);
+ }
+
+ return SkGlyphRun{
+ runSize, std::move(denseIndex), std::move(positions), uniqueSize, std::move(uniqueGlyphIDs)};
+}
+
+SkGlyphRun SkGlyphRun::MakeFromDrawPosText(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ const SkPoint pos[]) {
+ size_t runSize;
+ std::unique_ptr<uint16_t[]> denseIndex;
+ uint16_t uniqueSize;
+ std::unique_ptr<SkGlyphID[]> uniqueGlyphIDs;
+ std::tie(runSize, denseIndex, uniqueSize, uniqueGlyphIDs) = make_core(paint, bytes, byteLength);
+
+ if (runSize == 0) { return SkGlyphRun{}; }
+
+ auto positions = skstd::make_unique_default<SkPoint[]>(runSize);
+
+ memcpy(positions.get(), pos, sizeof(SkPoint) * runSize);
+
+ return SkGlyphRun{
+ runSize, std::move(denseIndex), std::move(positions), uniqueSize, std::move(uniqueGlyphIDs)};
+}
+
+std::unique_ptr<SkGlyphID[]> SkGlyphRun::copyGlyphIDs() const {
+ auto glyphs = skstd::make_unique_default<SkGlyphID[]>(fRunSize);
+
+ for (size_t i = 0; i < fRunSize; i++) {
+ glyphs[i] = fUniqueGlyphs[fDenseIndex[i]];
+ }
+
+ return glyphs;
+}
+
+SkGlyphRun::SkGlyphRun(size_t runSize,
+ std::unique_ptr<uint16_t[]>&& denseIndex,
+ std::unique_ptr<SkPoint[]>&& positions,
+ uint16_t uniqueSize,
+ std::unique_ptr<SkGlyphID[]>&& uniqueGlyphIDs)
+ : fDenseIndex{std::move(denseIndex)}
+ , fPositions{std::move(positions)}
+ , fUniqueGlyphs{std::move(uniqueGlyphIDs)}
+ , fRunSize{runSize}
+ , fUniqueSize{uniqueSize} { }
diff --git a/src/core/SkGlyphRun.h b/src/core/SkGlyphRun.h
new file mode 100644
index 0000000..17b4297
--- /dev/null
+++ b/src/core/SkGlyphRun.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2018 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkGlyphRunInfo_DEFINED
+#define SkGlyphRunInfo_DEFINED
+
+#include <memory>
+#include <vector>
+
+#include "SkDescriptor.h"
+#include "SkMask.h"
+#include "SkPath.h"
+#include "SkPoint.h"
+#include "SkTypes.h"
+
+class SkGlyphRun {
+public:
+ SkGlyphRun() = default;
+ SkGlyphRun(SkGlyphRun&&) = default;
+ static SkGlyphRun MakeFromDrawText(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ SkPoint origin);
+ static SkGlyphRun MakeFromDrawPosTextH(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ const SkScalar xpos[], SkScalar constY);
+ static SkGlyphRun MakeFromDrawPosText(
+ const SkPaint& paint, const void* bytes, size_t byteLength,
+ const SkPoint pos[]);
+
+ size_t runSize() const { return fRunSize; }
+ uint16_t uniqueSize() const { return fUniqueSize; }
+
+ // copyGlyphIDs is temporary glue to work with the existing system. Don't use with new code.
+ std::unique_ptr<SkGlyphID[]> copyGlyphIDs() const;
+ const SkScalar* getPositions() const {
+ return reinterpret_cast<const SkScalar*>(fPositions.get());
+ }
+
+private:
+ SkGlyphRun(size_t runSize,
+ std::unique_ptr<uint16_t[]>&& denseIndex,
+ std::unique_ptr<SkPoint[]>&& positions,
+ uint16_t uniqueSize,
+ std::unique_ptr<SkGlyphID[]>&& uniqueGlyphIDs);
+
+ std::unique_ptr<uint16_t[]> fDenseIndex;
+ std::unique_ptr<SkPoint[]> fPositions;
+ std::unique_ptr<SkGlyphID[]> fUniqueGlyphs;
+ const size_t fRunSize{0};
+ const uint16_t fUniqueSize{0};
+};
+
+template <typename T>
+class SkSpan {
+public:
+ SkSpan(const T* ptr, size_t size) : fPtr{ptr}, fSize{size} {}
+ SkSpan(const std::vector<T>& v) : fPtr{v.data()}, fSize{v.size()} {}
+ const T& operator [] (ptrdiff_t i) const { return fPtr[i]; }
+ const T* begin() const { return fPtr; }
+ const T* end() const { return fPtr + fSize; }
+ ptrdiff_t size() const { return fSize; }
+
+private:
+ const T* fPtr;
+ size_t fSize;
+};
+
+#endif // SkGlyphRunInfo_DEFINED
diff --git a/src/core/SkThreadedBMPDevice.cpp b/src/core/SkThreadedBMPDevice.cpp
index b75e90d..10cd824 100644
--- a/src/core/SkThreadedBMPDevice.cpp
+++ b/src/core/SkThreadedBMPDevice.cpp
@@ -210,16 +210,6 @@
});
}
-void SkThreadedBMPDevice::drawText(const void* text, size_t len, SkScalar x, SkScalar y,
- const SkPaint& paint) {
- char* clonedText = this->cloneArray((const char*)text, len);
- SkRect drawBounds = SkRectPriv::MakeLargest(); // TODO tighter drawBounds
- SkSurfaceProps prop(SkBitmapDeviceFilteredSurfaceProps(fBitmap, paint, this->surfaceProps())());
- fQueue.push(drawBounds, [=](SkArenaAlloc*, const DrawState& ds, const SkIRect& tileBounds){
- TileDraw(ds, tileBounds).drawText(clonedText, len, x, y, paint, &prop);
- });
-}
-
void SkThreadedBMPDevice::drawPosText(const void* text, size_t len, const SkScalar xpos[],
int scalarsPerPos, const SkPoint& offset, const SkPaint& paint) {
char* clonedText = this->cloneArray((const char*)text, len);
diff --git a/src/core/SkThreadedBMPDevice.h b/src/core/SkThreadedBMPDevice.h
index d9e27b4..6defce5 100644
--- a/src/core/SkThreadedBMPDevice.h
+++ b/src/core/SkThreadedBMPDevice.h
@@ -32,9 +32,6 @@
void drawPath(const SkPath&, const SkPaint&, const SkMatrix* prePathMatrix,
bool pathIsMutable) override;
void drawSprite(const SkBitmap&, int x, int y, const SkPaint&) override;
-
- void drawText(const void* text, size_t len, SkScalar x, SkScalar y,
- const SkPaint&) override;
void drawPosText(const void* text, size_t len, const SkScalar pos[],
int scalarsPerPos, const SkPoint& offset, const SkPaint& paint) override;
void drawVertices(const SkVertices*, SkBlendMode, const SkPaint&) override;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index e5bda32..a79f9d1 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -217,20 +217,6 @@
return this->getRTOpList();
}
-void GrRenderTargetContext::drawText(const GrClip& clip, const SkPaint& skPaint,
- const SkMatrix& viewMatrix, const char text[],
- size_t byteLength, SkScalar x, SkScalar y,
- const SkIRect& clipBounds) {
- ASSERT_SINGLE_OWNER
- RETURN_IF_ABANDONED
- SkDEBUGCODE(this->validate();)
- GR_CREATE_TRACE_MARKER_CONTEXT("GrRenderTargetContext", "drawText", fContext);
-
- GrTextContext* atlasTextContext = this->drawingManager()->getTextContext();
- atlasTextContext->drawText(fContext, fTextTarget.get(), clip, skPaint, viewMatrix,
- fSurfaceProps, text, byteLength, x, y, clipBounds);
-}
-
void GrRenderTargetContext::drawPosText(const GrClip& clip, const SkPaint& paint,
const SkMatrix& viewMatrix, const char text[],
size_t byteLength, const SkScalar pos[],
diff --git a/src/gpu/GrRenderTargetContext.h b/src/gpu/GrRenderTargetContext.h
index acbf963..d605314 100644
--- a/src/gpu/GrRenderTargetContext.h
+++ b/src/gpu/GrRenderTargetContext.h
@@ -63,9 +63,6 @@
// we could use GrPaint except that
// * SkPaint->GrPaint conversion depends upon whether the glyphs are color or grayscale and
// this can vary within a text run.
- virtual void drawText(const GrClip&, const SkPaint&, const SkMatrix& viewMatrix,
- const char text[], size_t byteLength, SkScalar x, SkScalar y,
- const SkIRect& clipBounds);
virtual void drawPosText(const GrClip&, const SkPaint&, const SkMatrix& viewMatrix,
const char text[], size_t byteLength, const SkScalar pos[],
int scalarsPerPosition, const SkPoint& offset,
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 06307a1..210cefc 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1611,17 +1611,6 @@
///////////////////////////////////////////////////////////////////////////////
-void SkGpuDevice::drawText(const void* text,
- size_t byteLength, SkScalar x, SkScalar y,
- const SkPaint& paint) {
- ASSERT_SINGLE_OWNER
- GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawText", fContext.get());
- SkDEBUGCODE(this->validate();)
-
- fRenderTargetContext->drawText(this->clip(), paint, this->ctm(), (const char*)text, byteLength,
- x, y, this->devClipBounds());
-}
-
void SkGpuDevice::drawPosText(const void* text, size_t byteLength,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint& paint) {
diff --git a/src/gpu/SkGpuDevice.h b/src/gpu/SkGpuDevice.h
index d98dbff..7c7030e 100644
--- a/src/gpu/SkGpuDevice.h
+++ b/src/gpu/SkGpuDevice.h
@@ -87,8 +87,6 @@
const SkPaint& paint, SkCanvas::SrcRectConstraint) override;
void drawSprite(const SkBitmap& bitmap, int x, int y,
const SkPaint& paint) override;
- void drawText(const void* text, size_t len, SkScalar x, SkScalar y,
- const SkPaint&) override;
void drawPosText(const void* text, size_t len, const SkScalar pos[],
int scalarsPerPos, const SkPoint& offset, const SkPaint&) override;
void drawTextBlob(const SkTextBlob*, SkScalar x, SkScalar y,
diff --git a/src/gpu/text/GrTextContext.cpp b/src/gpu/text/GrTextContext.cpp
index f662fa9..72926fe 100644
--- a/src/gpu/text/GrTextContext.cpp
+++ b/src/gpu/text/GrTextContext.cpp
@@ -17,6 +17,7 @@
#include "SkFindAndPlaceGlyph.h"
#include "SkGr.h"
#include "SkGraphics.h"
+#include "SkGlyphRun.h"
#include "SkMakeUnique.h"
#include "SkMaskFilterBase.h"
#include "SkPaintPriv.h"
@@ -209,11 +210,17 @@
shaderCaps.supportsDistanceFieldText(), fOptions)) {
switch (it.positioning()) {
case SkTextBlob::kDefault_Positioning: {
- this->drawDFText(cacheBlob, run, glyphCache, props, runPaint, scalerContextFlags,
- viewMatrix, (const char*)it.glyphs(), textLen, x + offset.x(),
- y + offset.y());
+ auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
+ auto glyphRun =
+ SkGlyphRun::MakeFromDrawText(runPaint.skPaint(),
+ (const char*)it.glyphs(), textLen, origin);
+
+ this->drawDFPosText(cacheBlob, run, glyphCache, props, runPaint,
+ scalerContextFlags, viewMatrix, (const char*)it.glyphs(),
+ textLen, glyphRun.getPositions(), 2, SkPoint::Make(0,0));
break;
}
+
case SkTextBlob::kHorizontal_Positioning: {
SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
this->drawDFPosText(cacheBlob, run, glyphCache, props, runPaint,
@@ -231,11 +238,17 @@
}
} else {
switch (it.positioning()) {
- case SkTextBlob::kDefault_Positioning:
- DrawBmpText(cacheBlob, run, glyphCache, props, runPaint, scalerContextFlags,
- viewMatrix, (const char*)it.glyphs(), textLen, x + offset.x(),
- y + offset.y());
+ case SkTextBlob::kDefault_Positioning: {
+ auto origin = SkPoint::Make(x + offset.x(), y + offset.y());
+ auto glyphRun =
+ SkGlyphRun::MakeFromDrawText(
+ runPaint.skPaint(), (const char*) it.glyphs(), textLen, origin);
+
+ this->DrawBmpPosText(cacheBlob, run, glyphCache, props, runPaint,
+ scalerContextFlags, viewMatrix, (const char*) it.glyphs(),
+ textLen, glyphRun.getPositions(), 2, SkPoint::Make(0, 0));
break;
+ }
case SkTextBlob::kHorizontal_Positioning:
DrawBmpPosText(cacheBlob, run, glyphCache, props, runPaint, scalerContextFlags,
viewMatrix, (const char*)it.glyphs(), textLen, it.pos(), 1,
@@ -252,35 +265,6 @@
}
inline sk_sp<GrTextBlob>
-GrTextContext::makeDrawTextBlob(GrTextBlobCache* blobCache,
- GrGlyphCache* glyphCache,
- const GrShaderCaps& shaderCaps,
- const GrTextUtils::Paint& paint,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix,
- const SkSurfaceProps& props,
- const char text[], size_t byteLength,
- SkScalar x, SkScalar y) const {
- int glyphCount = paint.skPaint().countText(text, byteLength);
- if (!glyphCount) {
- return nullptr;
- }
- sk_sp<GrTextBlob> blob = blobCache->makeBlob(glyphCount, 1);
- blob->initThrowawayBlob(viewMatrix, x, y);
- blob->setRunPaintFlags(0, paint.skPaint().getFlags());
-
- if (CanDrawAsDistanceFields(paint, viewMatrix, props, shaderCaps.supportsDistanceFieldText(),
- fOptions)) {
- this->drawDFText(blob.get(), 0, glyphCache, props, paint, scalerContextFlags, viewMatrix,
- text, byteLength, x, y);
- } else {
- DrawBmpText(blob.get(), 0, glyphCache, props, paint, scalerContextFlags, viewMatrix, text,
- byteLength, x, y);
- }
- return blob;
-}
-
-inline sk_sp<GrTextBlob>
GrTextContext::makeDrawPosTextBlob(GrTextBlobCache* blobCache,
GrGlyphCache* glyphCache,
const GrShaderCaps& shaderCaps,
@@ -311,29 +295,6 @@
return blob;
}
-void GrTextContext::drawText(GrContext* context, GrTextUtils::Target* target,
- const GrClip& clip, const SkPaint& skPaint,
- const SkMatrix& viewMatrix, const SkSurfaceProps& props,
- const char text[], size_t byteLength, SkScalar x, SkScalar y,
- const SkIRect& regionClipBounds) {
- if (context->contextPriv().abandoned()) {
- return;
- }
-
- auto glyphCache = context->contextPriv().getGlyphCache();
- auto textBlobCache = context->contextPriv().getTextBlobCache();
-
- GrTextUtils::Paint paint(&skPaint, &target->colorSpaceInfo());
- sk_sp<GrTextBlob> blob(this->makeDrawTextBlob(
- textBlobCache, glyphCache, *context->contextPriv().caps()->shaderCaps(), paint,
- ComputeScalerContextFlags(target->colorSpaceInfo()), viewMatrix, props, text,
- byteLength, x, y));
- if (blob) {
- blob->flush(target, props, fDistanceAdjustTable.get(), paint,
- clip, viewMatrix, regionClipBounds, x, y);
- }
-}
-
void GrTextContext::drawPosText(GrContext* context, GrTextUtils::Target* target,
const GrClip& clip, const SkPaint& skPaint,
const SkMatrix& viewMatrix, const SkSurfaceProps& props,
@@ -358,41 +319,6 @@
}
}
-void GrTextContext::DrawBmpText(GrTextBlob* blob, int runIndex,
- GrGlyphCache* glyphCache, const SkSurfaceProps& props,
- const GrTextUtils::Paint& paint,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix, const char text[],
- size_t byteLength, SkScalar x, SkScalar y) {
- SkASSERT(byteLength == 0 || text != nullptr);
-
- // nothing to draw
- if (text == nullptr || byteLength == 0) {
- return;
- }
-
- // Ensure the blob is set for bitmaptext
- blob->setHasBitmap();
-
- if (SkDraw::ShouldDrawTextAsPaths(paint, viewMatrix)) {
- DrawBmpTextAsPaths(blob, runIndex, glyphCache, props, paint, scalerContextFlags, viewMatrix,
- text, byteLength, x, y);
- return;
- }
-
- sk_sp<GrTextStrike> currStrike;
- auto cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
- SkFindAndPlaceGlyph::ProcessText(paint.skPaint().getTextEncoding(), text, byteLength, {x, y},
- viewMatrix, paint.skPaint().getTextAlign(), cache.get(),
- [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
- position += rounding;
- BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike,
- glyph, SkScalarFloorToScalar(position.fX),
- SkScalarFloorToScalar(position.fY),
- paint.filteredPremulColor(), cache.get(),
- SK_Scalar1, false);
- });
-}
void GrTextContext::DrawBmpPosText(GrTextBlob* blob, int runIndex,
GrGlyphCache* glyphCache, const SkSurfaceProps& props,
@@ -432,43 +358,6 @@
});
}
-void GrTextContext::DrawBmpTextAsPaths(GrTextBlob* blob, int runIndex,
- GrGlyphCache* glyphCache,
- const SkSurfaceProps& props,
- const GrTextUtils::Paint& origPaint,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix, const char text[],
- size_t byteLength, SkScalar x, SkScalar y) {
- // nothing to draw
- if (text == nullptr || byteLength == 0) {
- return;
- }
-
- // Temporarily jam in kFill, so we only ever ask for the raw outline from the cache.
- SkPaint pathPaint(origPaint);
- pathPaint.setStyle(SkPaint::kFill_Style);
- pathPaint.setPathEffect(nullptr);
-
- GrTextUtils::PathTextIter iter(text, byteLength, pathPaint, true);
- FallbackTextHelper fallbackTextHelper(viewMatrix, pathPaint, glyphCache, iter.getPathScale());
-
- const SkGlyph* iterGlyph;
- const SkPath* iterPath;
- SkScalar xpos = 0;
- const char* lastText = text;
- while (iter.next(&iterGlyph, &iterPath, &xpos)) {
- if (iterGlyph) {
- SkPoint pos = SkPoint::Make(xpos + x, y);
- fallbackTextHelper.appendText(*iterGlyph, iter.getText() - lastText, lastText, pos);
- } else if (iterPath) {
- blob->appendPathGlyph(runIndex, *iterPath, xpos + x, y, iter.getPathScale(), false);
- }
- lastText = iter.getText();
- }
-
- fallbackTextHelper.drawText(blob, runIndex, glyphCache, props, origPaint, scalerContextFlags);
-}
-
void GrTextContext::DrawBmpPosTextAsPaths(GrTextBlob* blob, int runIndex,
GrGlyphCache* glyphCache,
const SkSurfaceProps& props,
@@ -678,74 +567,6 @@
*flags = SkScalerContextFlags::kNone;
}
-void GrTextContext::drawDFText(GrTextBlob* blob, int runIndex,
- GrGlyphCache* glyphCache, const SkSurfaceProps& props,
- const GrTextUtils::Paint& paint,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix, const char text[],
- size_t byteLength, SkScalar x, SkScalar y) const {
- SkASSERT(byteLength == 0 || text != nullptr);
-
- // nothing to draw
- if (text == nullptr || byteLength == 0) {
- return;
- }
-
- const SkPaint& skPaint = paint.skPaint();
- SkPaint::GlyphCacheProc glyphCacheProc =
- SkPaint::GetGlyphCacheProc(skPaint.getTextEncoding(), true);
-
- SkTArray<SkScalar> positions;
-
- const char* textPtr = text;
- SkScalar stopX = 0;
- SkScalar stopY = 0;
-
- SkAutoDescriptor desc;
- SkScalerContextEffects effects;
- // We apply the fake-gamma by altering the distance in the shader, so we ignore the
- // passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
- SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
- skPaint, &props, SkScalerContextFlags::kNone, nullptr, &desc, &effects);
- auto typeface = SkPaintPriv::GetTypefaceOrDefault(skPaint);
-
- {
- auto origPaintCache =
- SkStrikeCache::FindOrCreateStrikeExclusive(*desc.getDesc(), effects, *typeface);
-
- const char* stop = text + byteLength;
- while (textPtr < stop) {
- // don't need x, y here, since all subpixel variants will have the
- // same advance
- const SkGlyph& glyph = glyphCacheProc(origPaintCache.get(), &textPtr);
-
- positions.push_back(stopX);
- positions.push_back(stopY);
-
- stopX += SkFloatToScalar(glyph.fAdvanceX);
- stopY += SkFloatToScalar(glyph.fAdvanceY);
- }
- SkASSERT(textPtr == stop);
- }
-
- // now adjust starting point depending on alignment
- SkScalar alignX = stopX;
- SkScalar alignY = stopY;
- if (skPaint.getTextAlign() == SkPaint::kCenter_Align) {
- alignX = SkScalarHalf(alignX);
- alignY = SkScalarHalf(alignY);
- } else if (skPaint.getTextAlign() == SkPaint::kLeft_Align) {
- alignX = 0;
- alignY = 0;
- }
- x -= alignX;
- y -= alignY;
- SkPoint offset = SkPoint::Make(x, y);
-
- this->drawDFPosText(blob, runIndex, glyphCache, props, paint, scalerContextFlags,
- viewMatrix, text, byteLength, positions.begin(), 2, offset);
-}
-
void GrTextContext::drawDFPosText(GrTextBlob* blob, int runIndex,
GrGlyphCache* glyphCache, const SkSurfaceProps& props,
const GrTextUtils::Paint& paint,
@@ -936,11 +757,15 @@
// right now we don't handle textblobs, nor do we handle drawPosText. Since we only intend to
// test the text op with this unit test, that is okay.
- sk_sp<GrTextBlob> blob(textContext->makeDrawTextBlob(
+
+ auto origin = SkPoint::Make(x, y);
+ auto glyphRun = SkGlyphRun::MakeFromDrawText(skPaint, text, textLen, origin);
+
+ sk_sp<GrTextBlob> blob(textContext->makeDrawPosTextBlob(
context->contextPriv().getTextBlobCache(), glyphCache,
*context->contextPriv().caps()->shaderCaps(), utilsPaint,
GrTextContext::kTextBlobOpScalerContextFlags, viewMatrix, surfaceProps, text,
- static_cast<size_t>(textLen), SkIntToScalar(x), SkIntToScalar(y)));
+ static_cast<size_t>(textLen), glyphRun.getPositions(), 2, origin));
return blob->test_makeOp(textLen, 0, 0, viewMatrix, x, y, utilsPaint, surfaceProps,
textContext->dfAdjustTable(), rtc->textTarget());
diff --git a/src/gpu/text/GrTextContext.h b/src/gpu/text/GrTextContext.h
index 3dab70b..7d31d84 100644
--- a/src/gpu/text/GrTextContext.h
+++ b/src/gpu/text/GrTextContext.h
@@ -44,9 +44,6 @@
static std::unique_ptr<GrTextContext> Make(const Options& options);
- void drawText(GrContext*, GrTextUtils::Target*, const GrClip&, const SkPaint&,
- const SkMatrix& viewMatrix, const SkSurfaceProps&, const char text[],
- size_t byteLength, SkScalar x, SkScalar y, const SkIRect& regionClipBounds);
void drawPosText(GrContext*, GrTextUtils::Target*, const GrClip&, const SkPaint&,
const SkMatrix& viewMatrix, const SkSurfaceProps&, const char text[],
size_t byteLength, const SkScalar pos[], int scalarsPerPosition,
@@ -123,15 +120,6 @@
static bool HasLCD(const SkTextBlob*);
- sk_sp<GrTextBlob> makeDrawTextBlob(GrTextBlobCache*, GrGlyphCache*,
- const GrShaderCaps&,
- const GrTextUtils::Paint&,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix,
- const SkSurfaceProps&,
- const char text[], size_t byteLength,
- SkScalar x, SkScalar y) const;
-
sk_sp<GrTextBlob> makeDrawPosTextBlob(GrTextBlobCache*, GrGlyphCache*,
const GrShaderCaps&,
const GrTextUtils::Paint&,
@@ -144,23 +132,12 @@
const SkPoint& offset) const;
// Functions for appending BMP text to GrTextBlob
- static void DrawBmpText(GrTextBlob*, int runIndex, GrGlyphCache*,
- const SkSurfaceProps&, const GrTextUtils::Paint& paint,
- SkScalerContextFlags scalerContextFlags, const SkMatrix& viewMatrix,
- const char text[], size_t byteLength, SkScalar x, SkScalar y);
-
static void DrawBmpPosText(GrTextBlob*, int runIndex, GrGlyphCache*,
const SkSurfaceProps&, const GrTextUtils::Paint& paint,
SkScalerContextFlags scalerContextFlags, const SkMatrix& viewMatrix,
const char text[], size_t byteLength, const SkScalar pos[],
int scalarsPerPosition, const SkPoint& offset);
- static void DrawBmpTextAsPaths(GrTextBlob*, int runIndex, GrGlyphCache*,
- const SkSurfaceProps&, const GrTextUtils::Paint& paint,
- SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix, const char text[],
- size_t byteLength, SkScalar x, SkScalar y);
-
static void DrawBmpPosTextAsPaths(GrTextBlob*, int runIndex, GrGlyphCache*,
const SkSurfaceProps&, const GrTextUtils::Paint& paint,
SkScalerContextFlags scalerContextFlags,
@@ -170,11 +147,6 @@
const SkPoint& offset);
// functions for appending distance field text
- void drawDFText(GrTextBlob* blob, int runIndex, GrGlyphCache*, const SkSurfaceProps&,
- const GrTextUtils::Paint& paint, SkScalerContextFlags scalerContextFlags,
- const SkMatrix& viewMatrix, const char text[], size_t byteLength, SkScalar x,
- SkScalar y) const;
-
void drawDFPosText(GrTextBlob* blob, int runIndex, GrGlyphCache*,
const SkSurfaceProps&, const GrTextUtils::Paint& paint,
SkScalerContextFlags scalerContextFlags,
diff --git a/src/pdf/SkPDFDevice.cpp b/src/pdf/SkPDFDevice.cpp
index 1cf649c..f4c034e 100644
--- a/src/pdf/SkPDFDevice.cpp
+++ b/src/pdf/SkPDFDevice.cpp
@@ -1450,12 +1450,6 @@
}
}
-void SkPDFDevice::drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) {
- this->internalDrawText(text, len, nullptr, SkTextBlob::kDefault_Positioning,
- SkPoint{x, y}, paint, nullptr, 0, nullptr);
-}
-
void SkPDFDevice::drawPosText(const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint& paint) {
diff --git a/src/pdf/SkPDFDevice.h b/src/pdf/SkPDFDevice.h
index a9c0590..33d0e70 100644
--- a/src/pdf/SkPDFDevice.h
+++ b/src/pdf/SkPDFDevice.h
@@ -95,8 +95,6 @@
const SkRect& dst,
const SkPaint&,
SkCanvas::SrcRectConstraint) override;
- void drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint&) override;
void drawPosText(const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint&) override;
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index e777f60..3462f7c 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -936,17 +936,6 @@
drawBitmapCommon(MxCp(&adjustedMatrix, cs), bm, paint);
}
-void SkSVGDevice::drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) {
- AutoElement elem("text", fWriter, fResourceBucket.get(), MxCp(this), paint);
- elem.addTextAttributes(paint);
-
- SVGTextBuilder builder(text, len, paint, SkPoint::Make(x, y), 0);
- elem.addAttribute("x", builder.posX());
- elem.addAttribute("y", builder.posY());
- elem.addText(builder.text());
-}
-
void SkSVGDevice::drawPosText(const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos, const SkPoint& offset,
const SkPaint& paint) {
diff --git a/src/svg/SkSVGDevice.h b/src/svg/SkSVGDevice.h
index 222e55d..4784c7e 100644
--- a/src/svg/SkSVGDevice.h
+++ b/src/svg/SkSVGDevice.h
@@ -37,8 +37,6 @@
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint, SkCanvas::SrcRectConstraint) override;
- void drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) override;
void drawPosText(const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint& paint) override;
diff --git a/src/xps/SkXPSDevice.cpp b/src/xps/SkXPSDevice.cpp
index 29ee8f3..ef5f488 100644
--- a/src/xps/SkXPSDevice.cpp
+++ b/src/xps/SkXPSDevice.cpp
@@ -2047,63 +2047,6 @@
GlyphRun* const fXpsGlyphs;
};
-void SkXPSDevice::drawText(const void* text, size_t byteLen,
- SkScalar x, SkScalar y,
- const SkPaint& paint) {
- if (byteLen < 1) return;
-
- if (text_must_be_pathed(paint, this->ctm())) {
- SkPath path;
- paint.getTextPath(text, byteLen, x, y, &path);
- this->drawPath(path, paint, nullptr, true);
- //TODO: add automation "text"
- return;
- }
-
- TypefaceUse* typeface;
- HRV(CreateTypefaceUse(paint, &typeface));
-
- auto cache =
- SkStrikeCache::FindOrCreateStrikeExclusive(
- paint, &this->surfaceProps(),
- SkScalerContextFlags::kNone, nullptr);
-
- // Advance width and offsets for glyphs measured in hundredths of the font em size
- // (XPS Spec 5.1.3).
- FLOAT centemPerUnit = 100.0f / SkScalarToFLOAT(paint.getTextSize());
- GlyphRun xpsGlyphs;
- xpsGlyphs.setReserve(num_glyph_guess(paint.getTextEncoding(),
- static_cast<const char*>(text), byteLen));
-
- ProcessOneGlyph processOneGlyph(centemPerUnit, typeface->glyphsUsed, &xpsGlyphs);
-
- SkFindAndPlaceGlyph::ProcessText(
- paint.getTextEncoding(), static_cast<const char*>(text), byteLen,
- SkPoint{ x, y }, SkMatrix::I(), paint.getTextAlign(), cache.get(), processOneGlyph);
-
- if (xpsGlyphs.count() == 0) {
- return;
- }
-
- XPS_POINT origin = {
- xpsGlyphs[0].horizontalOffset / centemPerUnit,
- xpsGlyphs[0].verticalOffset / -centemPerUnit,
- };
- xpsGlyphs[0].horizontalOffset = 0.0f;
- xpsGlyphs[0].verticalOffset = 0.0f;
-
- HRV(AddGlyphs(this->fXpsFactory.get(),
- this->fCurrentXpsCanvas.get(),
- typeface,
- nullptr,
- xpsGlyphs.begin(), xpsGlyphs.count(),
- &origin,
- SkScalarToFLOAT(paint.getTextSize()),
- XPS_STYLE_SIMULATION_NONE,
- this->ctm(),
- paint));
-}
-
void SkXPSDevice::drawPosText(const void* text, size_t byteLen,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint& paint) {
diff --git a/src/xps/SkXPSDevice.h b/src/xps/SkXPSDevice.h
index a5ee076..81e881e 100644
--- a/src/xps/SkXPSDevice.h
+++ b/src/xps/SkXPSDevice.h
@@ -97,8 +97,6 @@
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
SkCanvas::SrcRectConstraint) override;
- void drawText(const void* text, size_t len,
- SkScalar x, SkScalar y, const SkPaint& paint) override;
void drawPosText(const void* text, size_t len,
const SkScalar pos[], int scalarsPerPos,
const SkPoint& offset, const SkPaint& paint) override;