added /enableGPU command to skiaserve

tools/skiaserve/skiaserve.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrCaps.h"
 #include "GrContextFactory.h"
 #include "SkCanvas.h"
@@ skipping 58 matching lines @@
 struct Request {
     Request(SkString rootUrl) : fUploadContext(nullptr), fUrlDataManager(rootUrl) {}
     UploadContext* fUploadContext;
     SkAutoTUnref<SkPicture> fPicture;
     SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
     SkAutoTDelete<GrContextFactory> fContextFactory;
     SkAutoTUnref<SkSurface> fSurface;
     UrlDataManager fUrlDataManager;
 };
 
-// TODO factor this out into functions, also handle CPU path
-SkSurface* setupSurface(GrContextFactory* factory) {
-    GrContext* context = factory->get(GrContextFactory::kNative_GLContextType,
-                                      GrContextFactory::kNone_GLContextOptions);
-    int maxRTSize = context->caps()->maxRenderTargetSize();
-    SkImageInfo info = SkImageInfo::Make(SkTMin(kImageWidth, maxRTSize),
-                                         SkTMin(kImageHeight, maxRTSize),
-                                         kN32_SkColorType, kPremul_SkAlphaType);
-    uint32_t flags = 0;
-    SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
-    SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0,
-                                                    &props);
-    SkASSERT(surface);
-
-    return surface;
-}
-
 static void write_png_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
     SkWStream* out = (SkWStream*) png_get_io_ptr(png_ptr);
     out->write(data, length);
 }
 
 static void write_png(const png_bytep rgba, png_uint_32 width, png_uint_32 height, SkWStream& out) {
     png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
     SkASSERT(png != nullptr);
     png_infop info_ptr = png_create_info_struct(png);
     SkASSERT(info_ptr != nullptr);
@@ skipping 59 matching lines @@
 void drawToCanvas(Request* request, int n) {
     SkCanvas* target = getCanvasFromRequest(request);
     request->fDebugCanvas->drawTo(target, n);
 }
 
 SkData* drawToPng(Request* request, int n) {
     drawToCanvas(request, n);
     return writeCanvasToPng(getCanvasFromRequest(request));
 }
 
-SkSurface* setupCpuSurface() {
+SkSurface* createCPUSurface() {
     SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType,
                                          kPremul_SkAlphaType);
     return SkSurface::NewRaster(info);
 }
 
+SkSurface* createGPUSurface(Request* request) {
+    GrContext* context = request->fContextFactory->get(GrContextFactory::kNative_GLContextType,
+                                                       GrContextFactory::kNone_GLContextOptions);
+    int maxRTSize = context->caps()->maxRenderTargetSize();
+    SkImageInfo info = SkImageInfo::Make(SkTMin(kImageWidth, maxRTSize),
+                                         SkTMin(kImageHeight, maxRTSize),
+                                         kN32_SkColorType, kPremul_SkAlphaType);
+    uint32_t flags = 0;
+    SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
+    SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0,
+                                                    &props);
+    SkASSERT(surface);

[jcgregorio, 2016/02/19 15:23:56]

Instead of asserting how about checking for a NULL returned from
createGPUSurface and fall back to using the CPU surface?

+
+    return surface;
+}
+
 static const size_t kBufferSize = 1024;
 
 static int process_upload_data(void* cls, enum MHD_ValueKind kind,
                                const char* key, const char* filename,
                                const char* content_type, const char* transfer_encoding,
                                const char* data, uint64_t off, size_t size) {
     struct UploadContext* uc = reinterpret_cast<UploadContext*>(cls);
 
     if (0 != size) {
         uc->fStream.write(data, size);
@@ skipping 260 matching lines @@
         }
 
         int alpha;
         sscanf(commands[1].c_str(), "%d", &alpha);
 
         request->fDebugCanvas->setClipVizColor(SkColorSetARGB(alpha, 0, 0, 0));
         return SendOK(connection);
     }
 };
 
+/**
+   Controls whether GPU rendering is enabled. Posting to /enableGPU/1 turns GPU on, /enableGPU/0 
+   disables it.
+ */
+class EnableGPUHandler : public UrlHandler {
+public:
+    bool canHandle(const char* method, const char* url) override {
+        static const char* kBasePath = "/enableGPU/";
+        return 0 == strcmp(method, MHD_HTTP_METHOD_POST) &&
+               0 == strncmp(url, kBasePath, strlen(kBasePath));
+    }
+
+    int handle(Request* request, MHD_Connection* connection,
+               const char* url, const char* method,
+               const char* upload_data, size_t* upload_data_size) override {
+        SkTArray<SkString> commands;
+        SkStrSplit(url, "/", &commands);
+
+        if (commands.count() != 2) {
+            return MHD_NO;
+        }
+
+        int enable;
+        sscanf(commands[1].c_str(), "%d", &enable);
+
+        if (enable) {
+            request->fSurface.reset(createGPUSurface(request));
+        }
+        else {
+            request->fSurface.reset(createCPUSurface());
+        }
+        return SendOK(connection);
+    }
+};
+
 class PostHandler : public UrlHandler {
 public:
     bool canHandle(const char* method, const char* url) override {
         return 0 == strcmp(method, MHD_HTTP_METHOD_POST) &&
                0 == strcmp(url, "/new");
     }
 
     int handle(Request* request, MHD_Connection* connection,
                const char* url, const char* method,
                const char* upload_data, size_t* upload_data_size) override {
@@ skipping 28 matching lines @@
         request->fPicture.reset(
             SkPicture::CreateFromStream(request->fUploadContext->fStream.detachAsStream()));
         if (!request->fPicture.get()) {
             fprintf(stderr, "Could not create picture from stream.\n");
             return MHD_NO;
         }
 
         // create surface
         GrContextOptions grContextOpts;
         request->fContextFactory.reset(new GrContextFactory(grContextOpts));
-        request->fSurface.reset(setupSurface(request->fContextFactory.get()));
+        request->fSurface.reset(createGPUSurface(request));
 
         // pour picture into debug canvas
         request->fDebugCanvas.reset(new SkDebugCanvas(kImageWidth, kImageHeight));
         request->fDebugCanvas->drawPicture(request->fPicture);
 
         // clear upload context
         delete request->fUploadContext;
         request->fUploadContext = nullptr;
 
         return SendTemplate(connection, true, "/");
@@ skipping 48 matching lines @@
                const char* url, const char* method,
                const char* upload_data, size_t* upload_data_size) override {
         SkTArray<SkString> commands;
         SkStrSplit(url, "/", &commands);
 
         if (!request->fPicture.get() || commands.count() > 2) {
             return MHD_NO;
         }
 
         // drawTo
-        SkAutoTUnref<SkSurface> surface(setupCpuSurface());
+        SkAutoTUnref<SkSurface> surface(createCPUSurface());
         SkCanvas* canvas = surface->getCanvas();
 
         int n;
         // /info or /info/N
         if (commands.count() == 1) {
             n = request->fDebugCanvas->getSize() - 1;
         } else {
             sscanf(commands[1].c_str(), "%d", &n);
         }
 
@@ skipping 80 matching lines @@
 };
 
 class UrlManager {
 public:
     UrlManager() {
         // Register handlers
         fHandlers.push_back(new RootHandler);
         fHandlers.push_back(new PostHandler);
         fHandlers.push_back(new ImgHandler);
         fHandlers.push_back(new ClipAlphaHandler);
+        fHandlers.push_back(new EnableGPUHandler);
         fHandlers.push_back(new CmdHandler);
         fHandlers.push_back(new InfoHandler);
         fHandlers.push_back(new DownloadHandler);
         fHandlers.push_back(new DataHandler);
         fHandlers.push_back(new FaviconHandler);
         fHandlers.push_back(new BreakHandler);
     }
 
     ~UrlManager() {
         for (int i = 0; i < fHandlers.count(); i++) { delete fHandlers[i]; }
@@ skipping 47 matching lines @@
     MHD_stop_daemon(daemon);
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return skiaserve_main();
 }
 #endif