SkCanvas::drawImage is the new way for drawing an SkImage to a Canvas

gm/multipicturedraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 
 #include "SkColorFilter.h"
@@ skipping 38 matching lines @@
     SkPaint fill;
     fill.setStyle(SkPaint::kFill_Style);
     fill.setColor(fillColor);
 
     SkPaint stroke;
     stroke.setStyle(SkPaint::kStroke_Style);
     stroke.setStrokeWidth(3);
 
     SkPictureRecorder recorder;
 
-    SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth), 
+    SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight));
 
     SkScalar xPos, yPos = 0;
 
     for (int y = 0; y < kNumHexY; ++y) {
         xPos = 0;
 
         for (int x = 0; x < kNumHexX; ++x) {
             canvas->saveLayer(NULL, NULL);
             canvas->translate(xPos, yPos + ((x % 2) ? kRoot3Over2 * kHexSide : 0));
@@ skipping 61 matching lines @@
 
     canvas->save();
     canvas->translate(-SkScalarHalf(kTriSide), 1.5f * kTriSide / kRoot3);
     canvas->drawPicture(tri);
     canvas->restore();
 
     return recorder.endRecording();
 }
 
 // Create a Sierpinkski-like picture that starts with a top row with a picture
-// that just contains a triangle. Subsequent rows take the prior row's picture, 
+// that just contains a triangle. Subsequent rows take the prior row's picture,
 // shrinks it and replicates it 3 times then draws and appropriate number of
 // copies of it.
 static const SkPicture* make_sierpinski_picture() {
     SkAutoTUnref<const SkPicture> pic(make_tri_picture());
 
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                SkIntToScalar(kPicHeight));
 
@@ skipping 58 matching lines @@
 
     canvas->drawPicture(pictures[1]);
 }
 
 // Two pictures with a round rect clip on the second one
 static void rrect_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
     canvas->drawPicture(pictures[0]);
 
     SkRect rect = pictures[0]->cullRect();
     rect.inset(kInset, kInset);
-        
+
     SkRRect rrect;
     rrect.setRectXY(rect, kInset, kInset);
 
     canvas->clipRRect(rrect);
 
     canvas->drawPicture(pictures[1]);
 }
 
 // Two pictures with a clip path on the second one
 static void path_clip(SkCanvas* canvas, const SkPicture* pictures[kNumPictures]) {
@@ skipping 42 matching lines @@
 };
 
 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
                            const SkPicture* pictures[kNumPictures],
                            SkCanvas* dest, const SkMatrix& xform) {
     SkAutoTUnref<SkPicture> composite;
 
     {
         SkPictureRecorder recorder;
 
-        SkCanvas* pictureCanvas = recorder.beginRecording(SkIntToScalar(kPicWidth), 
+        SkCanvas* pictureCanvas = recorder.beginRecording(SkIntToScalar(kPicWidth),
                                                           SkIntToScalar(kPicHeight));
 
         (*pfGen)(pictureCanvas, pictures);
 
         composite.reset(recorder.endRecording());
     }
 
     mpd->add(dest, composite, &xform);
 }
 
-typedef void(*PFLayoutMtd)(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd, 
+typedef void(*PFLayoutMtd)(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
                            PFContentMtd pfGen, const SkPicture* pictures[kNumPictures],
                            SkTArray<ComposeStep>* composeSteps);
 
 // Draw the content into a single canvas
-static void simple(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd, 
-                   PFContentMtd pfGen, 
+static void simple(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
+                   PFContentMtd pfGen,
                    const SkPicture* pictures[kNumPictures],
                    SkTArray<ComposeStep> *composeSteps) {
 
     ComposeStep& step = composeSteps->push_back();
 
     step.fSurf = create_compat_surface(finalCanvas, kPicWidth, kPicHeight);
 
     SkCanvas* subCanvas = step.fSurf->getCanvas();
 
     create_content(mpd, pfGen, pictures, subCanvas, SkMatrix::I());
 }
 
 // Draw the content into multiple canvases/tiles
 static void tiled(SkCanvas* finalCanvas, SkMultiPictureDraw* mpd,
-                  PFContentMtd pfGen, 
+                  PFContentMtd pfGen,
                   const SkPicture* pictures[kNumPictures],
                   SkTArray<ComposeStep> *composeSteps) {
     static const int kNumTilesX = 2;
     static const int kNumTilesY = 2;
     static const int kTileWidth = kPicWidth / kNumTilesX;
     static const int kTileHeight = kPicHeight / kNumTilesY;
 
     SkASSERT(kPicWidth == kNumTilesX * kTileWidth);
     SkASSERT(kPicHeight == kNumTilesY * kTileHeight);
 
     static const SkColor colors[kNumTilesX][kNumTilesY] = {
-        { SK_ColorCYAN,   SK_ColorMAGENTA }, 
+        { SK_ColorCYAN,   SK_ColorMAGENTA },
         { SK_ColorYELLOW, SK_ColorGREEN   }
     };
 
     for (int y = 0; y < kNumTilesY; ++y) {
         for (int x = 0; x < kNumTilesX; ++x) {
             ComposeStep& step = composeSteps->push_back();
 
             step.fX = SkIntToScalar(x*kTileWidth);
             step.fY = SkIntToScalar(y*kTileHeight);
             step.fPaint = SkNEW(SkPaint);
@@ skipping 70 matching lines @@
             fPictures[0] = make_hex_plane_picture(SK_ColorWHITE);
             fPictures[1] = make_hex_plane_picture(SK_ColorGRAY);
             fPictures[2] = make_sierpinski_picture();
         }
 
         virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
             SkMultiPictureDraw mpd;
             SkTArray<ComposeStep> composeSteps;
 
             // Fill up the MultiPictureDraw
-            (*gLayoutMthds[fLayout])(canvas, &mpd, 
-                                     gContentMthds[fContent], 
+            (*gLayoutMthds[fLayout])(canvas, &mpd,
+                                     gContentMthds[fContent],
                                      fPictures, &composeSteps);
 
             mpd.draw();
 
             // Compose all the drawn canvases into the final canvas
             for (int i = 0; i < composeSteps.count(); ++i) {
                 const ComposeStep& step = composeSteps[i];
 
                 SkAutoTUnref<SkImage> image(step.fSurf->newImageSnapshot());
 
-                image->draw(canvas, step.fX, step.fY, step.fPaint);
+                canvas->drawImage(image, step.fX, step.fY, step.fPaint);
             }
         }
 
         virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(kPicWidth, kPicHeight); }
 
         virtual SkString onShortName() SK_OVERRIDE {
-            static const char* gContentNames[] = { 
+            static const char* gContentNames[] = {
                 "noclip", "rectclip", "rrectclip", "pathclip", "invpathclip", "sierpinski"
             };
             static const char* gLayoutNames[] = { "simple", "tiled" };
 
             SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
             SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
 
             SkString name("multipicturedraw_");
 
             name.append(gContentNames[fContent]);
             name.append("_");
             name.append(gLayoutNames[fLayout]);
             return name;
         }
 
         virtual uint32_t onGetFlags() const SK_OVERRIDE { return kAsBench_Flag | kSkipTiled_Flag; }
 
     private:
         typedef GM INHERITED;
     };
 
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,     
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,    
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,   
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,    
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content, 
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kSierpinski_Content,
                                                 MultiPictureDraw::kSimple_Layout));)
 
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,     
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kNoClipSingle_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,    
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,   
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,    
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
-    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content, 
+    DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kSierpinski_Content,
                                                 MultiPictureDraw::kTiled_Layout));)
 }