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);
+    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);
     }
     return MHD_YES;
 }
 
 // SendOK just sends an empty response with a 200 OK status code.
 static int SendOK(MHD_Connection* connection) {
     const char* data = "";
 
     MHD_Response* response = MHD_create_response_from_buffer(strlen(data),
                                                              (void*)data,
                                                              MHD_RESPMEM_PERSISTENT);
     int ret = MHD_queue_response(connection, 200, response);
     MHD_destroy_response(response);
     return ret;
 }
 
+static int SendError(MHD_Connection* connection, const char* msg) {
+    MHD_Response* response = MHD_create_response_from_buffer(strlen(msg),
+                                                             (void*) msg,
+                                                             MHD_RESPMEM_PERSISTENT);
+    int ret = MHD_queue_response(connection, 500, response);
+    MHD_destroy_response(response);
+    return ret;
+}
+
 static int SendData(MHD_Connection* connection, const SkData* data, const char* type,
                     bool setContentDisposition = false, const char* dispositionString = nullptr) {
     MHD_Response* response = MHD_create_response_from_buffer(data->size(),
                                                              const_cast<void*>(data->data()),
                                                              MHD_RESPMEM_MUST_COPY);
     MHD_add_response_header(response, "Content-Type", type);
 
     if (setContentDisposition) {
         MHD_add_response_header(response, "Content-Disposition", dispositionString);
     }
@@ skipping 234 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) {
+            SkSurface* surface = createGPUSurface(request);
+            if (surface) {
+                request->fSurface.reset(surface);
+                return SendOK(connection);
+            }
+            return SendError(connection, "Unable to create GPU surface");
+        }
+        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 25 matching lines @@
         uc->fPostProcessor = nullptr;
 
         // parse picture from stream
         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()));
-
         // 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 47 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 27 matching lines @@
     int result = kUrlManager.invoke(request, connection, url, method, upload_data,
                                     upload_data_size);
     if (MHD_NO == result) {
         fprintf(stderr, "Invalid method and / or url: %s %s\n", method, url);
     }
     return result;
 }
 
 int skiaserve_main() {
     Request request(SkString("/data")); // This simple server has one request
+
+    // create surface
+    GrContextOptions grContextOpts;
+    request.fContextFactory.reset(new GrContextFactory(grContextOpts));
+    request.fSurface.reset(createCPUSurface());
+
     struct MHD_Daemon* daemon;
     // TODO Add option to bind this strictly to an address, e.g. localhost, for security.
     daemon = MHD_start_daemon(MHD_USE_SELECT_INTERNALLY, FLAGS_port, nullptr, nullptr,
                               &answer_to_connection, &request,
                               MHD_OPTION_END);
     if (NULL == daemon) {
         return 1;
     }
 
     getchar();
     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