Revert of Override SkCanvas::drawImage() in SkDeferredCanvas and SkGPipe

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"
@@ skipping 232 matching lines @@
     virtual void drawPath(const SkPath& path, const SkPaint&) SK_OVERRIDE;
     virtual void drawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
                             const SkPaint*) SK_OVERRIDE;
     virtual void drawBitmapRectToRect(const SkBitmap&, const SkRect* src,
                                       const SkRect& dst, const SkPaint* paint,
                                       DrawBitmapRectFlags flags) SK_OVERRIDE;
     virtual void drawBitmapMatrix(const SkBitmap&, const SkMatrix&,
                                   const SkPaint*) SK_OVERRIDE;
     virtual void drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                                 const SkRect& dst, const SkPaint* paint = NULL) SK_OVERRIDE;
-    virtual void drawImage(const SkImage* image, SkScalar left, SkScalar top,
-                           const SkPaint* paint) SK_OVERRIDE;
-    virtual void drawImageRect(const SkImage* image, const SkRect* src,
-                               const SkRect& dst,
-                               const SkPaint* paint) SK_OVERRIDE;
     virtual void drawSprite(const SkBitmap&, int left, int top,
                             const SkPaint*) SK_OVERRIDE;
     virtual void drawVertices(VertexMode, int vertexCount,
                           const SkPoint vertices[], const SkPoint texs[],
                           const SkColor colors[], SkXfermode*,
                           const uint16_t indices[], int indexCount,
                               const SkPaint&) SK_OVERRIDE;
     virtual void drawData(const void*, size_t) SK_OVERRIDE;
     virtual void beginCommentGroup(const char* description) SK_OVERRIDE;
     virtual void addComment(const char* kywd, const char* value) SK_OVERRIDE;
@@ skipping 89 matching lines @@
     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& bm, DrawOps op, unsigned flags,
                           size_t opBytesNeeded, const SkPaint* paint);
 
-    bool commonDrawImage(const SkImage* image, DrawOps op, unsigned flags,
-                         size_t opBytesNeeded, const SkPaint* paint);
-
     SkPaint fPaint;
     void writePaint(const SkPaint&);
 
     class AutoPipeNotify {
     public:
         AutoPipeNotify(SkGPipeCanvas* canvas) : fCanvas(canvas) {}
         ~AutoPipeNotify() { fCanvas->doNotify(); }
     private:
         SkGPipeCanvas* fCanvas;
     };
@@ skipping 92 matching lines @@
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap, (fBitmapShuttle.get(), BITMAPS_TO_KEEP));
     } else {
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap,
                                  (BITMAPS_TO_KEEP, controller->numberOfReaders()));
         if (this->needOpBytes(sizeof(void*))) {
             this->writeOp(kShareBitmapHeap_DrawOp);
             fWriter.writePtr(static_cast<void*>(fBitmapHeap));
         }
     }
     fFlattenableHeap.setBitmapStorage(fBitmapHeap);
-
     this->doNotify();
 }
 
 SkGPipeCanvas::~SkGPipeCanvas() {
     this->finish(true);
     SkSafeUnref(fFactorySet);
     SkSafeUnref(fBitmapHeap);
 }
 
 bool SkGPipeCanvas::needOpBytes(size_t needed) {
@@ skipping 308 matching lines @@
         return false;
     }
 
     if (this->needOpBytes(opBytesNeeded)) {
         this->writeOp(op, flags, bitmapIndex);
         return true;
     }
     return false;
 }
 
-bool SkGPipeCanvas::commonDrawImage(const SkImage* image, DrawOps op,
-                                    unsigned flags,
-                                    size_t opBytesNeeded,
-                                    const SkPaint* paint) {
-     if (fDone) {
-        return false;
-    }
-
-    if (paint != NULL) {
-        flags |= kDrawBitmap_HasPaint_DrawOpFlag;
-        this->writePaint(*paint);
-    }
-
-     opBytesNeeded += sizeof (SkImage*);
-
-    if (this->needOpBytes(opBytesNeeded)) {
-        this->writeOp(op, flags, 0);
-
-        image->ref(); // The SkGPipeReader will have to call unref()
-        fWriter.writePtr(static_cast<void*>(const_cast<SkImage*>(image)));
-
-        return true;
-    }
-    return false;
-}
-
-void SkGPipeCanvas::drawImage(const SkImage* image, SkScalar left, SkScalar top,
-                       const SkPaint* paint) {
-    if (is_cross_process(fFlags)){
-        // If the SkGPipe is cross-process, we will have to flatten the data in the SkImage, so
-        // fallback to the default implementation in SkCanvas (which calls SkImage::draw())
-        // https://code.google.com//p/skia/issues/detail?id=2985
-        this->INHERITED::drawImage(image, left, top, paint);
-    } else {
-        NOTIFY_SETUP(this);
-        size_t opBytesNeeded = sizeof(SkScalar) * 2;
-
-        if (this->commonDrawImage(image, kDrawImage_DrawOp, 0, opBytesNeeded, paint)) {
-            fWriter.writeScalar(left);
-            fWriter.writeScalar(top);
-        }
-    }
-}
-
-void SkGPipeCanvas::drawImageRect(const SkImage* image, const SkRect* src,
-                                  const SkRect& dst,
-                                  const SkPaint* paint) {
-    if (is_cross_process(fFlags)){
-        // If the SkGPipe is cross-process, we will have to flatten the data in the SkImage, so
-        // fallback to the default implementation in SkCanvas (which calls SkImage::drawRect())
-        // https://code.google.com//p/skia/issues/detail?id=2985
-       this->INHERITED::drawImageRect(image, src, dst, paint);
-    } else {
-        NOTIFY_SETUP(this);
-        size_t opBytesNeeded = sizeof (SkRect);
-        bool hasSrc = src != NULL;
-        unsigned flags;
-        if (hasSrc) {
-            flags = kDrawImage_HasSrcRect_DrawOpFlag;
-            opBytesNeeded += sizeof (SkRect);
-        } else {
-            flags = 0;
-        }
-
-        if (this->commonDrawImage(image, kDrawImageRect_DrawOp, flags, opBytesNeeded, paint)) {
-            if (hasSrc) {
-                fWriter.writeRect(*src);
-            }
-            fWriter.writeRect(dst);
-        }
-    }
-}
-
 void SkGPipeCanvas::drawBitmap(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);
     }
 }
@@ skipping 271 matching lines @@
             fWriter.write32(indexCount);
             fWriter.writePad(indices, indexCount * sizeof(uint16_t));
         }
     }
 }
 
 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::drawData(const void* ptr, size_t size) {
     if (size && ptr) {
@@ skipping 258 matching lines @@
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }