Ensure blob typeface information survives SkGPipe serialization.

src/pipe/SkGPipeWrite.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotation.h"
 #include "SkBitmapDevice.h"
 #include "SkBitmapHeap.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkData.h"
 #include "SkDrawLooper.h"
 #include "SkGPipe.h"
 #include "SkGPipePriv.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkWriteBuffer.h"
 #include "SkPaint.h"
 #include "SkPatchUtils.h"
 #include "SkPathEffect.h"
 #include "SkPictureFlat.h"
+#include "SkPtrRecorder.h"
 #include "SkRasterizer.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkStream.h"
 #include "SkTextBlob.h"
 #include "SkTSearch.h"
 #include "SkTypeface.h"
 #include "SkWriter32.h"
 
 enum {
     kSizeOfFlatRRect = sizeof(SkRect) + 4 * sizeof(SkVector)
 };
 
-static bool isCrossProcess(uint32_t flags) {
+static bool is_cross_process(uint32_t flags) {
     return SkToBool(flags & SkGPipeWriter::kCrossProcess_Flag);
 }
 
 static SkFlattenable* get_paintflat(const SkPaint& paint, unsigned paintFlat) {
     SkASSERT(paintFlat < kCount_PaintFlats);
     switch (paintFlat) {
         case kColorFilter_PaintFlat:    return paint.getColorFilter();
         case kDrawLooper_PaintFlat:     return paint.getLooper();
         case kMaskFilter_PaintFlat:     return paint.getMaskFilter();
         case kPathEffect_PaintFlat:     return paint.getPathEffect();
@@ skipping 282 matching lines @@
     inline void doNotify() {
         if (!fDone) {
             size_t bytes = fWriter.bytesWritten() - fBytesNotified;
             if (bytes > 0) {
                 fController->notifyWritten(bytes);
                 fBytesNotified += bytes;
             }
         }
     }
 
+    size_t prepareInProcessTypefaceBuffer(const SkRefCntSet& typefaceSet, void* buffer);
+    size_t prepareCrossProcessTypefaceBuffer(const SkRefCntSet& typefaceSet, void* buffer);
+
     // Should be called after any calls to an SkFlatDictionary::findAndReplace
     // if a new SkFlatData was added when in cross process mode
     void flattenFactoryNames();
 
     FlattenableHeap             fFlattenableHeap;
     FlatDictionary              fFlatDictionary;
     SkAutoTUnref<BitmapShuttle> fBitmapShuttle;
     int                         fCurrFlatIndex[kCount_PaintFlats];
 
     int flattenToIndex(SkFlattenable* obj, PaintFlats);
@@ skipping 53 matching lines @@
         return 0;
     }
 
     fBitmapHeap->deferAddingOwners();
     bool added, replaced;
     const SkFlatData* flat = fFlatDictionary.findAndReplace(*obj, fFlattenableHeap.flatToReplace(),
                                                             &added, &replaced);
     fBitmapHeap->endAddingOwnersDeferral(added);
     int index = flat->index();
     if (added) {
-        if (isCrossProcess(fFlags)) {
+        if (is_cross_process(fFlags)) {
             this->flattenFactoryNames();
         }
         size_t flatSize = flat->flatSize();
         if (this->needOpBytes(flatSize)) {
             this->writeOp(kDef_Flattenable_DrawOp, paintflat, index);
             fWriter.write(flat->data(), flatSize);
         }
     }
     if (replaced) {
         index = ~index;
     }
     return index;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define MIN_BLOCK_SIZE  (16 * 1024)
 #define BITMAPS_TO_KEEP 5
 #define FLATTENABLES_TO_KEEP 10
 
 SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
                              SkWriter32* writer, uint32_t flags,
                              uint32_t width, uint32_t height)
     : SkCanvas(width, height)
-    , fFactorySet(isCrossProcess(flags) ? SkNEW(SkNamedFactorySet) : NULL)
+    , fFactorySet(is_cross_process(flags) ? SkNEW(SkNamedFactorySet) : NULL)
     , fWriter(*writer)
     , fFlags(flags)
-    , fFlattenableHeap(FLATTENABLES_TO_KEEP, fFactorySet, isCrossProcess(flags))
+    , fFlattenableHeap(FLATTENABLES_TO_KEEP, fFactorySet, is_cross_process(flags))
     , fFlatDictionary(&fFlattenableHeap)
 {
     fController = controller;
     fDone = false;
     fBlockSize = 0; // need first block from controller
     fBytesNotified = 0;
     fFirstSaveLayerStackLevel = kNoSaveLayer;
     sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
 
     // Tell the reader the appropriate flags to use.
@@ skipping 478 matching lines @@
             fWriter.writePad(text, byteLength);
 
             fWriter.writePath(path);
             if (matrix) {
                 fWriter.writeMatrix(*matrix);
             }
         }
     }
 }
 
+size_t SkGPipeCanvas::prepareInProcessTypefaceBuffer(const SkRefCntSet& typefaceSet, void* buffer) {
+    // When in-process, we simply write out the typeface pointers.
+    typefaceSet.copyToArray((SkRefCnt**)buffer);
+
+    return typefaceSet.count() * sizeof(SkTypeface*);
+}
+
+size_t SkGPipeCanvas::prepareCrossProcessTypefaceBuffer(const SkRefCntSet& typefaceSet,
+                                                        void* buffer) {
+    // For cross-process we use typeface IDs.
+    typefaceSet.copyToArray((SkRefCnt**)buffer);

[mtklein, 2014/09/15 22:13:14]

Is there any hope for writing typefaceSet.copyIDsToArray(uint32_t*), so we never
have to do the two passes and memory punning?

+
+    uint32_t* ids = reinterpret_cast<uint32_t*>(buffer);
+    SkTypeface** typefaces = reinterpret_cast<SkTypeface**>(buffer);
+    for (int i = 0; i < typefaceSet.count(); ++i) {
+        ids[i] = this->getTypefaceID(typefaces[i]);
+    }
+
+    return typefaceSet.count() * sizeof(uint32_t);
+}
+
 void SkGPipeCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                    const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
 
     // FIXME: this is inefficient but avoids duplicating the blob serialization logic.
+    SkRefCntSet typefaceSet;
     SkWriteBuffer blobBuffer;
+    blobBuffer.setTypefaceRecorder(&typefaceSet);
     blob->flatten(blobBuffer);
 
-    size_t size = sizeof(uint32_t) + 2 * sizeof(SkScalar) + blobBuffer.bytesWritten();
+    // Unlike most draw ops (which only use one paint/typeface), text blobs may reference
+    // an arbitrary number of typefaces. Since the one-paint-per-op model is not applicable,
+    // we need to serialize these explicitly.
+    SkAutoSTMalloc<128, uint8_t> storage(typefaceSet.count() * sizeof(SkTypeface*));
+    size_t typefaceSize = is_cross_process(fFlags)
+        ? this->prepareCrossProcessTypefaceBuffer(typefaceSet, storage.get())
+        : this->prepareInProcessTypefaceBuffer(typefaceSet, storage.get());
+
+    // blob byte count + typeface count + x + y + blob data + an index (cross-process)
+    // or pointer (in-process) for each typeface
+    size_t size = 2 * sizeof(uint32_t)
+                + 2 * sizeof(SkScalar)
+                + blobBuffer.bytesWritten()
+                + typefaceSize;
+
     if (this->needOpBytes(size)) {
         this->writeOp(kDrawTextBlob_DrawOp);
+        SkDEBUGCODE(size_t initialOffset = fWriter.bytesWritten();)
+
         fWriter.writeScalar(x);
         fWriter.writeScalar(y);
+
+        fWriter.write32(typefaceSet.count());
+        fWriter.write(storage.get(), typefaceSize);
+
         fWriter.write32(SkToU32(blobBuffer.bytesWritten()));
         uint32_t* pad = fWriter.reservePad(blobBuffer.bytesWritten());
         blobBuffer.writeToMemory(pad);
+
+        SkASSERT(initialOffset + size == fWriter.bytesWritten());
     }
 }
 
 void SkGPipeCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                                   const SkPaint* paint) {
     // we want to playback the picture into individual draw calls
     //
     // todo: do we always have to unroll? If the pipe is not cross-process, seems like
     // we could just ref the picture and move on...? <reed, scroggo>
     //
@@ skipping 222 matching lines @@
         *ptr++ = castToU32(paint.getTextScaleX());
         base.setTextScaleX(paint.getTextScaleX());
     }
     if (base.getTextSkewX() != paint.getTextSkewX()) {
         *ptr++ = PaintOp_packOp(kTextSkewX_PaintOp);
         *ptr++ = castToU32(paint.getTextSkewX());
         base.setTextSkewX(paint.getTextSkewX());
     }
 
     if (!SkTypeface::Equal(base.getTypeface(), paint.getTypeface())) {
-        if (isCrossProcess(fFlags)) {
+        if (is_cross_process(fFlags)) {
             uint32_t id = this->getTypefaceID(paint.getTypeface());
             *ptr++ = PaintOp_packOpData(kTypeface_PaintOp, id);
         } else if (this->needOpBytes(sizeof(void*))) {
             // Add to the set for ref counting.
             fTypefaceSet.add(paint.getTypeface());
             // It is safe to write the typeface to the stream before the rest
             // of the paint unless we ever send a kReset_PaintOp, which we
             // currently never do.
             this->writeOp(kSetTypeface_DrawOp);
             fWriter.writePtr(paint.getTypeface());
@@ skipping 125 matching lines @@
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }