cleanup previous array of paints

git-svn-id: http://skia.googlecode.com/svn/trunk@1310 2bbb7eff-a529-9590-31e7-b0007b416f81

3 files changed, 42 insertions, 115 deletions

diff --git a/src/pipe/SkGPipePriv.h b/src/pipe/SkGPipePriv.h
index c3b4e4c992..06ba7b6aaa 100644
--- a/src/pipe/SkGPipePriv.h
+++ b/src/pipe/SkGPipePriv.h
@@ -208,8 +208,4 @@ static uint32_t PaintOp_packOpFlagData(PaintOps op, unsigned flags, unsigned dat
     data;
 }
 
-enum {
-    kLastOp_PaintOpFlag = 1 << 0
-};
-
 #endif
diff --git a/src/pipe/SkGPipeRead.cpp b/src/pipe/SkGPipeRead.cpp
index ee20d80890..5e6c632b91 100644
--- a/src/pipe/SkGPipeRead.cpp
+++ b/src/pipe/SkGPipeRead.cpp
@@ -72,13 +72,9 @@ public:
 
     void setReader(SkFlattenableReadBuffer* reader) { fReader = reader; }
 
-    const SkPaint& getPaint(uint32_t drawOp32) const;
+    const SkPaint& paint() const { return fPaint; }
+    SkPaint* editPaint() { return &fPaint; }
     
-    //  Extracts index from DrawOp_unpackData().
-    //  Returns the specified paint from our list, or creates a new paint if
-    //  index == count. If index > count, return NULL
-    SkPaint* editPaint(uint32_t drawOp32);
-
     SkFlattenable* getFlat(unsigned index) const {
         if (0 == index) {
             return NULL;
@@ -103,20 +99,11 @@ public:
     }
     
     SkFlattenableReadBuffer* fReader;
-    SkTDArray<SkFlattenable*> fFlatArray;
 
 private:
-
-    SkTDArray<SkPaint*> fPaints;
-
-    SkRefCntTDArray<SkColorFilter*> fColorFilters;
-    SkRefCntTDArray<SkDrawLooper*> fDrawLoopers;
-    SkRefCntTDArray<SkMaskFilter*> fMaskFilters;
-    SkRefCntTDArray<SkPathEffect*> fPathEffects;
-    SkRefCntTDArray<SkRasterizer*> fRasterizers;
-    SkRefCntTDArray<SkShader*> fShaders;
-    SkRefCntTDArray<SkTypeface*> fTypefaces;
-    SkRefCntTDArray<SkXfermode*> fXfermodes;
+    SkPaint                   fPaint;
+    SkTDArray<SkFlattenable*> fFlatArray;
+    SkTDArray<SkTypeface*>    fTypefaces;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -134,29 +121,6 @@ template <typename T> const T* skipAlign(SkReader32* reader, int count = 1) {
     return reinterpret_cast<const T*>(reader->skip(size));
 }
 
-const SkPaint& SkGPipeState::getPaint(uint32_t op32) const {
-    unsigned index = DrawOp_unpackData(op32);
-    if (index >= fPaints.count()) {
-        SkASSERT(!"paint index out of range");
-        index = 0;  // we always have at least 1 paint
-    }
-    return *fPaints[index];
-}
-
-SkPaint* SkGPipeState::editPaint(uint32_t op32) {
-    unsigned index = DrawOp_unpackData(op32);
-
-    if (index > fPaints.count()) {
-        SkASSERT(!"paint index out of range");
-        return NULL;
-    }
-
-    if (index == fPaints.count()) {
-        *fPaints.append() = SkNEW(SkPaint);
-    }
-    return fPaints[index];
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -236,7 +200,7 @@ static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     }
     const SkPaint* paint = NULL;
     if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
-        paint = &state->getPaint(reader->readU32());
+        paint = &state->paint();
     }
     canvas->saveLayer(bounds, paint, saveFlags);
 }
@@ -259,7 +223,7 @@ static void drawClear_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
 
 static void drawPaint_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                          SkGPipeState* state) {
-    canvas->drawPaint(state->getPaint(op32));
+    canvas->drawPaint(state->paint());
 }
 
 static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -267,19 +231,19 @@ static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     SkCanvas::PointMode mode = (SkCanvas::PointMode)DrawOp_unpackFlags(op32);
     size_t count = reader->readU32();
     const SkPoint* pts = skip<SkPoint>(reader, count);
-    canvas->drawPoints(mode, count, pts, state->getPaint(op32));
+    canvas->drawPoints(mode, count, pts, state->paint());
 }
 
 static void drawRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                         SkGPipeState* state) {
-    canvas->drawRect(*skip<SkRect>(reader), state->getPaint(op32));
+    canvas->drawRect(*skip<SkRect>(reader), state->paint());
 }
 
 static void drawPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                         SkGPipeState* state) {
     SkPath path;
     path.unflatten(*reader);
-    canvas->drawPath(path, state->getPaint(op32));
+    canvas->drawPath(path, state->paint());
 }
 
 static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -311,7 +275,7 @@ static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     }
 
     canvas->drawVertices(mode, vertexCount, verts, texs, colors, xfer,
-                         indices, indexCount, state->getPaint(op32));
+                         indices, indexCount, state->paint());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -321,7 +285,7 @@ static void drawText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     size_t len = reader->readU32();
     const void* text = reader->skip(SkAlign4(len));
     const SkScalar* xy = skip<SkScalar>(reader, 2);
-    canvas->drawText(text, len, xy[0], xy[1], state->getPaint(op32));
+    canvas->drawText(text, len, xy[0], xy[1], state->paint());
 }
 
 static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -330,7 +294,7 @@ static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     const void* text = reader->skip(SkAlign4(len));
     size_t posCount = reader->readU32();    // compute by our writer
     const SkPoint* pos = skip<SkPoint>(reader, posCount);
-    canvas->drawPosText(text, len, pos, state->getPaint(op32));
+    canvas->drawPosText(text, len, pos, state->paint());
 }
 
 static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -340,7 +304,7 @@ static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
     size_t posCount = reader->readU32();    // compute by our writer
     const SkScalar* xpos = skip<SkScalar>(reader, posCount);
     SkScalar constY = reader->readScalar();
-    canvas->drawPosTextH(text, len, xpos, constY, state->getPaint(op32));
+    canvas->drawPosTextH(text, len, xpos, constY, state->paint());
 }
 
 static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
@@ -358,7 +322,7 @@ static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op3
         matrix = &matrixStorage;
     }
 
-    canvas->drawTextOnPath(text, len, path, matrix, state->getPaint(op32));
+    canvas->drawTextOnPath(text, len, path, matrix, state->paint());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -412,14 +376,12 @@ static void paintOp_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
                        SkGPipeState* state) {
     size_t offset = reader->offset();
     size_t stop = offset + PaintOp_unpackData(op32);
-    SkPaint* p = state->editPaint(0);
-    int done;
+    SkPaint* p = state->editPaint();
 
     do {
         uint32_t p32 = reader->readU32();
         unsigned op = PaintOp_unpackOp(p32);
         unsigned data = PaintOp_unpackData(p32);
-        done = PaintOp_unpackFlags(p32) & kLastOp_PaintOpFlag;
 
 //        SkDebugf(" read %08X op=%d flags=%d data=%d\n", p32, op, done, data);
 
@@ -452,8 +414,7 @@ static void paintOp_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
             default: SkASSERT(!"bad paintop"); return;
         }
         SkASSERT(reader->offset() <= stop);
-        done = (reader->offset() >= stop);
-    } while (!done);
+    } while (reader->offset() < stop);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -521,14 +482,11 @@ static const ReadProc gReadTable[] = {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkGPipeState::SkGPipeState() {
-    // start out with one paint in default state
-    *fPaints.append() = SkNEW(SkPaint);
-}
+SkGPipeState::SkGPipeState() {}
 
 SkGPipeState::~SkGPipeState() {
+    fTypefaces.unrefAll();
     fFlatArray.unrefAll();
-    fPaints.deleteAll();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/pipe/SkGPipeWrite.cpp b/src/pipe/SkGPipeWrite.cpp
index 0a56be6d44..aa6ed821b6 100644
--- a/src/pipe/SkGPipeWrite.cpp
+++ b/src/pipe/SkGPipeWrite.cpp
@@ -175,8 +175,8 @@ private:
     int fCurrFlatIndex[kCount_PaintFlats];
     int flattenToIndex(SkFlattenable* obj, PaintFlats);
 
-    SkTDArray<SkPaint*> fPaints;
-    unsigned writePaint(const SkPaint&);
+    SkPaint fPaint;
+    void writePaint(const SkPaint&);
 
     class AutoPipeNotify {
     public:
@@ -242,9 +242,6 @@ SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
     fBlockSize = 0; // need first block from controller
     sk_bzero(fCurrFlatIndex, sizeof(fCurrFlatIndex));
 
-    // always begin with 1 default paint
-    *fPaints.append() = SkNEW(SkPaint);
-
     // we need a device to limit our clip
     // should the caller give us the bounds?
     SkBitmap bitmap;
@@ -256,7 +253,6 @@ SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
 SkGPipeCanvas::~SkGPipeCanvas() {
     this->finish();
 
-    fPaints.deleteAll();
     fFlatArray.freeAll();
 }
 
@@ -311,7 +307,6 @@ int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
                              SaveFlags saveFlags) {
     NOTIFY_SETUP(this);
     size_t size = 0;
-    unsigned index = 0; // just to avoid the warning
     unsigned opFlags = 0;
     
     if (bounds) {
@@ -320,8 +315,7 @@ int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
     }
     if (paint) {
         opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
-        index = this->writePaint(*paint);
-        size += 4;
+        this->writePaint(*paint);
     }
 
     if (this->needOpBytes(size)) {
@@ -329,9 +323,6 @@ int SkGPipeCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint,
         if (bounds) {
             fWriter.writeRect(*bounds);
         }
-        if (paint) {
-            fWriter.write32(index);
-        }
     }
     
     // we just pass on the save, so we don't create a layer
@@ -459,9 +450,9 @@ void SkGPipeCanvas::clear(SkColor color) {
 
 void SkGPipeCanvas::drawPaint(const SkPaint& paint) {
     NOTIFY_SETUP(this);
-    unsigned paintIndex = this->writePaint(paint);
+    this->writePaint(paint);
     if (this->needOpBytes()) {
-        this->writeOp(kDrawPaint_DrawOp, 0, paintIndex);
+        this->writeOp(kDrawPaint_DrawOp);
     }
 }
 
@@ -469,9 +460,9 @@ void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
                                    const SkPoint pts[], const SkPaint& paint) {
     if (count) {
         NOTIFY_SETUP(this);
-        unsigned paintIndex = this->writePaint(paint);
+        this->writePaint(paint);
         if (this->needOpBytes(4 + count * sizeof(SkPoint))) {
-            this->writeOp(kDrawPoints_DrawOp, mode, paintIndex);
+            this->writeOp(kDrawPoints_DrawOp, mode, 0);
             fWriter.write32(count);
             fWriter.write(pts, count * sizeof(SkPoint));
         }
@@ -480,18 +471,18 @@ void SkGPipeCanvas::drawPoints(PointMode mode, size_t count,
 
 void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
     NOTIFY_SETUP(this);
-    unsigned paintIndex = this->writePaint(paint);
+    this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
-        this->writeOp(kDrawRect_DrawOp, 0, paintIndex);
+        this->writeOp(kDrawRect_DrawOp);
         fWriter.writeRect(rect);
     }
 }
 
 void SkGPipeCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
     NOTIFY_SETUP(this);
-    unsigned paintIndex = this->writePaint(paint);
+    this->writePaint(paint);
     if (this->needOpBytes(estimateFlattenSize(path))) {
-        this->writeOp(kDrawPath_DrawOp, 0, paintIndex);
+        this->writeOp(kDrawPath_DrawOp);
         path.flatten(fWriter);
     }
 }
@@ -520,9 +511,9 @@ void SkGPipeCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
                                  SkScalar y, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
-        unsigned paintIndex = this->writePaint(paint);
+        this->writePaint(paint);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
-            this->writeOp(kDrawText_DrawOp, 0, paintIndex);
+            this->writeOp(kDrawText_DrawOp);
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
             fWriter.writeScalar(x);
@@ -535,10 +526,10 @@ void SkGPipeCanvas::drawPosText(const void* text, size_t byteLength,
                                 const SkPoint pos[], const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
-        unsigned paintIndex = this->writePaint(paint);
+        this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkPoint))) {
-            this->writeOp(kDrawPosText_DrawOp, 0, paintIndex);
+            this->writeOp(kDrawPosText_DrawOp);
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
@@ -552,10 +543,10 @@ void SkGPipeCanvas::drawPosTextH(const void* text, size_t byteLength,
                                  const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
-        unsigned paintIndex = this->writePaint(paint);
+        this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
-            this->writeOp(kDrawPosTextH_DrawOp, 0, paintIndex);
+            this->writeOp(kDrawPosTextH_DrawOp);
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
@@ -576,9 +567,9 @@ void SkGPipeCanvas::drawTextOnPath(const void* text, size_t byteLength,
             flags |= kDrawTextOnPath_HasMatrix_DrawOpFlag;
             size += matrix->flatten(NULL);
         }
-        unsigned paintIndex = this->writePaint(paint);
+        this->writePaint(paint);
         if (this->needOpBytes(size)) {
-            this->writeOp(kDrawTextOnPath_DrawOp, flags, paintIndex);
+            this->writeOp(kDrawTextOnPath_DrawOp, flags, 0);
 
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
@@ -611,7 +602,7 @@ void SkGPipeCanvas::drawVertices(VertexMode mode, int vertexCount,
 
     NOTIFY_SETUP(this);
     size_t size = 4 + vertexCount * sizeof(SkPoint);
-    unsigned paintIndex = this->writePaint(paint);
+    this->writePaint(paint);
     unsigned flags = 0;
     if (texs) {
         flags |= kDrawVertices_HasTexs_DrawOpFlag;
@@ -627,7 +618,7 @@ void SkGPipeCanvas::drawVertices(VertexMode mode, int vertexCount,
     }
     
     if (this->needOpBytes(size)) {
-        this->writeOp(kDrawVertices_DrawOp, flags, paintIndex);
+        this->writeOp(kDrawVertices_DrawOp, flags, 0);
         fWriter.write32(mode);
         fWriter.write32(vertexCount);
         fWriter.write(vertices, vertexCount * sizeof(SkPoint));
@@ -675,79 +666,65 @@ template <typename T> uint32_t castToU32(T value) {
     return data.fDst;
 }
 
-unsigned SkGPipeCanvas::writePaint(const SkPaint& paint) {
-    SkPaint& base = *fPaints[0];
+void SkGPipeCanvas::writePaint(const SkPaint& paint) {
+    SkPaint& base = fPaint;
     uint32_t storage[32];
     uint32_t* ptr = storage;
-    uint32_t* last = NULL;
 
     if (base.getFlags() != paint.getFlags()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kFlags_PaintOp, paint.getFlags());
         base.setFlags(paint.getFlags());
     }
     if (base.getColor() != paint.getColor()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kColor_PaintOp);
         *ptr++ = paint.getColor();
         base.setColor(paint.getColor());
     }
     if (base.getStyle() != paint.getStyle()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kStyle_PaintOp, paint.getStyle());
         base.setStyle(paint.getStyle());
     }
     if (base.getStrokeJoin() != paint.getStrokeJoin()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kJoin_PaintOp, paint.getStrokeJoin());
         base.setStrokeJoin(paint.getStrokeJoin());
     }
     if (base.getStrokeCap() != paint.getStrokeCap()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kCap_PaintOp, paint.getStrokeCap());
         base.setStrokeCap(paint.getStrokeCap());
     }
     if (base.getStrokeWidth() != paint.getStrokeWidth()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kWidth_PaintOp);
         *ptr++ = castToU32(paint.getStrokeWidth());
         base.setStrokeWidth(paint.getStrokeWidth());
     }
     if (base.getStrokeMiter() != paint.getStrokeMiter()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kMiter_PaintOp);
         *ptr++ = castToU32(paint.getStrokeMiter());
         base.setStrokeMiter(paint.getStrokeMiter());
     }
     if (base.getTextEncoding() != paint.getTextEncoding()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kEncoding_PaintOp, paint.getTextEncoding());
         base.setTextEncoding(paint.getTextEncoding());
     }
     if (base.getHinting() != paint.getHinting()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kHinting_PaintOp, paint.getHinting());
         base.setHinting(paint.getHinting());
     }
     if (base.getTextAlign() != paint.getTextAlign()) {
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kAlign_PaintOp, paint.getTextAlign());
         base.setTextAlign(paint.getTextAlign());
     }
     if (base.getTextSize() != paint.getTextSize()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kTextSize_PaintOp);
         *ptr++ = castToU32(paint.getTextSize());
         base.setTextSize(paint.getTextSize());
     }
     if (base.getTextScaleX() != paint.getTextScaleX()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kTextScaleX_PaintOp);
         *ptr++ = castToU32(paint.getTextScaleX());
         base.setTextScaleX(paint.getTextScaleX());
     }
     if (base.getTextSkewX() != paint.getTextSkewX()) {
-        last = ptr;
         *ptr++ = PaintOp_packOp(kTextSkewX_PaintOp);
         *ptr++ = castToU32(paint.getTextSkewX());
         base.setTextSkewX(paint.getTextSkewX());
@@ -755,7 +732,6 @@ unsigned SkGPipeCanvas::writePaint(const SkPaint& paint) {
 
     if (!SkTypeface::Equal(base.getTypeface(), paint.getTypeface())) {
         uint32_t id = this->getTypefaceID(paint.getTypeface());
-        last = ptr;
         *ptr++ = PaintOp_packOpData(kTypeface_PaintOp, id);
         base.setTypeface(paint.getTypeface());
     }
@@ -764,7 +740,6 @@ unsigned SkGPipeCanvas::writePaint(const SkPaint& paint) {
         int index = this->flattenToIndex(get_paintflat(paint, i), (PaintFlats)i);
         SkASSERT(index >= 0 && index <= fFlatArray.count());
         if (index != fCurrFlatIndex[i]) {
-            last = ptr;
             *ptr++ = PaintOp_packOpFlagData(kFlatIndex_PaintOp, i, index);
             fCurrFlatIndex[i] = index;
         }
@@ -773,13 +748,11 @@ unsigned SkGPipeCanvas::writePaint(const SkPaint& paint) {
     size_t size = (char*)ptr - (char*)storage;
     if (size && this->needOpBytes(size)) {
         this->writeOp(kPaintOp_DrawOp, 0, size);
-//        *last |= kLastOp_PaintOpFlag << PAINTOPS_DATA_BITS;
         fWriter.write(storage, size);
         for (size_t i = 0; i < size/4; i++) {
 //            SkDebugf("[%d] %08X\n", i, storage[i]);
         }
     }
-    return 0;
 }
 
 ///////////////////////////////////////////////////////////////////////////////