Revert "use serialprocs for typefaces"

This reverts commit b681972e79.

Reason for revert: need to handle null typeface in new procs

Original change's description:
> use serialprocs for typefaces
> 
> Bug: skia:
> Change-Id: Ibf59a0fdcf68e8555bd4241e9473e733f6a30993
> Reviewed-on: https://skia-review.googlesource.com/81840
> Reviewed-by: Florin Malita <fmalita@chromium.org>
> Reviewed-by: Mike Klein <mtklein@chromium.org>
> Commit-Queue: Mike Reed <reed@google.com>

TBR=mtklein@chromium.org,mtklein@google.com,fmalita@chromium.org,reed@google.com

Change-Id: Id69500fbc291ecee753e7ee6b80abc2a7cd60d18
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:
Reviewed-on: https://skia-review.googlesource.com/82341
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>

include/core/SkTextBlob.h

@@ -17,9 +17,6 @@
 class SkReadBuffer;
 class SkWriteBuffer;
 
-struct SkSerialProcs;
-struct SkDeserialProcs;
-
 typedef void (*SkTypefaceCatalogerProc)(SkTypeface*, void* ctx);
 typedef sk_sp<SkTypeface> (*SkTypefaceResolverProc)(uint32_t id, void* ctx);
 
@@ -74,9 +71,6 @@ public:
     static sk_sp<SkTextBlob> Deserialize(const void* data, size_t size,
                                          SkTypefaceResolverProc, void* ctx);
 
-    sk_sp<SkData> serialize(const SkSerialProcs&) const;
-    static sk_sp<SkTextBlob> Deserialize(const void* data, size_t size, const SkDeserialProcs&);
-
 private:
     friend class SkNVRefCnt<SkTextBlob>;
     class RunRecord;

src/core/SkReadBuffer.cpp

@@ -374,26 +374,12 @@ sk_sp<SkTypeface> SkReadBuffer::readTypeface() {
         return sk_ref_sp(fInflator->getTypeface(this->read32()));
     }
 
-    // Read 32 bits (signed)
+    uint32_t index = this->readUInt();
-    //   0 -- failure
+    if (0 == index || index > (unsigned)fTFCount) {
-    //  >0 -- index
-    //  <0 -- custom (serial procs) : negative size in bytes
-
-    int32_t index = this->readUInt();
-    if (index == 0) {
         return nullptr;
-    } else if (index > 0) {
+    } else {
-        if (index > fTFCount) {
+        SkASSERT(fTFArray);
-            return nullptr;
-        }
         return sk_ref_sp(fTFArray[index - 1]);
-    } else {    // custom
-        size_t size = -index;
-        const void* data = this->skip(size);
-        if (!data) {
-            return nullptr;
-        }
-        return fProcs.fTypefaceProc(data, size, fProcs.fTypefaceCtx);
     }
 }
 

src/core/SkReadBuffer.h

@@ -185,7 +185,7 @@ public:
     // be created (e.g. it was not originally encoded) then this returns an image that doesn't
     // draw.
     sk_sp<SkImage> readImage();
-    sk_sp<SkTypeface> readTypeface();
+    virtual sk_sp<SkTypeface> readTypeface();
 
     void setTypefaceArray(SkTypeface* array[], int count) {
         fTFArray = array;

src/core/SkTextBlob.cpp

@@ -868,9 +868,25 @@ sk_sp<SkTextBlob> SkTextBlob::MakeFromBuffer(SkReadBuffer& reader) {
     return blobBuilder.make();
 }
 
-sk_sp<SkData> SkTextBlob::serialize(const SkSerialProcs& procs) const {
+class SkTypefaceCatalogerWriteBuffer : public SkBinaryWriteBuffer {
-    SkBinaryWriteBuffer buffer;
+public:
-    buffer.setSerialProcs(procs);
+    SkTypefaceCatalogerWriteBuffer(SkTypefaceCatalogerProc proc, void* ctx)
+        : SkBinaryWriteBuffer(SkBinaryWriteBuffer::kCrossProcess_Flag)
+        , fCatalogerProc(proc)
+        , fCatalogerCtx(ctx)
+    {}
+
+    void writeTypeface(SkTypeface* typeface) override {
+        fCatalogerProc(typeface, fCatalogerCtx);
+        this->write32(typeface ? typeface->uniqueID() : 0);
+    }
+
+    SkTypefaceCatalogerProc fCatalogerProc;
+    void*                   fCatalogerCtx;
+};
+
+sk_sp<SkData> SkTextBlob::serialize(SkTypefaceCatalogerProc proc, void* ctx) const {
+    SkTypefaceCatalogerWriteBuffer buffer(proc, ctx);
     this->flatten(buffer);
 
     size_t total = buffer.bytesWritten();
@@ -879,61 +895,26 @@ sk_sp<SkData> SkTextBlob::serialize(const SkSerialProcs& procs) const {
     return data;
 }
 
-sk_sp<SkTextBlob> SkTextBlob::Deserialize(const void* data, size_t length,
+class SkTypefaceResolverReadBuffer : public SkReadBuffer {
-                                          const SkDeserialProcs& procs) {
+public:
-    SkReadBuffer buffer(data, length);
+    SkTypefaceResolverReadBuffer(const void* data, size_t size, SkTypefaceResolverProc proc,
-    buffer.setDeserialProcs(procs);
+                                 void* ctx)
-    return SkTextBlob::MakeFromBuffer(buffer);
+        : SkReadBuffer(data, size)
-}
+        , fResolverProc(proc)
+        , fResolverCtx(ctx)
+    {}
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
+    sk_sp<SkTypeface> readTypeface() override {
-
+        auto id = this->readUInt();
-namespace {
+        return this->isValid() ? fResolverProc(id, fResolverCtx) : nullptr;
-    struct CatalogState {
-        SkTypefaceCatalogerProc fProc;
-        void*                   fCtx;
-    };
-
-    bool catalog_typeface_proc(SkTypeface* face, SkWStream* stream, void* ctx) {
-        CatalogState* state = static_cast<CatalogState*>(ctx);
-        state->fProc(face, state->fCtx);
-        stream->write32(face->uniqueID());
-        return true;
     }
-}
 
-sk_sp<SkData> SkTextBlob::serialize(SkTypefaceCatalogerProc proc, void* ctx) const {
+    SkTypefaceResolverProc  fResolverProc;
-    CatalogState state = { proc, ctx };
+    void*                   fResolverCtx;
-    SkSerialProcs procs;
+};
-    procs.fTypefaceProc = catalog_typeface_proc;
-    procs.fTypefaceCtx  = &state;
-    return this->serialize(procs);
-}
-
-namespace {
-    struct ResolverState {
-        SkTypefaceResolverProc  fProc;
-        void*                   fCtx;
-    };
-
-    sk_sp<SkTypeface> resolver_typeface_proc(const void* data, size_t length, void* ctx) {
-        SkASSERT(length == 4);
-        if (length != 4) {
-            return nullptr;
-        }
-
-        ResolverState* state = static_cast<ResolverState*>(ctx);
-        uint32_t id;
-        memcpy(&id, data, length);
-        return state->fProc(id, state->fCtx);
-    }
-}
 
 sk_sp<SkTextBlob> SkTextBlob::Deserialize(const void* data, size_t length,
                                           SkTypefaceResolverProc proc, void* ctx) {
-    ResolverState state = { proc, ctx };
+    SkTypefaceResolverReadBuffer buffer(data, length, proc, ctx);
-    SkDeserialProcs procs;
+    return SkTextBlob::MakeFromBuffer(buffer);
-    procs.fTypefaceProc = resolver_typeface_proc;
-    procs.fTypefaceCtx  = &state;
-    return Deserialize(data, length, procs);
 }

src/core/SkWriteBuffer.cpp

@@ -175,31 +175,11 @@ void SkBinaryWriteBuffer::writeTypeface(SkTypeface* obj) {
         return;
     }
 
-    // Write 32 bits (signed)
+    if (nullptr == obj || nullptr == fTFSet) {
-    //   0 -- failure
-    //  >0 -- index
-    //  <0 -- custom (serial procs)
-
-    if (obj == nullptr) {
         fWriter.write32(0);
-    } else if (fProcs.fTypefaceProc) {
+    } else {
-        SkDynamicMemoryWStream stream;
+        fWriter.write32(fTFSet->add(obj));
-        if (fProcs.fTypefaceProc(obj, &stream, fProcs.fTypefaceCtx)) {
-            auto data = stream.detachAsData();
-            size_t size = data->size();
-            if (!sk_64_isS32(size)) {
-                size = 0;
-            }
-            int32_t ssize = SkToS32(size);
-            fWriter.write32(-ssize);    // negative to signal custom
-            if (size) {
-                this->writePad32(data->data(), size);
-            }
-            return;
-        }
-        // if the proc returned false, we fall through for std behavior
     }
-    fWriter.write32(fTFSet ? fTFSet->add(obj) : 0);
 }
 
 void SkBinaryWriteBuffer::writePaint(const SkPaint& paint) {