convert gm tool to use surfaces instead of devices

gm/gmmain.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.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 20 matching lines @@
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkJSONCPP.h"
 #include "SkOSFile.h"
 #include "SkPDFRasterizer.h"
 #include "SkPicture.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkString.h"
+#include "SkSurface.h"
 #include "SkTArray.h"
 #include "SkTDict.h"
 #include "SkTileGridPicture.h"
 #include "SamplePipeControllers.h"
 
 #ifdef SK_DEBUG
 static const bool kDebugOnly = true;
 #else
 static const bool kDebugOnly = false;
 #endif
@@ skipping 501 matching lines @@
         gm->draw(canvas);
         canvas->setDrawFilter(NULL);
     }
 
     static ErrorCombination generate_image(GM* gm, const ConfigData& gRec,
                                            GrSurface* gpuTarget,
                                            SkBitmap* bitmap,
                                            bool deferred) {
         SkISize size (gm->getISize());
         setup_bitmap(gRec, size, bitmap);
+        SkImageInfo info;
+        bitmap->asImageInfo(&info);
 
+        SkAutoTUnref<SkSurface> surface;
         SkAutoTUnref<SkCanvas> canvas;
 
         if (gRec.fBackend == kRaster_Backend) {
-            SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*bitmap)));
+            surface.reset(SkSurface::NewRasterDirect(info,
+                                                     bitmap->getPixels(),
+                                                     bitmap->rowBytes()));
             if (deferred) {
-                canvas.reset(SkDeferredCanvas::Create(device));
+                canvas.reset(SkDeferredCanvas::Create(surface));
             } else {
-                canvas.reset(SkNEW_ARGS(SkCanvas, (device)));
+                canvas.reset(SkRef(surface->getCanvas()));
             }
             invokeGM(gm, canvas, false, deferred);
             canvas->flush();
         }
 #if SK_SUPPORT_GPU
         else {  // GPU
-            SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(gpuTarget));
+            surface.reset(SkSurface::NewRenderTargetDirect(gpuTarget->asRenderTarget()));
             if (deferred) {
-                canvas.reset(SkDeferredCanvas::Create(device));
+                canvas.reset(SkDeferredCanvas::Create(surface));
             } else {
-                canvas.reset(SkNEW_ARGS(SkCanvas, (device)));
+                canvas.reset(SkRef(surface->getCanvas()));
             }
             invokeGM(gm, canvas, false, deferred);
             // the device is as large as the current rendertarget, so
             // we explicitly only readback the amount we expect (in
             // size) overwrite our previous allocation
             bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,
                               size.fHeight);
             canvas->readPixels(bitmap, 0, 0);
         }
 #endif
@@ skipping 1821 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif