Modify skiaserve to support downloads

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 "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
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 __SK_FORCE_IMAGE_DECODER_LINKING;
@@ skipping 97 matching lines @@
                                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) {
+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);
+    }
+
     int ret = MHD_queue_response(connection, MHD_HTTP_OK, response);
     MHD_destroy_response(response);
     return ret;
 }
 
 static int SendJSON(MHD_Connection* connection, SkDebugCanvas* debugCanvas, int n) {
     SkDynamicMemoryWStream stream;
     SkAutoTUnref<SkJSONCanvas> jsonCanvas(new SkJSONCanvas(kImageWidth, kImageHeight, stream));
     debugCanvas->drawTo(jsonCanvas, n);
     jsonCanvas->finish();
@@ skipping 158 matching lines @@
         request->fDebugCanvas->drawPicture(request->fPicture);
 
         // clear upload context
         delete request->fUploadContext;
         request->fUploadContext = nullptr;
 
         return SendTemplate(connection, true, "/");
     }
 };
 
+class DownloadHandler : public UrlHandler {
+public:
+    bool canHandle(const char* method, const char* url) override {
+        return 0 == strcmp(method, MHD_HTTP_METHOD_GET) &&
+               0 == strcmp(url, "/download");
+    }
+
+    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 MHD_NO;
+        }
+
+        // TODO move to a function
+        // Playback into picture recorder
+        SkPictureRecorder recorder;
+        SkCanvas* canvas = recorder.beginRecording(kImageWidth, kImageHeight);
+
+        request->fDebugCanvas->draw(canvas);
+
+        SkAutoTUnref<SkPicture> picture(recorder.endRecording());
+
+        SkDynamicMemoryWStream outStream;
+
+        SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
+        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 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);
+        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,
                const char* upload_data, size_t* upload_data_size) const {
         for (int i = 0; i < fHandlers.count(); i++) {
@@ skipping 41 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