Modify skia serve to return clip rect and view matrix

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 "SkJSONCPP.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelSerializer.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
@@ skipping 86 matching lines @@
     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);
 }
 
+SkSurface* setupCpuSurface() {
+    SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType,
+                                         kPremul_SkAlphaType);
+    return SkSurface::NewRaster(info);
+}
+
 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 51 matching lines @@
 
 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 {
+class CmdHandler : public UrlHandler {
 public:
     bool canHandle(const char* method, const char* url) override {
         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 {
         SkTArray<SkString> commands;
@@ skipping 147 matching lines @@
         picture->serialize(&outStream, serializer);
 
         SkAutoTUnref<SkData> data(outStream.copyToData());
 
         // TODO fancier name handling
         return SendData(connection, data, "application/octet-stream", true,
                         "attachment; filename=something.skp;");
     }
 };
 
+class InfoHandler : public UrlHandler {
+public:
+    bool canHandle(const char* method, const char* url) override {
+        const char* kBaseName = "/info";
+        return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
+               0 == strncmp(url, kBaseName, strlen(kBaseName));
+    }
+
+    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 (!request->fPicture.get() || commands.count() > 2) {
+            return MHD_NO;
+        }
+
+        // drawTo
+        SkAutoTUnref<SkSurface> surface(setupCpuSurface());
+        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);
+        }
+
+        // TODO this is really slow and we should cache the matrix and clip
+        request->fDebugCanvas->drawTo(canvas, n);
+
+        // make some json
+        SkMatrix vm = request->fDebugCanvas->getCurrentMatrix();
+        SkIRect clip = request->fDebugCanvas->getCurrentClip();
+        Json::Value info(Json::objectValue);
+        info["ViewMatrix"] = SkJSONCanvas::MakeMatrix(vm);
+        info["ClipRect"] = SkJSONCanvas::MakeIRect(clip);
+
+        std::string json = Json::FastWriter().write(info);
+
+        // We don't want the null terminator so strlen is correct
+        SkAutoTUnref<SkData> data(SkData::NewWithCopy(json.c_str(), strlen(json.c_str())));
+        return SendData(connection, data, "application/json");
+    }
+};
+
+
 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 CmdHandler);
         fHandlers.push_back(new InfoHandler);
         fHandlers.push_back(new DownloadHandler);
     }
 
     ~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,
@@ skipping 43 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