remove SkGPipe

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1568883003

Review URL: https://codereview.chromium.org/1568883003

1 files changed, 0 insertions, 1483 deletions

diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
deleted file mode 100644
index 5147cd688d..0000000000
--- a/src/pipe/SkGPipeWrite.cpp
+++ /dev/null
@@ -1,1483 +0,0 @@
-
-/*
- * 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 "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 "SkRSXform.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 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();
-        case kRasterizer_PaintFlat:     return paint.getRasterizer();
-        case kShader_PaintFlat:         return paint.getShader();
-        case kImageFilter_PaintFlat:    return paint.getImageFilter();
-        case kXfermode_PaintFlat:       return paint.getXfermode();
-    }
-    SkDEBUGFAIL("never gets here");
-    return nullptr;
-}
-
-static size_t writeTypeface(SkWriter32* writer, SkTypeface* typeface) {
-    SkASSERT(typeface);
-    SkDynamicMemoryWStream stream;
-    typeface->serialize(&stream);
-    size_t size = stream.getOffset();
-    if (writer) {
-        writer->write32(SkToU32(size));
-        SkAutoDataUnref data(stream.copyToData());
-        writer->writePad(data->data(), size);
-    }
-    return 4 + SkAlign4(size);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class FlattenableHeap : public SkFlatController {
-public:
-    FlattenableHeap(int numFlatsToKeep, SkNamedFactorySet* fset, bool isCrossProcess)
-    : INHERITED(isCrossProcess ? SkWriteBuffer::kCrossProcess_Flag : 0)
-    , fNumFlatsToKeep(numFlatsToKeep) {
-        SkASSERT((isCrossProcess && fset != nullptr) || (!isCrossProcess && nullptr == fset));
-        if (isCrossProcess) {
-            this->setNamedFactorySet(fset);
-        }
-    }
-
-    ~FlattenableHeap() {
-        fPointers.freeAll();
-    }
-
-    void* allocThrow(size_t bytes) override;
-
-    void unalloc(void* ptr) override;
-
-    void setBitmapStorage(SkBitmapHeap* heap) {
-        this->setBitmapHeap(heap);
-    }
-
-    const SkFlatData* flatToReplace() const;
-
-    // Mark an SkFlatData as one that should not be returned by flatToReplace.
-    // Takes the result of SkFlatData::index() as its parameter.
-    void markFlatForKeeping(int index) {
-        *fFlatsThatMustBeKept.append() = index;
-    }
-
-    void markAllFlatsSafeToDelete() {
-        fFlatsThatMustBeKept.reset();
-    }
-
-private:
-    // Keep track of the indices (i.e. the result of SkFlatData::index()) of
-    // flats that must be kept, since they are on the current paint.
-    SkTDArray<int>   fFlatsThatMustBeKept;
-    SkTDArray<void*> fPointers;
-    const int        fNumFlatsToKeep;
-
-    typedef SkFlatController INHERITED;
-};
-
-void FlattenableHeap::unalloc(void* ptr) {
-    int indexToRemove = fPointers.rfind(ptr);
-    if (indexToRemove >= 0) {
-        sk_free(ptr);
-        fPointers.remove(indexToRemove);
-    }
-}
-
-void* FlattenableHeap::allocThrow(size_t bytes) {
-    void* ptr = sk_malloc_throw(bytes);
-    *fPointers.append() = ptr;
-    return ptr;
-}
-
-const SkFlatData* FlattenableHeap::flatToReplace() const {
-    // First, determine whether we should replace one.
-    if (fPointers.count() > fNumFlatsToKeep) {
-        // Look through the flattenable heap.
-        // TODO: Return the LRU flat.
-        for (int i = 0; i < fPointers.count(); i++) {
-            SkFlatData* potential = (SkFlatData*)fPointers[i];
-            // Make sure that it is not one that must be kept.
-            bool mustKeep = false;
-            for (int j = 0; j < fFlatsThatMustBeKept.count(); j++) {
-                if (potential->index() == fFlatsThatMustBeKept[j]) {
-                    mustKeep = true;
-                    break;
-                }
-            }
-            if (!mustKeep) {
-                return potential;
-            }
-        }
-    }
-    return nullptr;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct SkFlattenableTraits {
-    static void Flatten(SkWriteBuffer& buffer, const SkFlattenable& flattenable) {
-        buffer.writeFlattenable(&flattenable);
-    }
-    // No need to define unflatten if we never call it.
-};
-typedef SkFlatDictionary<SkFlattenable, SkFlattenableTraits> FlatDictionary;
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * If SkBitmaps are to be flattened to send to the reader, this class is
- * provided to the SkBitmapHeap to tell the SkGPipeCanvas to do so.
- */
-class BitmapShuttle : public SkBitmapHeap::ExternalStorage {
-public:
-    BitmapShuttle(SkGPipeCanvas*);
-
-    ~BitmapShuttle();
-
-    bool insert(const SkBitmap& bitmap, int32_t slot) override;
-
-    /**
-     *  Remove the SkGPipeCanvas used for insertion. After this, calls to
-     *  insert will crash.
-     */
-    void removeCanvas();
-
-private:
-    SkGPipeCanvas*    fCanvas;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-class SkGPipeCanvas : public SkCanvas {
-public:
-    SkGPipeCanvas(SkGPipeController*, SkWriter32*, uint32_t flags,
-                  uint32_t width, uint32_t height);
-    virtual ~SkGPipeCanvas();
-
-    /**
-     *  Called when nothing else is to be written to the stream. Any repeated
-     *  calls are ignored.
-     *
-     *  @param notifyReaders Whether to send a message to the reader(s) that
-     *      the writer is through sending commands. Should generally be true,
-     *      unless there is an error which prevents further messages from
-     *      being sent.
-     */
-    void finish(bool notifyReaders) {
-        if (fDone) {
-            return;
-        }
-        if (notifyReaders && this->needOpBytes()) {
-            this->writeOp(kDone_DrawOp);
-            this->doNotify();
-        }
-        if (shouldFlattenBitmaps(fFlags)) {
-            // The following circular references exist:
-            // fFlattenableHeap -> fWriteBuffer -> fBitmapStorage -> fExternalStorage -> fCanvas
-            // fBitmapHeap -> fExternalStorage -> fCanvas
-            // fFlattenableHeap -> fBitmapStorage -> fExternalStorage -> fCanvas
-
-            // Break them all by destroying the final link to this SkGPipeCanvas.
-            fBitmapShuttle->removeCanvas();
-        }
-        fDone = true;
-    }
-
-    void flushRecording(bool detachCurrentBlock);
-    size_t freeMemoryIfPossible(size_t bytesToFree);
-
-    size_t storageAllocatedForRecording() {
-        size_t bytesAllocated = 0;
-        if (nullptr != fBitmapHeap) {
-            bytesAllocated += fBitmapHeap->bytesAllocated();
-        }
-        if (nullptr != fImageHeap) {
-            bytesAllocated += fImageHeap->bytesInCache();
-        }
-        return bytesAllocated;
-    }
-
-    /**
-     * Flatten an SkBitmap to send to the reader, where it will be referenced
-     * according to slot.
-     */
-    bool shuttleBitmap(const SkBitmap&, int32_t slot);
-
-    void resetImageHeap();
-
-protected:
-    void willSave() override;
-    SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) override;
-    void willRestore() override;
-
-    void didConcat(const SkMatrix&) override;
-    void didSetMatrix(const SkMatrix&) override;
-
-    void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;
-    void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
-                    const SkPaint&) override;
-    void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
-                       const SkPaint&) override;
-    void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
-                        SkScalar constY, const SkPaint&) override;
-    void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
-                          const SkMatrix* matrix, const SkPaint&) override;
-    void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
-                        const SkPaint& paint) override;
-    void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
-                     const SkPoint texCoords[4], SkXfermode* xmode,
-                     const SkPaint& paint) override;
-    void onDrawPaint(const SkPaint&) override;
-    void onDrawPoints(PointMode, size_t count, const SkPoint pts[], const SkPaint&) override;
-    void onDrawRect(const SkRect&, const SkPaint&) override;
-    void onDrawOval(const SkRect&, const SkPaint&) override;
-    void onDrawRRect(const SkRRect&, const SkPaint&) override;
-    void onDrawPath(const SkPath&, const SkPaint&) override;
-    void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top, const SkPaint*) override;
-    void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst, const SkPaint*,
-                          SrcRectConstraint) override;
-    void onDrawImage(const SkImage*, SkScalar left, SkScalar top, const SkPaint*) override;
-    void onDrawImageRect(const SkImage*, const SkRect* src, const SkRect& dst,
-                         const SkPaint*, SrcRectConstraint) override;
-    void onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
-                         const SkPaint*) override;
-    void onDrawBitmapNine(const SkBitmap&, const SkIRect& center, const SkRect& dst,
-                          const SkPaint*) override;
-    void onDrawVertices(VertexMode vmode, int vertexCount,
-                        const SkPoint vertices[], const SkPoint texs[],
-                        const SkColor colors[], SkXfermode* xmode,
-                        const uint16_t indices[], int indexCount,
-                        const SkPaint&) override;
-    void onDrawAtlas(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[],
-                     int count, SkXfermode::Mode, const SkRect* cull, const SkPaint*) override;
-    void onClipRect(const SkRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRRect(const SkRRect&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipPath(const SkPath&, SkRegion::Op, ClipEdgeStyle) override;
-    void onClipRegion(const SkRegion&, SkRegion::Op) override;
-
-    void onDrawPicture(const SkPicture*, const SkMatrix*, const SkPaint*) override;
-
-private:
-    void recordTranslate(const SkMatrix&);
-    void recordScale(const SkMatrix&);
-    void recordConcat(const SkMatrix&);
-
-    SkNamedFactorySet* fFactorySet;
-    SkBitmapHeap*      fBitmapHeap;
-    SkImageHeap*       fImageHeap;
-    SkGPipeController* fController;
-    SkWriter32&        fWriter;
-    size_t             fBlockSize; // amount allocated for writer
-    size_t             fBytesNotified;
-    bool               fDone;
-    const uint32_t     fFlags;
-
-    SkRefCntSet        fTypefaceSet;
-
-    uint32_t getTypefaceID(SkTypeface*);
-
-    inline void writeOp(DrawOps op, unsigned flags, unsigned data) {
-        fWriter.write32(DrawOp_packOpFlagData(op, flags, data));
-    }
-
-    inline void writeOp(DrawOps op) {
-        fWriter.write32(DrawOp_packOpFlagData(op, 0, 0));
-    }
-
-    bool needOpBytes(size_t size = 0);
-
-    inline void doNotify() {
-        if (!fDone) {
-            size_t bytes = fWriter.bytesWritten() - fBytesNotified;
-            if (bytes > 0) {
-                fController->notifyWritten(bytes);
-                fBytesNotified += bytes;
-            }
-        }
-    }
-
-    typedef SkAutoSTMalloc<128, uint8_t> TypefaceBuffer;
-    size_t getInProcessTypefaces(const SkRefCntSet& typefaceSet, TypefaceBuffer*);
-    size_t getCrossProcessTypefaces(const SkRefCntSet& typefaceSet, TypefaceBuffer*);
-
-    // 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);
-
-    // Common code used by drawBitmap*. Behaves differently depending on the
-    // type of SkBitmapHeap being used, which is determined by the flags used.
-    bool commonDrawBitmap(const SkBitmap&, DrawOps, unsigned flags, size_t bytes, const SkPaint*);
-    bool commonDrawImage(const SkImage*, DrawOps, unsigned flags, size_t bytes, const SkPaint*);
-
-    SkPaint fPaint;
-    void writePaint(const SkPaint&);
-
-    class AutoPipeNotify {
-    public:
-        AutoPipeNotify(SkGPipeCanvas* canvas) : fCanvas(canvas) {}
-        ~AutoPipeNotify() { fCanvas->doNotify(); }
-    private:
-        SkGPipeCanvas* fCanvas;
-    };
-    friend class AutoPipeNotify;
-
-    typedef SkCanvas INHERITED;
-};
-
-void SkGPipeCanvas::flattenFactoryNames() {
-    const char* name;
-    while ((name = fFactorySet->getNextAddedFactoryName()) != nullptr) {
-        size_t len = strlen(name);
-        if (this->needOpBytes(SkWriter32::WriteStringSize(name, len))) {
-            this->writeOp(kDef_Factory_DrawOp);
-            fWriter.writeString(name, len);
-        }
-    }
-}
-
-bool SkGPipeCanvas::shuttleBitmap(const SkBitmap& bm, int32_t slot) {
-    SkASSERT(shouldFlattenBitmaps(fFlags));
-    SkWriteBuffer buffer;
-    buffer.setNamedFactoryRecorder(fFactorySet);
-    buffer.writeBitmap(bm);
-    this->flattenFactoryNames();
-    size_t size = buffer.bytesWritten();
-    if (this->needOpBytes(size)) {
-        this->writeOp(kDef_Bitmap_DrawOp, 0, slot);
-        void* dst = static_cast<void*>(fWriter.reserve(size));
-        buffer.writeToMemory(dst);
-        return true;
-    }
-    return false;
-}
-
-// return 0 for nullptr (or unflattenable obj), or index-base-1
-// return ~(index-base-1) if an old flattenable was replaced
-int SkGPipeCanvas::flattenToIndex(SkFlattenable* obj, PaintFlats paintflat) {
-    SkASSERT(!fDone && fBitmapHeap != nullptr);
-    if (nullptr == obj) {
-        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 (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(is_cross_process(flags) ? new SkNamedFactorySet : nullptr)
-    , fWriter(*writer)
-    , fFlags(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;
-    sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
-
-    // Tell the reader the appropriate flags to use.
-    if (this->needOpBytes()) {
-        this->writeOp(kReportFlags_DrawOp, fFlags, 0);
-    }
-
-    if (shouldFlattenBitmaps(flags)) {
-        fBitmapShuttle.reset(new BitmapShuttle(this));
-        fBitmapHeap = new SkBitmapHeap(fBitmapShuttle.get(), BITMAPS_TO_KEEP);
-    } else {
-        fBitmapHeap = new SkBitmapHeap(BITMAPS_TO_KEEP, controller->numberOfReaders());
-        if (this->needOpBytes(sizeof(void*))) {
-            this->writeOp(kShareBitmapHeap_DrawOp);
-            fWriter.writePtr(static_cast<void*>(fBitmapHeap));
-        }
-    }
-    fFlattenableHeap.setBitmapStorage(fBitmapHeap);
-
-    fImageHeap = new SkImageHeap;
-    if (this->needOpBytes(sizeof(void*))) {
-        this->writeOp(kShareImageHeap_DrawOp);
-        fWriter.writePtr(static_cast<void*>(fImageHeap));
-    }
-
-    this->doNotify();
-}
-
-SkGPipeCanvas::~SkGPipeCanvas() {
-    this->finish(true);
-    SkSafeUnref(fFactorySet);
-    SkSafeUnref(fBitmapHeap);
-    SkSafeUnref(fImageHeap);
-}
-
-bool SkGPipeCanvas::needOpBytes(size_t needed) {
-    if (fDone) {
-        return false;
-    }
-
-    needed += 4;  // size of DrawOp atom
-    needed = SkAlign4(needed);
-    if (fWriter.bytesWritten() + needed > fBlockSize) {
-        // Before we wipe out any data that has already been written, read it out.
-        this->doNotify();
-
-        // If we're going to allocate a new block, allocate enough to make it worthwhile.
-        needed = SkTMax<size_t>(MIN_BLOCK_SIZE, needed);
-
-        void* block = fController->requestBlock(needed, &fBlockSize);
-        if (nullptr == block) {
-            // Do not notify the readers, which would call this function again.
-            this->finish(false);
-            return false;
-        }
-        SkASSERT(SkIsAlign4(fBlockSize));
-        fWriter.reset(block, fBlockSize);
-        fBytesNotified = 0;
-    }
-    return true;
-}
-
-uint32_t SkGPipeCanvas::getTypefaceID(SkTypeface* face) {
-    uint32_t id = 0; // 0 means default/null typeface
-    if (face) {
-        id = fTypefaceSet.find(face);
-        if (0 == id) {
-            id = fTypefaceSet.add(face);
-            size_t size = writeTypeface(nullptr, face);
-            if (this->needOpBytes(size)) {
-                this->writeOp(kDef_Typeface_DrawOp);
-                writeTypeface(&fWriter, face);
-            }
-        }
-    }
-    return id;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#define NOTIFY_SETUP(canvas)    \
-    AutoPipeNotify apn(canvas)
-
-void SkGPipeCanvas::willSave() {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes()) {
-        this->writeOp(kSave_DrawOp);
-    }
-
-    this->INHERITED::willSave();
-}
-
-SkCanvas::SaveLayerStrategy SkGPipeCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) {
-    NOTIFY_SETUP(this);
-    size_t size = 0;
-    unsigned opFlags = 0;
-
-    if (rec.fBounds) {
-        opFlags |= kSaveLayer_HasBounds_DrawOpFlag;
-        size += sizeof(SkRect);
-    }
-    if (rec.fPaint) {
-        opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
-        this->writePaint(*rec.fPaint);
-    }
-
-    if (this->needOpBytes(size)) {
-        this->writeOp(kSaveLayer_DrawOp, opFlags, rec.fSaveLayerFlags);
-        if (rec.fBounds) {
-            fWriter.writeRect(*rec.fBounds);
-        }
-    }
-
-    (void)this->INHERITED::getSaveLayerStrategy(rec);
-    // we don't create a layer
-    return kNoLayer_SaveLayerStrategy;
-}
-
-void SkGPipeCanvas::willRestore() {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes()) {
-        this->writeOp(kRestore_DrawOp);
-    }
-
-    this->INHERITED::willRestore();
-}
-
-void SkGPipeCanvas::recordTranslate(const SkMatrix& m) {
-    if (this->needOpBytes(2 * sizeof(SkScalar))) {
-        this->writeOp(kTranslate_DrawOp);
-        fWriter.writeScalar(m.getTranslateX());
-        fWriter.writeScalar(m.getTranslateY());
-    }
-}
-
-void SkGPipeCanvas::recordScale(const SkMatrix& m) {
-    if (this->needOpBytes(2 * sizeof(SkScalar))) {
-        this->writeOp(kScale_DrawOp);
-        fWriter.writeScalar(m.getScaleX());
-        fWriter.writeScalar(m.getScaleY());
-    }
-}
-
-void SkGPipeCanvas::recordConcat(const SkMatrix& m) {
-    if (this->needOpBytes(m.writeToMemory(nullptr))) {
-        this->writeOp(kConcat_DrawOp);
-        fWriter.writeMatrix(m);
-    }
-}
-
-void SkGPipeCanvas::didConcat(const SkMatrix& matrix) {
-    if (!matrix.isIdentity()) {
-        NOTIFY_SETUP(this);
-        switch (matrix.getType()) {
-            case SkMatrix::kTranslate_Mask:
-                this->recordTranslate(matrix);
-                break;
-            case SkMatrix::kScale_Mask:
-                this->recordScale(matrix);
-                break;
-            default:
-                this->recordConcat(matrix);
-                break;
-        }
-    }
-
-    this->INHERITED::didConcat(matrix);
-}
-
-void SkGPipeCanvas::didSetMatrix(const SkMatrix& matrix) {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes(matrix.writeToMemory(nullptr))) {
-        this->writeOp(kSetMatrix_DrawOp);
-        fWriter.writeMatrix(matrix);
-    }
-    this->INHERITED::didSetMatrix(matrix);
-}
-
-void SkGPipeCanvas::onClipRect(const SkRect& rect, SkRegion::Op rgnOp,
-                               ClipEdgeStyle edgeStyle) {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes(sizeof(SkRect))) {
-        unsigned flags = 0;
-        if (kSoft_ClipEdgeStyle == edgeStyle) {
-            flags = kClip_HasAntiAlias_DrawOpFlag;
-        }
-        this->writeOp(kClipRect_DrawOp, flags, rgnOp);
-        fWriter.writeRect(rect);
-    }
-    this->INHERITED::onClipRect(rect, rgnOp, edgeStyle);
-}
-
-void SkGPipeCanvas::onClipRRect(const SkRRect& rrect, SkRegion::Op rgnOp,
-                                ClipEdgeStyle edgeStyle) {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes(kSizeOfFlatRRect)) {
-        unsigned flags = 0;
-        if (kSoft_ClipEdgeStyle == edgeStyle) {
-            flags = kClip_HasAntiAlias_DrawOpFlag;
-        }
-        this->writeOp(kClipRRect_DrawOp, flags, rgnOp);
-        fWriter.writeRRect(rrect);
-    }
-    this->INHERITED::onClipRRect(rrect, rgnOp, edgeStyle);
-}
-
-void SkGPipeCanvas::onClipPath(const SkPath& path, SkRegion::Op rgnOp,
-                               ClipEdgeStyle edgeStyle) {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes(path.writeToMemory(nullptr))) {
-        unsigned flags = 0;
-        if (kSoft_ClipEdgeStyle == edgeStyle) {
-            flags = kClip_HasAntiAlias_DrawOpFlag;
-        }
-        this->writeOp(kClipPath_DrawOp, flags, rgnOp);
-        fWriter.writePath(path);
-    }
-    // we just pass on the bounds of the path
-    this->INHERITED::onClipRect(path.getBounds(), rgnOp, edgeStyle);
-}
-
-void SkGPipeCanvas::onClipRegion(const SkRegion& region, SkRegion::Op rgnOp) {
-    NOTIFY_SETUP(this);
-    if (this->needOpBytes(region.writeToMemory(nullptr))) {
-        this->writeOp(kClipRegion_DrawOp, 0, rgnOp);
-        fWriter.writeRegion(region);
-    }
-    this->INHERITED::onClipRegion(region, rgnOp);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-void SkGPipeCanvas::onDrawPaint(const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes()) {
-        this->writeOp(kDrawPaint_DrawOp);
-    }
-}
-
-void SkGPipeCanvas::onDrawPoints(PointMode mode, size_t count,
-                                 const SkPoint pts[], const SkPaint& paint) {
-    if (count) {
-        NOTIFY_SETUP(this);
-        this->writePaint(paint);
-        if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
-            this->writeOp(kDrawPoints_DrawOp, mode, 0);
-            fWriter.write32(SkToU32(count));
-            fWriter.write(pts, count * sizeof(SkPoint));
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawOval(const SkRect& rect, const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes(sizeof(SkRect))) {
-        this->writeOp(kDrawOval_DrawOp);
-        fWriter.writeRect(rect);
-    }
-}
-
-void SkGPipeCanvas::onDrawRect(const SkRect& rect, const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes(sizeof(SkRect))) {
-        this->writeOp(kDrawRect_DrawOp);
-        fWriter.writeRect(rect);
-    }
-}
-
-void SkGPipeCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes(kSizeOfFlatRRect)) {
-        this->writeOp(kDrawRRect_DrawOp);
-        fWriter.writeRRect(rrect);
-    }
-}
-
-void SkGPipeCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
-                                 const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes(kSizeOfFlatRRect * 2)) {
-        this->writeOp(kDrawDRRect_DrawOp);
-        fWriter.writeRRect(outer);
-        fWriter.writeRRect(inner);
-    }
-}
-
-void SkGPipeCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-    if (this->needOpBytes(path.writeToMemory(nullptr))) {
-        this->writeOp(kDrawPath_DrawOp);
-        fWriter.writePath(path);
-    }
-}
-
-bool SkGPipeCanvas::commonDrawBitmap(const SkBitmap& bm, DrawOps op,
-                                     unsigned flags,
-                                     size_t opBytesNeeded,
-                                     const SkPaint* paint) {
-    if (fDone) {
-        return false;
-    }
-
-    if (paint != nullptr) {
-        flags |= kDrawBitmap_HasPaint_DrawOpFlag;
-        this->writePaint(*paint);
-    }
-    // This needs to run first so its calls to needOpBytes() and its writes
-    // don't interlace with the needOpBytes() and write below.
-    SkASSERT(fBitmapHeap != nullptr);
-    int32_t bitmapIndex = fBitmapHeap->insert(bm);
-    if (SkBitmapHeap::INVALID_SLOT == bitmapIndex) {
-        return false;
-    }
-
-    if (this->needOpBytes(opBytesNeeded)) {
-        this->writeOp(op, flags, bitmapIndex);
-        return true;
-    }
-    return false;
-}
-
-void SkGPipeCanvas::onDrawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
-                                 const SkPaint* paint) {
-    NOTIFY_SETUP(this);
-    size_t opBytesNeeded = sizeof(SkScalar) * 2;
-
-    if (this->commonDrawBitmap(bm, kDrawBitmap_DrawOp, 0, opBytesNeeded, paint)) {
-        fWriter.writeScalar(left);
-        fWriter.writeScalar(top);
-    }
-}
-
-void SkGPipeCanvas::onDrawBitmapRect(const SkBitmap& bm, const SkRect* src, const SkRect& dst,
-                                     const SkPaint* paint, SrcRectConstraint constraint) {
-    NOTIFY_SETUP(this);
-    size_t opBytesNeeded = sizeof(SkRect);
-    bool hasSrc = src != nullptr;
-    unsigned flags;
-    if (hasSrc) {
-        flags = kDrawBitmap_HasSrcRect_DrawOpFlag;
-        opBytesNeeded += sizeof(int32_t) * 4;
-    } else {
-        flags = 0;
-    }
-    if (kFast_SrcRectConstraint == constraint) {
-        flags |= kDrawBitmap_Bleed_DrawOpFlag;
-    }
-
-    if (this->commonDrawBitmap(bm, kDrawBitmapRect_DrawOp, flags, opBytesNeeded, paint)) {
-        if (hasSrc) {
-            fWriter.writeRect(*src);
-        }
-        fWriter.writeRect(dst);
-    }
-}
-
-void SkGPipeCanvas::onDrawBitmapNine(const SkBitmap& bm, const SkIRect& center,
-                                     const SkRect& dst, const SkPaint* paint) {
-    NOTIFY_SETUP(this);
-    size_t opBytesNeeded = sizeof(int32_t) * 4 + sizeof(SkRect);
-
-    if (this->commonDrawBitmap(bm, kDrawBitmapNine_DrawOp, 0, opBytesNeeded, paint)) {
-        fWriter.write32(center.fLeft);
-        fWriter.write32(center.fTop);
-        fWriter.write32(center.fRight);
-        fWriter.write32(center.fBottom);
-        fWriter.writeRect(dst);
-    }
-}
-
-bool SkGPipeCanvas::commonDrawImage(const SkImage* image, DrawOps op, unsigned flags,
-                                    size_t opBytesNeeded, const SkPaint* paint) {
-    if (fDone) {
-        return false;
-    }
-    
-    if (paint != nullptr) {
-        flags |= kDrawBitmap_HasPaint_DrawOpFlag;
-        this->writePaint(*paint);
-    }
-    // This needs to run first so its calls to needOpBytes() and its writes
-    // don't interlace with the needOpBytes() and write below.
-    int32_t slot = fImageHeap->insert(image);
-    SkASSERT(slot != 0);
-    if (this->needOpBytes(opBytesNeeded)) {
-        this->writeOp(op, flags, slot);
-        return true;
-    }
-    return false;
-}
-
-void SkGPipeCanvas::onDrawImage(const SkImage* image, SkScalar x, SkScalar y,
-                                const SkPaint* paint) {
-    NOTIFY_SETUP(this);
-    if (this->commonDrawImage(image, kDrawImage_DrawOp, 0, sizeof(SkScalar) * 2, paint)) {
-        fWriter.writeScalar(x);
-        fWriter.writeScalar(y);
-    }
-}
-
-void SkGPipeCanvas::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
-                                    const SkPaint* paint, SrcRectConstraint constraint) {
-    NOTIFY_SETUP(this);
-    unsigned flags = 0;
-    size_t opBytesNeeded = sizeof(SkRect);  // dst
-    if (src) {
-        flags |= kDrawBitmap_HasSrcRect_DrawOpFlag;
-        opBytesNeeded += sizeof(SkRect);    // src
-    }
-    if (this->commonDrawImage(image, kDrawImageRect_DrawOp, flags, opBytesNeeded, paint)) {
-        if (src) {
-            fWriter.writeRect(*src);
-        }
-        fWriter.writeRect(dst);
-        fWriter.writeInt(constraint);
-    }
-}
-
-void SkGPipeCanvas::onDrawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
-                                    const SkPaint* paint) {
-    NOTIFY_SETUP(this);
-    size_t opBytesNeeded = sizeof(SkIRect) + sizeof(SkRect);  // center + dst
-    if (this->commonDrawImage(image, kDrawImageNine_DrawOp, 0, opBytesNeeded, paint)) {
-        fWriter.writeIRect(center);
-        fWriter.writeRect(dst);
-    }
-}
-
-void SkGPipeCanvas::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
-                               const SkPaint& paint) {
-    if (byteLength) {
-        NOTIFY_SETUP(this);
-        this->writePaint(paint);
-        if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
-            this->writeOp(kDrawText_DrawOp);
-            fWriter.write32(SkToU32(byteLength));
-            fWriter.writePad(text, byteLength);
-            fWriter.writeScalar(x);
-            fWriter.writeScalar(y);
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
-                                  const SkPaint& paint) {
-    if (byteLength) {
-        NOTIFY_SETUP(this);
-        this->writePaint(paint);
-        int count = paint.textToGlyphs(text, byteLength, nullptr);
-        if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
-            this->writeOp(kDrawPosText_DrawOp);
-            fWriter.write32(SkToU32(byteLength));
-            fWriter.writePad(text, byteLength);
-            fWriter.write32(count);
-            fWriter.write(pos, count * sizeof(SkPoint));
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
-                                   SkScalar constY, const SkPaint& paint) {
-    if (byteLength) {
-        NOTIFY_SETUP(this);
-        this->writePaint(paint);
-        int count = paint.textToGlyphs(text, byteLength, nullptr);
-        if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
-            this->writeOp(kDrawPosTextH_DrawOp);
-            fWriter.write32(SkToU32(byteLength));
-            fWriter.writePad(text, byteLength);
-            fWriter.write32(count);
-            fWriter.write(xpos, count * sizeof(SkScalar));
-            fWriter.writeScalar(constY);
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
-                                     const SkMatrix* matrix, const SkPaint& paint) {
-    if (byteLength) {
-        NOTIFY_SETUP(this);
-        unsigned flags = 0;
-        size_t size = 4 + SkAlign4(byteLength) + path.writeToMemory(nullptr);
-        if (matrix) {
-            flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
-            size += matrix->writeToMemory(nullptr);
-        }
-        this->writePaint(paint);
-        if (this->needOpBytes(size)) {
-            this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
-
-            fWriter.write32(SkToU32(byteLength));
-            fWriter.writePad(text, byteLength);
-
-            fWriter.writePath(path);
-            if (matrix) {
-                fWriter.writeMatrix(*matrix);
-            }
-        }
-    }
-}
-
-size_t SkGPipeCanvas::getInProcessTypefaces(const SkRefCntSet& typefaceSet,
-                                            TypefaceBuffer* buffer) {
-    // When in-process, we simply write out the typeface pointers.
-    size_t size = typefaceSet.count() * sizeof(SkTypeface*);
-    buffer->reset(size);
-    typefaceSet.copyToArray(reinterpret_cast<SkRefCnt**>(buffer->get()));
-
-    return size;
-}
-
-size_t SkGPipeCanvas::getCrossProcessTypefaces(const SkRefCntSet& typefaceSet,
-                                               TypefaceBuffer* buffer) {
-    // For cross-process we use typeface IDs.
-    size_t size = typefaceSet.count() * sizeof(uint32_t);
-    buffer->reset(size);
-
-    uint32_t* idBuffer = reinterpret_cast<uint32_t*>(buffer->get());
-    SkRefCntSet::Iter iter(typefaceSet);
-    int i = 0;
-
-    for (void* setPtr = iter.next(); setPtr; setPtr = iter.next()) {
-        idBuffer[i++] = this->getTypefaceID(reinterpret_cast<SkTypeface*>(setPtr));
-    }
-
-    SkASSERT(i == typefaceSet.count());
-
-    return size;
-}
-
-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);
-
-    // 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.
-    TypefaceBuffer typefaceBuffer;
-    size_t typefaceSize = is_cross_process(fFlags)
-        ? this->getCrossProcessTypefaces(typefaceSet, &typefaceBuffer)
-        : this->getInProcessTypefaces(typefaceSet, &typefaceBuffer);
-
-    // 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(typefaceBuffer.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>
-    //
-    this->INHERITED::onDrawPicture(picture, matrix, paint);
-}
-
-void SkGPipeCanvas::onDrawVertices(VertexMode vmode, int vertexCount,
-                                   const SkPoint vertices[], const SkPoint texs[],
-                                   const SkColor colors[], SkXfermode* xfer,
-                                   const uint16_t indices[], int indexCount,
-                                   const SkPaint& paint) {
-    if (0 == vertexCount) {
-        return;
-    }
-
-    NOTIFY_SETUP(this);
-    this->writePaint(paint);
-
-    unsigned flags = 0;  // packs with the op, so needs no extra space
-
-    size_t size = 0;
-    size += 4;                              // vmode
-    size += 4;                              // vertex count
-    size += vertexCount * sizeof(SkPoint);  // vertices
-
-    if (texs) {
-        flags |= kDrawVertices_HasTexs_DrawOpFlag;
-        size += vertexCount * sizeof(SkPoint);
-    }
-    if (colors) {
-        flags |= kDrawVertices_HasColors_DrawOpFlag;
-        size += vertexCount * sizeof(SkColor);
-    }
-    if (xfer && !SkXfermode::IsMode(xfer, SkXfermode::kModulate_Mode)) {
-        flags |= kDrawVertices_HasXfermode_DrawOpFlag;
-        size += sizeof(int32_t);    // SkXfermode::Mode
-    }
-    if (indices && indexCount > 0) {
-        flags |= kDrawVertices_HasIndices_DrawOpFlag;
-        size += 4;                                        // index count
-        size += SkAlign4(indexCount * sizeof(uint16_t));  // indices
-    }
-
-    if (this->needOpBytes(size)) {
-        this->writeOp(kDrawVertices_DrawOp, flags, 0);
-        fWriter.write32(vmode);
-        fWriter.write32(vertexCount);
-        fWriter.write(vertices, vertexCount * sizeof(SkPoint));
-        if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
-            fWriter.write(texs, vertexCount * sizeof(SkPoint));
-        }
-        if (flags & kDrawVertices_HasColors_DrawOpFlag) {
-            fWriter.write(colors, vertexCount * sizeof(SkColor));
-        }
-        if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
-            SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
-            SkAssertResult(xfer->asMode(&mode));
-            fWriter.write32(mode);
-        }
-        if (flags & kDrawVertices_HasIndices_DrawOpFlag) {
-            fWriter.write32(indexCount);
-            fWriter.writePad(indices, indexCount * sizeof(uint16_t));
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
-                                const SkColor colors[], int count, SkXfermode::Mode mode,
-                                const SkRect* cull, const SkPaint* paint) {
-    NOTIFY_SETUP(this);
-    unsigned flags = 0;  // packs with the op, so needs no extra space
-
-    if (paint) {
-        flags |= kDrawAtlas_HasPaint_DrawOpFlag;
-        this->writePaint(*paint);
-    }
-
-    size_t size = 4;                        // image-slot
-    size += 4;                              // count
-    size += 4;                              // mode
-    size += count * sizeof(SkRSXform);      // xform
-    size += count * sizeof(SkRect);         // tex
-    if (colors) {
-        flags |= kDrawAtlas_HasColors_DrawOpFlag;
-        size += count * sizeof(SkColor);    // colors
-    }
-    if (cull) {
-        flags |= kDrawAtlas_HasCull_DrawOpFlag;
-        size += sizeof(SkRect);             // cull
-    }
-    
-    if (this->needOpBytes(size)) {
-        this->writeOp(kDrawAtlas_DrawOp, flags, 0);
-        int32_t slot = fImageHeap->insert(atlas);
-        fWriter.write32(slot);
-        fWriter.write32(count);
-        fWriter.write32(mode);
-        fWriter.write(xform, count * sizeof(SkRSXform));
-        fWriter.write(tex, count * sizeof(SkRect));
-        if (colors) {
-            fWriter.write(colors, count * sizeof(SkColor));
-        }
-        if (cull) {
-            fWriter.writeRect(*cull);
-        }
-    }
-}
-
-void SkGPipeCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
-                                const SkPoint texCoords[4], SkXfermode* xmode,
-                                const SkPaint& paint) {
-    NOTIFY_SETUP(this);
-    
-    size_t size = SkPatchUtils::kNumCtrlPts * sizeof(SkPoint);
-    unsigned flags = 0;
-    if (colors) {
-        flags |= kDrawVertices_HasColors_DrawOpFlag;
-        size += SkPatchUtils::kNumCorners * sizeof(SkColor);
-    }
-    if (texCoords) {
-        flags |= kDrawVertices_HasTexs_DrawOpFlag;
-        size += SkPatchUtils::kNumCorners * sizeof(SkPoint);
-    }
-    if (xmode) {
-        SkXfermode::Mode mode;
-        if (xmode->asMode(&mode) && SkXfermode::kModulate_Mode != mode) {
-            flags |= kDrawVertices_HasXfermode_DrawOpFlag;
-            size += sizeof(int32_t);
-        }
-    }
-    
-    this->writePaint(paint);
-    if (this->needOpBytes(size)) {
-        this->writeOp(kDrawPatch_DrawOp, flags, 0);
-        
-        fWriter.write(cubics, SkPatchUtils::kNumCtrlPts * sizeof(SkPoint));
-        
-        if (colors) {
-            fWriter.write(colors, SkPatchUtils::kNumCorners * sizeof(SkColor));
-        }
-        
-        if (texCoords) {
-            fWriter.write(texCoords, SkPatchUtils::kNumCorners * sizeof(SkPoint));
-        }
-        
-        if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
-            SkXfermode::Mode mode = SkXfermode::kModulate_Mode;
-            SkAssertResult(xmode->asMode(&mode));
-            fWriter.write32(mode);
-        }
-    }
-}
-
-void SkGPipeCanvas::flushRecording(bool detachCurrentBlock) {
-    this->doNotify();
-    if (detachCurrentBlock) {
-        // force a new block to be requested for the next recorded command
-        fBlockSize = 0;
-    }
-}
-
-void SkGPipeCanvas::resetImageHeap() {
-    if (fImageHeap) {
-        fImageHeap->reset();
-    }
-}
-
-size_t SkGPipeCanvas::freeMemoryIfPossible(size_t bytesToFree) {
-    return (nullptr == fBitmapHeap) ? 0 : fBitmapHeap->freeMemoryIfPossible(bytesToFree);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-template <typename T> uint32_t castToU32(T value) {
-    union {
-        T           fSrc;
-        uint32_t    fDst;
-    } data;
-    data.fSrc = value;
-    return data.fDst;
-}
-
-void SkGPipeCanvas::writePaint(const SkPaint& paint) {
-    if (fDone) {
-        return;
-    }
-    SkPaint& base = fPaint;
-    uint32_t storage[32];
-    uint32_t* ptr = storage;
-
-    if (base.getFlags() != paint.getFlags()) {
-        *ptr++ = PaintOp_packOpData(kFlags_PaintOp, paint.getFlags());
-        base.setFlags(paint.getFlags());
-    }
-    if (base.getColor() != paint.getColor()) {
-        *ptr++ = PaintOp_packOp(kColor_PaintOp);
-        *ptr++ = paint.getColor();
-        base.setColor(paint.getColor());
-    }
-    if (base.getFilterQuality() != paint.getFilterQuality()) {
-        *ptr++ = PaintOp_packOpData(kFilterLevel_PaintOp, paint.getFilterQuality());
-        base.setFilterQuality(paint.getFilterQuality());
-    }
-    if (base.getStyle() != paint.getStyle()) {
-        *ptr++ = PaintOp_packOpData(kStyle_PaintOp, paint.getStyle());
-        base.setStyle(paint.getStyle());
-    }
-    if (base.getStrokeJoin() != paint.getStrokeJoin()) {
-        *ptr++ = PaintOp_packOpData(kJoin_PaintOp, paint.getStrokeJoin());
-        base.setStrokeJoin(paint.getStrokeJoin());
-    }
-    if (base.getStrokeCap() != paint.getStrokeCap()) {
-        *ptr++ = PaintOp_packOpData(kCap_PaintOp, paint.getStrokeCap());
-        base.setStrokeCap(paint.getStrokeCap());
-    }
-    if (base.getStrokeWidth() != paint.getStrokeWidth()) {
-        *ptr++ = PaintOp_packOp(kWidth_PaintOp);
-        *ptr++ = castToU32(paint.getStrokeWidth());
-        base.setStrokeWidth(paint.getStrokeWidth());
-    }
-    if (base.getStrokeMiter() != paint.getStrokeMiter()) {
-        *ptr++ = PaintOp_packOp(kMiter_PaintOp);
-        *ptr++ = castToU32(paint.getStrokeMiter());
-        base.setStrokeMiter(paint.getStrokeMiter());
-    }
-    if (base.getTextEncoding() != paint.getTextEncoding()) {
-        *ptr++ = PaintOp_packOpData(kEncoding_PaintOp, paint.getTextEncoding());
-        base.setTextEncoding(paint.getTextEncoding());
-    }
-    if (base.getHinting() != paint.getHinting()) {
-        *ptr++ = PaintOp_packOpData(kHinting_PaintOp, paint.getHinting());
-        base.setHinting(paint.getHinting());
-    }
-    if (base.getTextAlign() != paint.getTextAlign()) {
-        *ptr++ = PaintOp_packOpData(kAlign_PaintOp, paint.getTextAlign());
-        base.setTextAlign(paint.getTextAlign());
-    }
-    if (base.getTextSize() != paint.getTextSize()) {
-        *ptr++ = PaintOp_packOp(kTextSize_PaintOp);
-        *ptr++ = castToU32(paint.getTextSize());
-        base.setTextSize(paint.getTextSize());
-    }
-    if (base.getTextScaleX() != paint.getTextScaleX()) {
-        *ptr++ = PaintOp_packOp(kTextScaleX_PaintOp);
-        *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 (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());
-        }
-        base.setTypeface(paint.getTypeface());
-    }
-
-    // This is a new paint, so all old flats can be safely purged, if necessary.
-    fFlattenableHeap.markAllFlatsSafeToDelete();
-    for (int i = 0; i < kCount_PaintFlats; i++) {
-        int index = this->flattenToIndex(get_paintflat(paint, i), (PaintFlats)i);
-        bool replaced = index < 0;
-        if (replaced) {
-            index = ~index;
-        }
-        // Store the index of any flat that needs to be kept. 0 means no flat.
-        if (index > 0) {
-            fFlattenableHeap.markFlatForKeeping(index);
-        }
-        SkASSERT(index >= 0 && index <= fFlatDictionary.count());
-        if (index != fCurrFlatIndex[i] || replaced) {
-            *ptr++ = PaintOp_packOpFlagData(kFlatIndex_PaintOp, i, index);
-            fCurrFlatIndex[i] = index;
-        }
-    }
-
-    size_t size = (char*)ptr - (char*)storage;
-    if (size && this->needOpBytes(size)) {
-        this->writeOp(kPaintOp_DrawOp, 0, SkToU32(size));
-        fWriter.write(storage, size);
-        for (size_t i = 0; i < size/4; i++) {
-//            SkDebugf("[%d] %08X\n", i, storage[i]);
-        }
-    }
-
-    //
-    //  Do these after we've written kPaintOp_DrawOp
-
-    if (base.getAnnotation() != paint.getAnnotation()) {
-        if (nullptr == paint.getAnnotation()) {
-            if (this->needOpBytes()) {
-                this->writeOp(kSetAnnotation_DrawOp, 0, 0);
-            }
-        } else {
-            SkWriteBuffer buffer;
-            paint.getAnnotation()->writeToBuffer(buffer);
-            const size_t size = buffer.bytesWritten();
-            if (this->needOpBytes(size)) {
-                this->writeOp(kSetAnnotation_DrawOp, 0, SkToU32(size));
-                buffer.writeToMemory(fWriter.reserve(size));
-            }
-        }
-        base.setAnnotation(paint.getAnnotation());
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkGPipe.h"
-
-SkGPipeController::~SkGPipeController() {
-    SkSafeUnref(fCanvas);
-}
-
-void SkGPipeController::setCanvas(SkGPipeCanvas* canvas) {
-    SkRefCnt_SafeAssign(fCanvas, canvas);
-}
-
-void SkGPipeController::purgeCaches()
-{
-    fCanvas->resetImageHeap();
-    // Other caches are self-purging with a small MRU pool
-    // We could purge them as well, but it is not clear whether
-    // that would be a win.
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-SkGPipeWriter::SkGPipeWriter()
-: fWriter(0) {
-    fCanvas = nullptr;
-}
-
-SkGPipeWriter::~SkGPipeWriter() {
-    this->endRecording();
-}
-
-SkCanvas* SkGPipeWriter::startRecording(SkGPipeController* controller, uint32_t flags,
-                                        uint32_t width, uint32_t height) {
-    if (nullptr == fCanvas) {
-        fWriter.reset(nullptr, 0);
-        fCanvas = new SkGPipeCanvas(controller, &fWriter, flags, width, height);
-    }
-    controller->setCanvas(fCanvas);
-    return fCanvas;
-}
-
-void SkGPipeWriter::endRecording() {
-    if (fCanvas) {
-        fCanvas->finish(true);
-        fCanvas->unref();
-        fCanvas = nullptr;
-    }
-}
-
-void SkGPipeWriter::flushRecording(bool detachCurrentBlock) {
-    if (fCanvas) {
-        fCanvas->flushRecording(detachCurrentBlock);
-    }
-}
-
-size_t SkGPipeWriter::freeMemoryIfPossible(size_t bytesToFree) {
-    if (fCanvas) {
-        return fCanvas->freeMemoryIfPossible(bytesToFree);
-    }
-    return 0;
-}
-
-size_t SkGPipeWriter::storageAllocatedForRecording() const {
-    return nullptr == fCanvas ? 0 : fCanvas->storageAllocatedForRecording();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-BitmapShuttle::BitmapShuttle(SkGPipeCanvas* canvas) {
-    SkASSERT(canvas != nullptr);
-    fCanvas = canvas;
-    fCanvas->ref();
-}
-
-BitmapShuttle::~BitmapShuttle() {
-    this->removeCanvas();
-}
-
-bool BitmapShuttle::insert(const SkBitmap& bitmap, int32_t slot) {
-    SkASSERT(fCanvas != nullptr);
-    return fCanvas->shuttleBitmap(bitmap, slot);
-}
-
-void BitmapShuttle::removeCanvas() {
-    if (nullptr == fCanvas) {
-        return;
-    }
-    fCanvas->unref();
-    fCanvas = nullptr;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
-SkImageHeap::SkImageHeap() : fBytesInCache (0) {}
-
-SkImageHeap::~SkImageHeap() {
-    fArray.unrefAll();
-}
-
-void SkImageHeap::reset() {
-    fArray.unrefAll();
-    fArray.rewind();
-    fBytesInCache = 0;
-}
-
-const SkImage* SkImageHeap::get(int32_t slot) const {
-    SkASSERT(slot > 0);
-    return fArray[slot - 1];
-}
-
-int32_t SkImageHeap::find(const SkImage* img) const {
-    int index = fArray.find(img);
-    if (index >= 0) {
-        return index + 1;   // found
-    }
-    return 0;   // not found
-}
-
-int32_t SkImageHeap::insert(const SkImage* img) {
-    int32_t slot = this->find(img);
-    if (slot) {
-        return slot;
-    }
-    // TODO: SkImage does not expose bytes per pixel, 4 is just a best guess.
-    fBytesInCache += img->width() * img->height() * 4;
-    *fArray.append() = SkRef(img);
-    return fArray.count();  // slot is always index+1
-}
-