From 785586af7dc72c23d0ab30204ab2975a1451dc16 Mon Sep 17 00:00:00 2001 From: Cary Clark Date: Thu, 19 Jul 2018 10:07:01 -0400 Subject: remove unused serialization in textblob The SKTextBlob serialization code that is tested by Skia is unused by Chrome. The serialization code that is used by Chrome is untested by Skia. Remove the unused code; test the used code. The code path introduced nearly a year ago, likely for slimming paint, attempts to make text blobs smarter by allowing the reuse of typefaces. Maybe there needs to be a Chrome bug / feature request to use this? If if turns out there is no interest to do so, This CL aligns used interfaces with tests. R=reed@google.com,fmalita@google.com,bungeman@google.com Bug: skia:6818 Change-Id: I9b3ec0c326495322986ba26f20f901bcb208be73 Reviewed-on: https://skia-review.googlesource.com/141542 Reviewed-by: Cary Clark Reviewed-by: Florin Malita Reviewed-by: Ben Wagner Reviewed-by: Mike Reed Commit-Queue: Cary Clark Auto-Submit: Cary Clark --- include/core/SkTextBlob.h | 22 +++------------------ src/core/SkTextBlob.cpp | 49 ----------------------------------------------- tests/TextBlobTest.cpp | 49 ++++++++++++++++++++++++++++------------------- 3 files changed, 32 insertions(+), 88 deletions(-) diff --git a/include/core/SkTextBlob.h b/include/core/SkTextBlob.h index 8dce082512..cf77a78ca5 100644 --- a/include/core/SkTextBlob.h +++ b/include/core/SkTextBlob.h @@ -17,9 +17,6 @@ struct SkSerialProcs; struct SkDeserialProcs; -typedef void (*SkTypefaceCatalogerProc)(SkTypeface*, void* ctx); -typedef sk_sp (*SkTypefaceResolverProc)(uint32_t id, void* ctx); - /** \class SkTextBlob SkTextBlob combines multiple text runs into an immutable, ref-counted structure. @@ -45,29 +42,16 @@ public: kFull_Positioning = 2 // Point positioning -- two scalars per glyph. }; - /** - * Serialize the typeface into a data blob, storing type uniqueID of each referenced typeface. - * During this process, each time a typeface is encountered, it is passed to the catalog, - * allowing the caller to what typeface IDs will need to be resolved in Deserialize(). - */ - sk_sp serialize(SkTypefaceCatalogerProc, void* ctx) const; - /** * Similar to serialize above, but writes directly into |memory|. Returns bytes written or 0u * if serialization failed due to insufficient size. */ size_t serialize(const SkSerialProcs& procs, void* memory, size_t memory_size) const; - /** - * Re-create a text blob previously serialized. Since the serialized form records the uniqueIDs - * of its typefaces, deserialization requires that the caller provide the corresponding - * SkTypefaces for those IDs. - */ - static sk_sp Deserialize(const void* data, size_t size, - SkTypefaceResolverProc, void* ctx); + sk_sp serialize(const SkSerialProcs& procs) const; - sk_sp serialize(const SkSerialProcs&) const; - static sk_sp Deserialize(const void* data, size_t size, const SkDeserialProcs&); + static sk_sp Deserialize(const void* data, size_t size, + const SkDeserialProcs& procs); private: friend class SkNVRefCnt; diff --git a/src/core/SkTextBlob.cpp b/src/core/SkTextBlob.cpp index fec7c527a2..4528e64f15 100644 --- a/src/core/SkTextBlob.cpp +++ b/src/core/SkTextBlob.cpp @@ -927,58 +927,9 @@ sk_sp SkTextBlob::Deserialize(const void* data, size_t length, /////////////////////////////////////////////////////////////////////////////////////////////////// -namespace { - struct CatalogState { - SkTypefaceCatalogerProc fProc; - void* fCtx; - }; - - sk_sp catalog_typeface_proc(SkTypeface* face, void* ctx) { - CatalogState* state = static_cast(ctx); - state->fProc(face, state->fCtx); - uint32_t id = face->uniqueID(); - return SkData::MakeWithCopy(&id, sizeof(uint32_t)); - } -} - -sk_sp SkTextBlob::serialize(SkTypefaceCatalogerProc proc, void* ctx) const { - CatalogState state = { proc, ctx }; - SkSerialProcs procs; - procs.fTypefaceProc = catalog_typeface_proc; - procs.fTypefaceCtx = &state; - return this->serialize(procs); -} - size_t SkTextBlob::serialize(const SkSerialProcs& procs, void* memory, size_t memory_size) const { SkBinaryWriteBuffer buffer(memory, memory_size); buffer.setSerialProcs(procs); SkTextBlobPriv::Flatten(*this, buffer); return buffer.usingInitialStorage() ? buffer.bytesWritten() : 0u; } - -namespace { - struct ResolverState { - SkTypefaceResolverProc fProc; - void* fCtx; - }; - - sk_sp resolver_typeface_proc(const void* data, size_t length, void* ctx) { - if (length != 4) { - return nullptr; - } - - ResolverState* state = static_cast(ctx); - uint32_t id; - memcpy(&id, data, length); - return state->fProc(id, state->fCtx); - } -} - -sk_sp SkTextBlob::Deserialize(const void* data, size_t length, - SkTypefaceResolverProc proc, void* ctx) { - ResolverState state = { proc, ctx }; - SkDeserialProcs procs; - procs.fTypefaceProc = resolver_typeface_proc; - procs.fTypefaceCtx = &state; - return Deserialize(data, length, procs); -} diff --git a/tests/TextBlobTest.cpp b/tests/TextBlobTest.cpp index 7780ef7a7f..5018d7a79b 100644 --- a/tests/TextBlobTest.cpp +++ b/tests/TextBlobTest.cpp @@ -7,6 +7,7 @@ #include "SkPaint.h" #include "SkPoint.h" +#include "SkSerialProcs.h" #include "SkTextBlobRunIterator.h" #include "SkTo.h" #include "SkTypeface.h" @@ -412,6 +413,25 @@ static sk_sp render(const SkTextBlob* blob) { return surf->makeImageSnapshot(); } +static sk_sp SerializeTypeface(SkTypeface* tf, void* ctx) { + auto array = (SkTDArray*)ctx; + *array->append() = tf; + return sk_sp(nullptr); +} + +static sk_sp DeserializeTypeface(const void* data, size_t length, void* ctx) { + auto array = (SkTDArray*)ctx; + for (int i = 0; i < array->count(); ++i) { + auto result = (*array)[i]; + if (result) { + (*array)[i] = nullptr; + return sk_ref_sp(result); + } + } + SkASSERT(false); + return sk_sp(nullptr); +} + /* * Build a blob with more than one typeface. * Draw it into an offscreen, @@ -429,26 +449,15 @@ DEF_TEST(TextBlob_serialize, reporter) { }(); SkTDArray array; - sk_sp data = blob0->serialize([](SkTypeface* tf, void* ctx) { - auto array = (SkTDArray*)ctx; - if (array->find(tf) < 0) { - *array->append() = tf; - } - }, &array); - // we only expect 1, since null would not have been serialized, but the default would - REPORTER_ASSERT(reporter, array.count() == 1); - - sk_sp blob1 = SkTextBlob::Deserialize(data->data(), data->size(), - [](uint32_t uniqueID, void* ctx) { - auto array = (SkTDArray*)ctx; - for (int i = 0; i < array->count(); ++i) { - if ((*array)[i]->uniqueID() == uniqueID) { - return sk_ref_sp((*array)[i]); - } - } - SkASSERT(false); - return sk_sp(nullptr); - }, &array); + SkSerialProcs serializeProcs; + serializeProcs.fTypefaceProc = &SerializeTypeface; + serializeProcs.fTypefaceCtx = (void*) &array; + sk_sp data = blob0->serialize(serializeProcs); + REPORTER_ASSERT(reporter, array.count() == 2); + SkDeserialProcs deserializeProcs; + deserializeProcs.fTypefaceProc = &DeserializeTypeface; + deserializeProcs.fTypefaceCtx = (void*) &array; + sk_sp blob1 = SkTextBlob::Deserialize(data->data(), data->size(), deserializeProcs); sk_sp img0 = render(blob0.get()); sk_sp img1 = render(blob1.get()); -- cgit v1.2.3