Make drawImage a virtual on SkDevice

src/pipe/SkGPipeRead.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 "SkBitmapHeap.h"
@@ skipping 160 matching lines @@
      * Needed to be a non-abstract subclass of SkBitmapHeapReader.
      */
     void releaseRef(int32_t) override {}
 
     void setSharedHeap(SkBitmapHeap* heap) {
         SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
         SkRefCnt_SafeAssign(fSharedHeap, heap);
         this->updateReader();
     }
 
+    void setImageHeap(SkImageHeap* heap) {
+        fImageHeap.reset(SkRef(heap));
+    }
+
     /**
      * Access the shared heap. Only used in the case when bitmaps are not
      * flattened.
      */
     SkBitmapHeap* getSharedHeap() const {
         SkASSERT(!shouldFlattenBitmaps(fFlags));
         return fSharedHeap;
     }
 
     void addTypeface() {
         size_t size = fReader->read32();
         const void* data = fReader->skip(SkAlign4(size));
         SkMemoryStream stream(data, size, false);
         *fTypefaces.append() = SkTypeface::Deserialize(&stream);
     }
 
     SkTypeface* getTypeface(unsigned id) const {
         return id ? fTypefaces[id - 1] : NULL;
     }
 
+    const SkImage* getImage(int32_t slot) const {
+        return fImageHeap->get(slot);
+    }
+
 private:
     void updateReader() {
         if (NULL == fReader) {
             return;
         }
         bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag);
         fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess,
                                          SkReadBuffer::kCrossProcess_Flag));
         if (crossProcess) {
             fReader->setFactoryArray(&fFactoryArray);
         } else {
             fReader->setFactoryArray(NULL);
         }
 
         if (shouldFlattenBitmaps(fFlags)) {
             fReader->setBitmapStorage(this);
         } else {
             fReader->setBitmapStorage(fSharedHeap);
         }
     }
     SkReadBuffer*             fReader;
     SkPaint                   fPaint;
     SkTDArray<SkFlattenable*> fFlatArray;
     SkTDArray<SkTypeface*>    fTypefaces;
     SkTDArray<SkFlattenable::Factory> fFactoryArray;
     SkTDArray<SkBitmap*>      fBitmaps;
     bool                      fSilent;
     // Only used when sharing bitmaps with the writer.
     SkBitmapHeap*             fSharedHeap;
+    SkAutoTUnref<SkImageHeap> fImageHeap;
     unsigned                  fFlags;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 template <typename T> const T* skip(SkReader32* reader, size_t count = 1) {
     size_t size = sizeof(T) * count;
     SkASSERT(SkAlign4(size) == size);
     return reinterpret_cast<const T*>(reader->skip(size));
 }
@@ skipping 382 matching lines @@
                           SkGPipeState* state) {
     BitmapHolder holder(reader, op32, state);
     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
     const SkIPoint* point = skip<SkIPoint>(reader);
     const SkBitmap* bitmap = holder.getBitmap();
     if (state->shouldDraw()) {
         canvas->drawSprite(*bitmap, point->fX, point->fY, hasPaint ? &state->paint() : NULL);
     }
 }
 
+static void drawImage_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32, SkGPipeState* state) {
+    unsigned slot = DrawOp_unpackData(op32);
+    unsigned flags = DrawOp_unpackFlags(op32);
+    bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
+    SkScalar x = reader->readScalar();
+    SkScalar y = reader->readScalar();
+    const SkImage* image = state->getImage(slot);
+    if (state->shouldDraw()) {
+        canvas->drawImage(image, x, y, hasPaint ? &state->paint() : NULL);
+    }
+}
+
+static void drawImageRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
+                             SkGPipeState* state) {
+    unsigned slot = DrawOp_unpackData(op32);
+    unsigned flags = DrawOp_unpackFlags(op32);
+    bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
+    bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag);
+    const SkRect* src = NULL;
+    if (hasSrc) {
+        src = skip<SkRect>(reader);
+    }
+    const SkRect* dst = skip<SkRect>(reader);
+    const SkImage* image = state->getImage(slot);
+    if (state->shouldDraw()) {
+        canvas->drawImageRect(image, src, *dst, hasPaint ? &state->paint() : NULL);
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static void drawPicture_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                            SkGPipeState* state) {
     UNIMPLEMENTED
 }
 
 static void drawTextBlob_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
                             SkGPipeState* state) {
     SkScalar x = reader->readScalar();
@@ skipping 125 matching lines @@
     (void)reader->skip(bytes);
 }
 
 static void reportFlags_rp(SkCanvas*, SkReader32*, uint32_t op32,
                            SkGPipeState* state) {
     unsigned flags = DrawOp_unpackFlags(op32);
     state->setFlags(flags);
 }
 
 static void shareBitmapHeap_rp(SkCanvas*, SkReader32* reader, uint32_t,
-                           SkGPipeState* state) {
+                               SkGPipeState* state) {
     state->setSharedHeap(static_cast<SkBitmapHeap*>(reader->readPtr()));
 }
 
+static void shareImageHeap_rp(SkCanvas*, SkReader32* reader, uint32_t, SkGPipeState* state) {
+    state->setImageHeap(static_cast<SkImageHeap*>(reader->readPtr()));
+}
+
 static void done_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState*) {}
 
 typedef void (*ReadProc)(SkCanvas*, SkReader32*, uint32_t op32, SkGPipeState*);
 
 static const ReadProc gReadTable[] = {
     skip_rp,
     clipPath_rp,
     clipRegion_rp,
     clipRect_rp,
     clipRRect_rp,
     concat_rp,
     drawBitmap_rp,
     drawBitmapNine_rp,
     drawBitmapRect_rp,
     drawDRRect_rp,
+    drawImage_rp,
+    drawImageRect_rp,
     drawOval_rp,
     drawPaint_rp,
     drawPatch_rp,
     drawPath_rp,
     drawPicture_rp,
     drawPoints_rp,
     drawPosText_rp,
     drawPosTextH_rp,
     drawRect_rp,
     drawRRect_rp,
@@ skipping 15 matching lines @@
     typeface_rp,
     annotation_rp,
 
     def_Typeface_rp,
     def_PaintFlat_rp,
     def_Bitmap_rp,
     def_Factory_rp,
 
     reportFlags_rp,
     shareBitmapHeap_rp,
+    shareImageHeap_rp,
     done_rp
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGPipeState::SkGPipeState()
     : fReader(0)
     , fSilent(false)
     , fSharedHeap(NULL)
     , fFlags(0) {
@@ skipping 78 matching lines @@
                 status = kReadAtom_Status;
                 break;
             }
     }
 
     if (bytesRead) {
         *bytesRead = reader.offset();
     }
     return status;
 }