Try out scalar picture sizes

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 34 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(kPicWidth, kPicHeight);
+    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));
             canvas->drawPath(hex, fill);
@@ skipping 38 matching lines @@
 
 // Just a single picture with no clip
 static void no_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
     canvas->drawPicture(pictures[0]);
 }
 
 // Two pictures with a rect clip on the second one
 static void rect_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
     canvas->drawPicture(pictures[0]);
 
-    SkRect rect = SkRect::MakeWH(SkIntToScalar(kPicWidth), SkIntToScalar(kPicHeight));
+    SkRect rect = pictures[0]->cullRect();
     rect.inset(kInset, kInset);
 
     canvas->clipRect(rect);
 
     canvas->drawPicture(pictures[1]);
 }
 
 // Two pictures with a round rect clip on the second one
 static void rrect_clip(SkCanvas* canvas, const SkPicture* pictures[2]) {
     canvas->drawPicture(pictures[0]);
 
-    SkRect rect = SkRect::MakeWH(SkIntToScalar(kPicWidth), SkIntToScalar(kPicHeight));
+    SkRect rect = pictures[0]->cullRect();
     rect.inset(kInset, kInset);
         
     SkRRect rrect;
     rrect.setRectXY(rect, kInset, kInset);
 
     canvas->clipRRect(rrect);
 
     canvas->drawPicture(pictures[1]);
 }
 
@@ skipping 31 matching lines @@
 };
 
 static void create_content(SkMultiPictureDraw* mpd, PFContentMtd pfGen,
                            const SkPicture* pictures[2],
                            SkCanvas* dest, const SkMatrix& xform) {
     SkAutoTUnref<SkPicture> composite;
 
     {
         SkPictureRecorder recorder;
 
-        SkCanvas* pictureCanvas = recorder.beginRecording(kPicWidth, kPicHeight);
+        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, 
@@ skipping 103 matching lines @@
     protected:
         Content          fContent;
         Layout           fLayout;
         const SkPicture* fPictures[2];
 
         virtual void onOnceBeforeDraw() SK_OVERRIDE {
             fPictures[0] = make_picture(SK_ColorWHITE);
             fPictures[1] = make_picture(SK_ColorGRAY);
         }
 
-        virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE{
+        virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
             SkMultiPictureDraw mpd;
             SkTArray<ComposeStep> composeSteps;
 
             // Fill up the MultiPictureDraw
             (*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);
             }
         }
 
-        virtual SkISize onISize() SK_OVERRIDE{ return SkISize::Make(kPicWidth, kPicHeight); }
+        virtual SkISize onISize() SK_OVERRIDE { return SkISize::Make(kPicWidth, kPicHeight); }
 
-        virtual SkString onShortName() SK_OVERRIDE{
+        virtual SkString onShortName() SK_OVERRIDE {
             static const char* gContentNames[] = { 
                 "noclip", "rectclip", "rrectclip", "pathclip", "invpathclip" 
             };
             static const char* gLayoutNames[] = { "simple", "tiled" };
 
             SkASSERT(SK_ARRAY_COUNT(gLayoutNames) == kLayoutCnt);
             SkASSERT(SK_ARRAY_COUNT(gContentNames) == kContentCnt);
 
             SkString name("multipicturedraw_");
 
@@ skipping 24 matching lines @@
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRectClipMulti_Content,    
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kRRectClipMulti_Content,   
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kPathClipMulti_Content,    
                                                 MultiPictureDraw::kTiled_Layout));)
     DEF_GM(return SkNEW_ARGS(MultiPictureDraw, (MultiPictureDraw::kInvPathClipMulti_Content, 
                                                 MultiPictureDraw::kTiled_Layout));)
 }