Create image cache for use by json canvas

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 "UrlDataManager.h"
+
 #include <sys/socket.h>
 #include <microhttpd.h>
 
 // To get image decoders linked in we have to do the below magic
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_string(source, "https://debugger.skia.org", "Where to load the web UI from.");
 DEFINE_int32(port, 8888, "The port to listen on.");
@@ skipping 25 matching lines @@
 
 }
 
 struct UploadContext {
     SkDynamicMemoryWStream fStream;
     MHD_PostProcessor* fPostProcessor;
     MHD_Connection* connection;
 };
 
 struct Request {
-    Request() : fUploadContext(nullptr) {}
+    Request(SkString rootUrl) : fUploadContext(nullptr), fUrlDataManager(rootUrl) {}
     UploadContext* fUploadContext;
     SkAutoTUnref<SkPicture> fPicture;
     SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
+    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);
@@ skipping 12 matching lines @@
 SkData* writeCanvasToPng(SkCanvas* canvas) {
     // capture pixels
     SkBitmap bmp;
     bmp.setInfo(canvas->imageInfo());
     if (!canvas->readPixels(&bmp, 0, 0)) {
         fprintf(stderr, "Can't read pixels\n");
         return nullptr;
     }
 
     // write to png
+    // TODO encoding to png can be quite slow, we should investigate bmp
     SkData* png = SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100);
     if (!png) {
         fprintf(stderr, "Can't encode to png\n");
         return nullptr;
     }
     return png;
 }
 
 SkData* setupAndDrawToCanvasReturnPng(SkDebugCanvas* debugCanvas, int n) {
     GrContextOptions grContextOpts;
@@ skipping 292 matching lines @@
         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 DataHandler : public UrlHandler {
+public:
+    bool canHandle(const char* method, const char* url) override {
+        static const char* kBaseUrl = "/data";
+        return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
+               0 == strncmp(url, kBaseUrl, strlen(kBaseUrl));
+    }
+
+    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;
+        }
+
+        SkAutoTUnref<UrlDataManager::UrlData> urlData(
+            SkRef(request->fUrlDataManager.getDataFromUrl(SkString(url))));
+
+        if (urlData) {
+            return SendData(connection, urlData->fData.get(), urlData->fContentType.c_str());
+        }
+        return MHD_NO;
+    }
+};
 
 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);
+        fHandlers.push_back(new DataHandler);
     }
 
     ~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++) {
@@ skipping 20 matching lines @@
     Request* request = reinterpret_cast<Request*>(cls);
     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; // This simple server has one request
+    Request request(SkString("/data")); // This simple server has one request
     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