Get SkiaServe Request started off with a little privacy

tools/skiaserve/Request.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 "Request.h"
 
 #include "png.h"
 
+#include "SkJSONCanvas.h"
+
 const int Request::kImageWidth = 1920;
 const int Request::kImageHeight = 1080;
 
 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);
@@ skipping 19 matching lines @@
         }
     }
     png_set_filter(png, 0, PNG_NO_FILTERS);
     png_set_rows(png, info_ptr, &rows[0]);
     png_set_write_fn(png, &out, write_png_callback, NULL);
     png_write_png(png, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
     png_destroy_write_struct(&png, NULL);
     sk_free(rows);
 }
 
+Request::Request(SkString rootUrl)
+    : fUploadContext(nullptr)
+    , fUrlDataManager(rootUrl)
+    , fGPUEnabled(false) {
+    // create surface
+    GrContextOptions grContextOpts;
+    fContextFactory.reset(new GrContextFactory(grContextOpts));
+    fSurface.reset(this->createCPUSurface());
+}
+
 SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
     SkBitmap* bmp = new SkBitmap();
     SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kRGBA_8888_SkColorType,
                 kOpaque_SkAlphaType);
     bmp->setInfo(info);
     if (!canvas->readPixels(bmp, 0, 0)) {
         fprintf(stderr, "Can't read pixels\n");
         return nullptr;
     }
     return bmp;
@@ skipping 43 matching lines @@
     SkImageInfo info = SkImageInfo::Make(SkTMin(kImageWidth, maxRTSize),
                                          SkTMin(kImageHeight, maxRTSize),
                                          kN32_SkColorType, kPremul_SkAlphaType);
     uint32_t flags = 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     SkSurface* surface = SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0,
                                                     &props);
     return surface;
 }
 
+bool Request::enableGPU(bool enable) {    
+    if (enable) {
+        SkSurface* surface = this->createGPUSurface();
+        if (surface) {
+            fSurface.reset(surface);
+            fGPUEnabled = true;
+            return true;
+        }
+        return false;
+    }
+    fSurface.reset(this->createCPUSurface());
+    fGPUEnabled = false;
+    return true;
+}
+
 SkData* Request::getJsonOps(int n) {
     SkCanvas* canvas = this->getCanvas();
     Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
     root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(root).c_str());
 
     return stream.copyToData();
 }
 
@@ skipping 18 matching lines @@
     SkDEBUGCODE(bool parsingSuccessful = )reader.parse(at->toJson(true).c_str(),
                                                        parsedFromString);
     SkASSERT(parsingSuccessful);
 #endif
 
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(parsedFromString).c_str());
 
     return stream.copyToData();
 }
+
+SkData* Request::getJsonInfo(int n) {
+    // drawTo
+    SkAutoTUnref<SkSurface> surface(this->createCPUSurface());
+    SkCanvas* canvas = surface->getCanvas();
+
+    // TODO this is really slow and we should cache the matrix and clip
+    fDebugCanvas->drawTo(canvas, n);
+
+    // make some json
+    SkMatrix vm = fDebugCanvas->getCurrentMatrix();
+    SkIRect clip = 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
+    return SkData::NewWithCopy(json.c_str(), strlen(json.c_str()));
+}