added mode=cpu|gpu to skiaserve JSON

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 49 matching lines @@
 
 }
 
 struct UploadContext {
     SkDynamicMemoryWStream fStream;
     MHD_PostProcessor* fPostProcessor;
     MHD_Connection* connection;
 };
 
 struct Request {
-    Request(SkString rootUrl) : fUploadContext(nullptr), fUrlDataManager(rootUrl) {}
+    Request(SkString rootUrl) 
+    : fUploadContext(nullptr)
+    , fUrlDataManager(rootUrl)
+    , fGPUEnabled(false) {}
+
     UploadContext* fUploadContext;
     SkAutoTUnref<SkPicture> fPicture;
     SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
     SkAutoTDelete<GrContextFactory> fContextFactory;
     SkAutoTUnref<SkSurface> fSurface;
     UrlDataManager fUrlDataManager;
+    bool fGPUEnabled;
 };
 
 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);
@@ skipping 132 matching lines @@
 
     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, SkCanvas* canvas, SkDebugCanvas* debugCanvas,
-                    UrlDataManager* urlDataManager, int n) {
+static int SendJSON(MHD_Connection* connection, Request* request, int n) {
+    SkCanvas* canvas = getCanvasFromRequest(request);
+    SkDebugCanvas* debugCanvas = request->fDebugCanvas;
+    UrlDataManager* urlDataManager = &request->fUrlDataManager;
     Json::Value root = debugCanvas->toJSON(*urlDataManager, n, canvas);
+    root["mode"] = Json::Value(request->fGPUEnabled ? "gpu" : "cpu");
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(root).c_str());
 
     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 43 matching lines @@
         }
 
         // /cmd or /cmd/N
         if (0 == strcmp(method, MHD_HTTP_METHOD_GET)) {
             int n;
             if (commands.count() == 1) {
                 n = request->fDebugCanvas->getSize() - 1;
             } else {
                 sscanf(commands[1].c_str(), "%d", &n);
             }
-            return SendJSON(connection, getCanvasFromRequest(request), request->fDebugCanvas,
-                            &request->fUrlDataManager, n);
+            return SendJSON(connection, request, 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 SendOK(connection);
         }
 
@@ skipping 179 matching lines @@
             return MHD_NO;
         }
 
         int enable;
         sscanf(commands[1].c_str(), "%d", &enable);
 
         if (enable) {
             SkSurface* surface = createGPUSurface(request);
             if (surface) {
                 request->fSurface.reset(surface);
+                request->fGPUEnabled = true;
                 return SendOK(connection);
             }
             return SendError(connection, "Unable to create GPU surface");
         }
         request->fSurface.reset(createCPUSurface());
+        request->fGPUEnabled = false;
         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");
     }
@@ skipping 271 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