Modify skiaserve to support drawTo and /cmd/N

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"
 #include "SkCommandLineFlags.h"
+#include "SkDebugCanvas.h"
 #include "SkJSONCanvas.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 
 #include <sys/socket.h>
 #include <microhttpd.h>
 
 // To get image decoders linked in we have to do the below magic
 #include "SkForceLinking.h"
@@ skipping 32 matching lines @@
 
 struct UploadContext {
     SkDynamicMemoryWStream fStream;
     MHD_PostProcessor* fPostProcessor;
     MHD_Connection* connection;
 };
 
 struct Request {
     Request() : fUploadContext(nullptr) {}
     UploadContext* fUploadContext;
-    SkAutoTUnref<SkData> fPNG;
     SkAutoTUnref<SkPicture> fPicture;
+    SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
 };
 
 // TODO factor this out into functions, also handle CPU path
-bool setupAndDrawToCanvas(Request* request, SkString* error) {
-    GrContextOptions grContextOpts;
-    SkAutoTDelete<GrContextFactory> factory(new GrContextFactory(grContextOpts));
-
+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);
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context,
-                                                               SkSurface::kNo_Budgeted, info,
-                                                               0, &props));
-    SkASSERT(surface.get());
+    SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0,
+                                                    &props);
+    SkASSERT(surface);
 
     SkGLContext* gl = factory->getContextInfo(GrContextFactory::kNative_GLContextType,
                                               GrContextFactory::kNone_GLContextOptions).fGLContext;
     gl->makeCurrent();
+    return surface;
+}
 
-    // draw
-    request->fPicture.reset(
-        SkPicture::CreateFromStream(request->fUploadContext->fStream.detachAsStream()));
-    if (!request->fPicture.get()) {
-        error->appendf("Could not create picture from stream.\n");
-        return false;
-    }
-
-    SkCanvas* canvas = surface->getCanvas();
-    canvas->drawPicture(request->fPicture);
-
+SkData* writeCanvasToPng(SkCanvas* canvas) {
     // capture pixels
     SkBitmap bmp;
     bmp.setInfo(canvas->imageInfo());
     if (!canvas->readPixels(&bmp, 0, 0)) {
-        error->appendf("Can't read canvas pixels.\n");
-        return false;
+        fprintf(stderr, "Can't read pixels\n");
+        return nullptr;
     }
 
     // write to png
-    request->fPNG.reset(SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100));
-    if (!request->fPNG) {
-        error->appendf("Can't encode a PNG.\n");
-        return false;
+    SkData* png = SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100);
+    if (!png) {
+        fprintf(stderr, "Can't encode to png\n");
+        return nullptr;
     }
-    return true;
+    return png;
+}
+
+SkData* setupAndDrawToCanvasReturnPng(SkDebugCanvas* debugCanvas, int n) {
+    GrContextOptions grContextOpts;
+    SkAutoTDelete<GrContextFactory> factory(new GrContextFactory(grContextOpts));
+    SkAutoTUnref<SkSurface> surface(setupSurface(factory.get()));
+
+    SkASSERT(debugCanvas);
+    SkCanvas* canvas = surface->getCanvas();
+    debugCanvas->drawTo(canvas, n);
+    return writeCanvasToPng(canvas);
 }
 
 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;
 }
 
 static int SendData(MHD_Connection* connection, const SkData* data, const char* type) {
     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);
 
     int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
     MHD_destroy_response(response);
     return ret;
 }
 
-static int SendJSON(MHD_Connection* connection, SkPicture* picture) {
+static int SendJSON(MHD_Connection* connection, SkDebugCanvas* debugCanvas, int n) {
     SkDynamicMemoryWStream stream;
     SkAutoTUnref<SkJSONCanvas> jsonCanvas(new SkJSONCanvas(kImageWidth, kImageHeight, stream));
-    jsonCanvas->drawPicture(picture);
+    debugCanvas->drawTo(jsonCanvas, n);
     jsonCanvas->finish();
 
     SkAutoTUnref<SkData> data(stream.copyToData());
     return SendData(connection, data, "application/json");
 }
 
 static int SendTemplate(MHD_Connection* connection, bool redirect = false,
                         const char* redirectUrl = nullptr) {
     SkString debuggerTemplate = generateTemplate(SkString(FLAGS_source[0]));
 
@@ skipping 13 matching lines @@
     int ret = MHD_queue_response(connection, status, response);
     MHD_destroy_response(response);
     return ret;
 }
 
 class UrlHandler {
 public:
     virtual ~UrlHandler() {}
     virtual bool canHandle(const char* method, const char* url) = 0;
     virtual int handle(Request* request, MHD_Connection* connection,
+                       const char* url, const char* method,
                        const char* upload_data, size_t* upload_data_size) = 0;
 };
 
 class InfoHandler : public UrlHandler {
 public:
     bool canHandle(const char* method, const char* url) override {
-        return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
-               0 == strcmp(url, "/cmd");
+        const char* kBasePath = "/cmd";
+        return 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 {
-        if (request->fPicture.get()) {
-            return SendJSON(connection, request->fPicture);
+        SkTArray<SkString> commands;
+        SkStrSplit(url, "/", &commands);
+
+        if (!request->fPicture.get() || commands.count() > 3) {
+            return MHD_NO;
         }
+
+        // /cmd or /cmd/N or /cmd/N/[0|1]
+        if (commands.count() == 1 && 0 == strcmp(method, MHD_HTTP_METHOD_GET)) {
+            int n = request->fDebugCanvas->getSize() - 1;
+            return SendJSON(connection, request->fDebugCanvas, n);
+        }
+
+        // /cmd/N, for now only delete supported
+        if (commands.count() == 2 && 0 == strcmp(method, MHD_HTTP_METHOD_DELETE)) {
+            int n;
+            sscanf(commands[1].c_str(), "%d", &n);
+            request->fDebugCanvas->deleteDrawCommandAt(n);
+            return MHD_YES;
+        }
+
+        // /cmd/N/[0|1]
+        if (commands.count() == 3 && 0 == strcmp(method, MHD_HTTP_METHOD_POST))  {
+            int n, toggle;
+            sscanf(commands[1].c_str(), "%d", &n);
+            sscanf(commands[2].c_str(), "%d", &toggle);
+            request->fDebugCanvas->toggleCommand(n, toggle);
+            return MHD_YES;
+        }
+
         return MHD_NO;
     }
 };
 
 class ImgHandler : public UrlHandler {
 public:
     bool canHandle(const char* method, const char* url) override {
         static const char* kBasePath = "/img";
         return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
                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 {
-        if (request->fPNG.get()) {
-            SkData* data = request->fPNG.get();
-            return SendData(connection, data, "image/png");
+        SkTArray<SkString> commands;
+        SkStrSplit(url, "/", &commands);

[jcgregorio, 2016/02/02 18:08:13]

Need to split off the trailing ?blahblahblah first, then split on "/".

+
+        if (!request->fPicture.get() || commands.count() > 2) {
+            return MHD_NO;
         }
 
-        return MHD_NO;
+        int n;
+        // /img or /img/N
+        if (commands.count() == 1) {
+            n = request->fDebugCanvas->getSize() - 1;
+        } else {
+            sscanf(commands[1].c_str(), "%d", &n);
+        }
+
+        SkAutoTUnref<SkData> data(setupAndDrawToCanvasReturnPng(request->fDebugCanvas, n));
+        return SendData(connection, data, "image/png");
     }
 };
 
 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 {
         UploadContext* uc =  request->fUploadContext;
 
         // New connection
         if (!uc) {
             // TODO make this a method on request
             uc = new UploadContext;
             uc->connection = connection;
             uc->fPostProcessor = MHD_create_post_processor(connection, kBufferSize,
                                                            &process_upload_data, uc);
             SkASSERT(uc->fPostProcessor);
 
             request->fUploadContext = uc;
             return MHD_YES;
         }
 
         // in process upload
         if (0 != *upload_data_size) {
             SkASSERT(uc->fPostProcessor);
             MHD_post_process(uc->fPostProcessor, upload_data, *upload_data_size);
             *upload_data_size = 0;
             return MHD_YES;
         }
 
         // end of upload
         MHD_destroy_post_processor(uc->fPostProcessor);
         uc->fPostProcessor = nullptr;
 
-        // TODO response
-        SkString error;
-        if (!setupAndDrawToCanvas(request, &error)) {
-            // TODO send error
-            return MHD_YES;
+        // 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;
         }
 
+        // 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, "/");
     }
 };
 
 class RootHandler : public UrlHandler {
 public:
     bool canHandle(const char* method, const char* url) override {
         return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
                0 == strcmp(url, "/");
     }
 
     int handle(Request* request, MHD_Connection* connection,
+               const char* url, const char* method,
                const char* upload_data, size_t* upload_data_size) override {
         return SendTemplate(connection);
     }
 };
 
 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 InfoHandler);
     }
 
     ~UrlManager() {
         for (int i = 0; i < fHandlers.count(); i++) { delete fHandlers[i]; }
     }
 
     // This is clearly not efficient for a large number of urls and handlers
     int invoke(Request* request, MHD_Connection* connection, const char* url, const char* method,
                const char* upload_data, size_t* upload_data_size) const {
         for (int i = 0; i < fHandlers.count(); i++) {
             if (fHandlers[i]->canHandle(method, url)) {
-                return fHandlers[i]->handle(request, connection, upload_data, upload_data_size);
+                return fHandlers[i]->handle(request, connection, url, method, upload_data,
+                                            upload_data_size);
             }
         }
         return MHD_NO;
     }
 
 private:
     SkTArray<UrlHandler*> fHandlers;
 };
 
 const UrlManager kUrlManager;
@@ skipping 28 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