Try out scalar picture sizes

gm/optimizations.cpp

 /*
  * Copyright 2013 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 "SkDebugCanvas.h"
 #include "SkPictureFlat.h"
 #include "SkPictureRecorder.h"
 
 #define WARN(msg)                                           \
     SkDebugf("%s:%d: %s\n", __FILE__, __LINE__, msg);
 
 // Do the commands in 'input' match the supplied pattern? Note: this is a pretty
 // heavy-weight operation since we are drawing the picture into a debug canvas
 // to extract the commands.
 static bool check_pattern(SkPicture& input, const SkTDArray<DrawType> &pattern) {
-    SkDebugCanvas debugCanvas(input.width(), input.height());
-    debugCanvas.setBounds(input.width(), input.height());
+    SkDebugCanvas debugCanvas(SkScalarCeilToInt(input.cullRect().width()), 
+                              SkScalarCeilToInt(input.cullRect().height()));
     input.draw(&debugCanvas);
 
     if (pattern.count() != debugCanvas.getSize()) {
         return false;
     }
 
     for (int i = 0; i < pattern.count(); ++i) {
         if (pattern[i] != debugCanvas.getDrawCommandAt(i)->getType()) {
             return false;
         }
@@ skipping 301 matching lines @@
             create_save_layer_opt_1_v2,
             create_save_layer_opt_1_v3,
             create_save_layer_opt_1_v4,
             create_save_layer_opt_2_v1,
             create_save_layer_opt_2_v2,
             create_save_layer_opt_2_v3,
             create_save_layer_opt_2_v4,
         };
 
         SkTDArray<DrawType> prePattern, postPattern;
-        int xPos = 0, yPos = 0;
+        SkScalar xPos = 0, yPos = 0;
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(gOpts); ++i) {
             SkAutoTUnref<SkPicture> pre((*gOpts[i])(&prePattern, &postPattern, fCheckerboard));
 
             if (!(check_pattern(*pre, prePattern))) {
                 WARN("Pre optimization pattern mismatch");
                 SkASSERT(0);
             }
 
             canvas->save();
-                canvas->translate(SkIntToScalar(xPos), SkIntToScalar(yPos));
+                canvas->translate(xPos, yPos);
                 pre->draw(canvas);
-                xPos += pre->width();
+                xPos += pre->cullRect().width();
             canvas->restore();
 
             // re-render the 'pre' picture and thus 'apply' the optimization
             SkPictureRecorder recorder;
 
             SkCanvas* recordCanvas =
-                recorder.DEPRECATED_beginRecording(pre->width(), pre->height(), NULL, 0);
+                recorder.DEPRECATED_beginRecording(pre->cullRect().width(), 
+                                                   pre->cullRect().height(), 
+                                                   NULL, 0);
 
             pre->draw(recordCanvas);
 
             SkAutoTUnref<SkPicture> post(recorder.endRecording());
 
             if (!(check_pattern(*post, postPattern))) {
                 WARN("Post optimization pattern mismatch");
                 SkASSERT(0);
             }
 
             canvas->save();
-                canvas->translate(SkIntToScalar(xPos), SkIntToScalar(yPos));
+                canvas->translate(xPos, yPos);
                 post->draw(canvas);
-                xPos += post->width();
+                xPos += post->cullRect().width();
             canvas->restore();
 
             if (xPos >= kWidth) {
                 // start a new line
                 xPos = 0;
-                yPos += post->height();
+                yPos += post->cullRect().height();
             }
 
             // TODO: we could also render the pre and post pictures to bitmaps
             // and manually compare them in this method
         }
     }
 
 private:
     void makeCheckerboard() {
         static const unsigned int kCheckerboardWidth = 16;
@@ skipping 15 matching lines @@
     }
 
     SkBitmap fCheckerboard;
 
     typedef skiagm::GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return new OptimizationsGM; )