pdfviewer: add ability to run on gpu

experimental/PdfViewer/pdf_viewer_main.cpp

 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkDevice.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkTArray.h"
 #include "SkNulCanvas.h"
 
+#if SK_SUPPORT_GPU
+#include "GrContextFactory.h"
+#include "GrContext.h"
+#include "SkGpuDevice.h"
+#endif
+
 #include "SkPdfRenderer.h"
 
 DEFINE_string2(readPath, r, "", "pdf files or directories of pdf files to process.");
 DEFINE_string2(writePath, w, "", "Directory to write the rendered pages.");
 DEFINE_bool2(noExtensionForOnePagePdf, n, false, "No page extension if only one page.");
 DEFINE_bool2(showMemoryUsage, m, false, "Show Memory usage.");
 DEFINE_string2(pages, p, "all", "What pages to render and how:\n"
                                 "\tall - all pages\n"
                                 "\treverse - all pages, in reverse order\n"
                                 "\tfirst - first page\n"
                                 "\tlast - last page\n"
                                 "\tnumber - a specific page number\n"
                );
 DEFINE_double(DPI, 72, "DPI to be used for rendering (scale).");
 DEFINE_int32(benchLoad, 0, "Load the pdf file minimally N times, without any rendering and \n"
              "\tminimal parsing to ensure correctness. Default 0 (disabled).");
 DEFINE_int32(benchRender, 0, "Render the pdf content N times. Default 0 (disabled)");
 DEFINE_string2(config, c, "8888", "Canvas to render:\n"
-                                  "\t8888 - all pages\n"
-                                  "\tnul - all pages, in reverse order\n"
+                                  "\t8888 - argb\n"
+
+#if SK_SUPPORT_GPU
+                                  "\tgpu: use the gpu\n"
+#endif
+                                  "\tnul - render in null canvas, any draw will just return.\n"
                );
 
 
 // TODO(edisonn): add config for device target(gpu, raster, pdf), + ability not to render at all
 
 /**
  * Given list of directories and files to use as input, expects to find .pdf
  * files and it will convert them to .png files writing them in the same directory
  * one file for each page.
  *
@@ skipping 105 matching lines @@
 /** Write the output of pdf renderer to a file.
  * @param outputDir Output dir.
  * @param inputFilename The skp file that was read.
  * @param renderer The object responsible to write the pdf file.
  * @param page -1 means there is only one page (0), and render in a file without page extension
  */
 
 extern "C" SkBitmap* gDumpBitmap;
 extern "C" SkCanvas* gDumpCanvas;
 
+#if SK_SUPPORT_GPU
+GrContextFactory gContextFactory;
+#endif
+
 static bool render_page(const SkString& outputDir,
                         const SkString& inputFilename,
                         const SkPdfRenderer& renderer,
                         int page) {
     SkRect rect = renderer.MediaBox(page < 0 ? 0 :page);
 
     // Exercise all pdf codepaths as in normal rendering, but no actual bits are changed.
     if (!FLAGS_config.isEmpty() && strcmp(FLAGS_config[0], "nul") == 0) {
         SkBitmap bitmap;
         SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
         SkNulCanvas canvas(device);
         renderer.renderPage(page < 0 ? 0 : page, &canvas, rect);
     } else {
         // 8888
         SkRect rect = renderer.MediaBox(page < 0 ? 0 :page);
 
         SkBitmap bitmap;
         SkScalar width = SkScalarMul(rect.width(),  SkDoubleToScalar(sqrt(FLAGS_DPI / 72.0)));
         SkScalar height = SkScalarMul(rect.height(),  SkDoubleToScalar(sqrt(FLAGS_DPI / 72.0)));
 
         rect = SkRect::MakeWH(width, height);
 
 #ifdef PDF_DEBUG_3X
         setup_bitmap(&bitmap, 3 * (int)SkScalarToDouble(width), 3 * (int)SkScalarToDouble(height));
 #else
         setup_bitmap(&bitmap, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
 #endif
-        SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
+        SkAutoTUnref<SkDevice> device;
+        if (strcmp(FLAGS_config[0], "8888") == 0) {
+            device.reset(SkNEW_ARGS(SkDevice, (bitmap)));
+        }
+#if SK_SUPPORT_GPU
+        else if (strcmp(FLAGS_config[0], "gpu") == 0) {
+            SkAutoTUnref<GrSurface> target;
+            GrContext* gr = gContextFactory.get(GrContextFactory::kNative_GLContextType);
+            if (gr) {
+                // create a render target to back the device
+                GrTextureDesc desc;
+                desc.fConfig = kSkia8888_GrPixelConfig;
+                desc.fFlags = kRenderTarget_GrTextureFlagBit;
+                desc.fWidth = width;
+                desc.fHeight = height;
+                desc.fSampleCnt = 0;
+                target.reset(gr->createUncachedTexture(desc, NULL, 0));
+            }
+            if (NULL == target.get()) {
+                SkASSERT(0);
+                return false;
+            }
+
+            device.reset(SkGpuDevice::Create(target));
+        }
+#endif
+        else {
+            SkDebugf("unknown --config: %s\n", FLAGS_config[0]);
+            return false;
+        }
         SkCanvas canvas(device);
 
         gDumpBitmap = &bitmap;
 
         gDumpCanvas = &canvas;
         renderer.renderPage(page < 0 ? 0 : page, &canvas, rect);
 
         SkString outputPath;
         if (!make_output_filepath(&outputPath, outputDir, inputFilename, page)) {
             return false;
@@ skipping 132 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif