Try out scalar picture sizes

tests/SerializationTest.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 "Resources.h"
 #include "SkBitmapSource.h"
 #include "SkCanvas.h"
@@ skipping 245 matching lines @@
         canvas.clear(0x00000000);
         SkPaint paint;
         paint.setImageFilter(deserializedFilter);
         canvas.clipRect(SkRect::MakeXYWH(0, 0, SkIntToScalar(24), SkIntToScalar(24)));
         canvas.drawBitmap(bitmap, 0, 0, &paint);
     }
 }
 
 static SkBitmap draw_picture(SkPicture& picture) {
      SkBitmap bitmap;
-     bitmap.allocN32Pixels(picture.width(), picture.height());
+     bitmap.allocN32Pixels(SkScalarCeilToInt(picture.cullRect().width()), 
+                           SkScalarCeilToInt(picture.cullRect().height()));
      SkCanvas canvas(bitmap);
      picture.draw(&canvas);
      return bitmap;
 }
 
 static void compare_bitmaps(skiatest::Reporter* reporter,
                             const SkBitmap& b1, const SkBitmap& b2) {
     REPORTER_ASSERT(reporter, b1.width() == b2.width());
     REPORTER_ASSERT(reporter, b1.height() == b2.height());
     SkAutoLockPixels autoLockPixels1(b1);
@@ skipping 31 matching lines @@
 
     // Create a paint with the typeface we loaded.
     SkPaint paint;
     paint.setColor(SK_ColorGRAY);
     paint.setTextSize(SkIntToScalar(30));
     SkSafeUnref(paint.setTypeface(typeface));
 
     // Paint some text.
     SkPictureRecorder recorder;
     SkIRect canvasRect = SkIRect::MakeWH(kBitmapSize, kBitmapSize);
-    SkCanvas* canvas = recorder.beginRecording(canvasRect.width(), canvasRect.height(), NULL, 0);
+    SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(canvasRect.width()), 
+                                               SkIntToScalar(canvasRect.height()), 
+                                               NULL, 0);
     canvas->drawColor(SK_ColorWHITE);
     canvas->drawText("A", 1, 24, 32, paint);
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     // Serlialize picture and create its clone from stream.
     SkDynamicMemoryWStream stream;
     picture->serialize(&stream);
     SkAutoTUnref<SkStream> inputStream(stream.detachAsStream());
     SkAutoTUnref<SkPicture> loadedPicture(SkPicture::CreateFromStream(inputStream.get()));
 
@@ skipping 28 matching lines @@
             canvas.drawRect(SkRect::MakeXYWH(f, 0, f, f), lightPaint);
             canvas.drawRect(SkRect::MakeXYWH(0, f, f, f), lightPaint);
             canvas.drawRect(SkRect::MakeXYWH(f, f, f, f), darkPaint);
             canvas.restore();
         }
     }
 
     return success;
 }
 
-static bool drawSomething(SkCanvas* canvas) {
+static bool draw_something(SkCanvas* canvas) {
     SkPaint paint;
     SkBitmap bitmap;
     bool success = make_checkerboard_bitmap(bitmap);
 
     canvas->save();
     canvas->scale(0.5f, 0.5f);
     canvas->drawBitmap(bitmap, 0, 0, NULL);
     canvas->restore();
 
     const char beforeStr[] = "before circle";
@@ skipping 93 matching lines @@
         invalidBitmap.setInfo(info);
 
         // The deserialization should succeed, and the rendering shouldn't crash,
         // even when the device fails to initialize, due to its size
         TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
     }
 
     // Test simple SkPicture serialization
     {
         SkPictureRecorder recorder;
-        bool didDraw = drawSomething(recorder.beginRecording(kBitmapSize, kBitmapSize, NULL, 0));
+        bool didDraw = draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize), 
+                                                              SkIntToScalar(kBitmapSize), 
+                                                              NULL, 0));
         REPORTER_ASSERT(reporter, didDraw);
         SkAutoTUnref<SkPicture> pict(recorder.endRecording());
 
         // Serialize picture
         SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
         pict->flatten(writer);
         size_t size = writer.bytesWritten();
         SkAutoTMalloc<unsigned char> data(size);
         writer.writeToMemory(static_cast<void*>(data.get()));
 
         // Deserialize picture
         SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
         SkAutoTUnref<SkPicture> readPict(
             SkPicture::CreateFromBuffer(reader));
         REPORTER_ASSERT(reporter, NULL != readPict.get());
     }
 
     TestPictureTypefaceSerialization(reporter);
 }