SkTextBlob plumbing

src/core/SkTextBlob.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTextBlob.h"
 
+#include "SkReadBuffer.h"
+#include "SkWriteBuffer.h"
+
 SkTextBlob::SkTextBlob(uint16_t *glyphs, SkScalar *pos, const SkTArray<Run> *runs,
                        const SkRect& bounds)
     : fGlyphBuffer(glyphs)
     , fPosBuffer(pos)
     , fRuns(runs)
     , fBounds(bounds) {
 }
 
 uint32_t SkTextBlob::uniqueID() const {
     static int32_t  gTextBlobGenerationID; // = 0;
 
     // loop in case our global wraps around, as we never want to return SK_InvalidGenID
     while (SK_InvalidGenID == fUniqueID) {
         fUniqueID = sk_atomic_inc(&gTextBlobGenerationID) + 1;
     }
 
     return fUniqueID;
 }
 
+unsigned SkTextBlob::ScalarsPerGlyph(GlyphPositioning pos) {
+    // GlyphPositioning values are directly mapped to scalars-per-glyph.
+    SkASSERT(pos <= 2);
+    return pos;
+}
+
+void SkTextBlob::flatten(SkWriteBuffer& buffer) const {
+    int runCount = (NULL == fRuns.get()) ? 0 : fRuns->count();
+
+    buffer.write32(runCount);
+    buffer.writeRect(fBounds);
+
+    size_t glyphBufferCount = 0;
+    size_t posBufferCount = 0;
+
+    for (int i = 0; i < runCount; ++i) {
+        const Run& run = (*fRuns)[i];
+        SkASSERT(run.count > 0);
+
+        buffer.write32(run.count);
+        buffer.write32(run.glyphStart);
+        buffer.write32(run.posStart);
+        buffer.writePoint(run.offset);
+        buffer.writePaint(run.font);
+        buffer.write32(run.positioning);
+
+        glyphBufferCount += run.count;
+        posBufferCount += run.count * ScalarsPerGlyph(run.positioning);
+    }
+
+    buffer.writeByteArray(fGlyphBuffer, glyphBufferCount * sizeof(uint16_t));
+    buffer.writeByteArray(fPosBuffer, posBufferCount * sizeof(SkScalar));
+}
+
+const SkTextBlob* SkTextBlob::CreateFromBuffer(SkReadBuffer& buffer) {
+    int runCount = buffer.read32();
+    if (runCount <= 0) {
+        return NULL;
+    }
+
+    SkRect bounds;
+    buffer.readRect(&bounds);
+
+    size_t glyphBufferCount = 0;
+    size_t posBufferCount = 0;
+    SkAutoTDelete<SkTArray<Run> > runs(SkNEW_ARGS(SkTArray<Run>, (runCount)));
+    for (int i = 0; i < runCount; ++i) {
+        Run& run = runs->push_back();
+
+        run.count = buffer.read32();
+        if (0 == run.count) {
+            return NULL;
+        }
+
+        run.glyphStart = buffer.read32();
+        run.posStart = buffer.read32();
+        if (run.glyphStart != glyphBufferCount || run.posStart != posBufferCount) {
+            return NULL;
+        }
+
+        buffer.readPoint(&run.offset);
+        buffer.readPaint(&run.font);
+
+        run.positioning = static_cast<GlyphPositioning>(buffer.read32());
+        if (run.positioning > 2) {
+            return NULL;
+        }
+
+        glyphBufferCount += run.count;
+        posBufferCount += run.count * ScalarsPerGlyph(run.positioning);
+    }
+
+    SkTDArray<uint16_t> glyphBuffer;
+    SkTDArray<SkScalar> posBuffer;
+
+    buffer.readByteArray(glyphBuffer.append(glyphBufferCount),
+                         glyphBufferCount * sizeof(uint16_t));
+    buffer.readByteArray(posBuffer.append(posBufferCount),
+                         posBufferCount * sizeof(SkScalar));
+
+    return SkNEW_ARGS(SkTextBlob, (glyphBuffer.detach(),
+                                   posBuffer.detach(),
+                                   runs.detach(),
+                                   bounds));
+}
+
 SkTextBlob::RunIterator::RunIterator(const SkTextBlob* blob)
     : fBlob(blob)
     , fIndex(0) {
     SkASSERT(NULL != blob);
 }
 
 bool SkTextBlob::RunIterator::done() const {
     return NULL == fBlob->fRuns.get() || fIndex >= fBlob->fRuns->count();
 }
 
@@ skipping 115 matching lines @@
     newRun.positioning = pos;
 }
 
 void SkTextBlobBuilder::allocInternal(const SkPaint &font,
                                       SkTextBlob::GlyphPositioning positioning,
                                       int count, SkPoint offset, const SkRect* bounds) {
     SkASSERT(count > 0);
 
     this->ensureRun(font, positioning, offset);
 
-    // SkTextBlob::GlyphPositioning values are directly mapped to scalars-per-glyph.
-    unsigned posScalarsPerGlyph = positioning;
-    SkASSERT(posScalarsPerGlyph <= 2);
+    unsigned posScalarsPerGlyph = SkTextBlob::ScalarsPerGlyph(positioning);
 
     fGlyphBuffer.append(count);
     fPosBuffer.append(count * posScalarsPerGlyph);
 
     SkASSERT(NULL != fRuns && !fRuns->empty());
     SkTextBlob::Run& run = fRuns->back();
 
     run.count += count;
 
     // The current run might have been merged, so the start offset may point to prev run data.
@@ skipping 58 matching lines @@
         // empty blob
         SkASSERT(NULL == fRuns || fRuns->empty());
         SkASSERT(fBounds.isEmpty());
 
         blob = SkNEW_ARGS(SkTextBlob, (NULL, NULL, NULL, SkRect::MakeEmpty()));
     }
 
     return blob;
 }