skiaserve now retains the graphics context rather than creating a new one each request

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 52 matching lines @@
     SkDynamicMemoryWStream fStream;
     MHD_PostProcessor* fPostProcessor;
     MHD_Connection* connection;
 };
 
 struct Request {
     Request(SkString rootUrl) : fUploadContext(nullptr), fUrlDataManager(rootUrl) {}
     UploadContext* fUploadContext;
     SkAutoTUnref<SkPicture> fPicture;
     SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
+    SkAutoTDelete<GrContextFactory> fContextFactory;
+    SkAutoTUnref<SkSurface> fSurface;
     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);
     uint32_t flags = 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0,
                                                     &props);
     SkASSERT(surface);
 
-    SkGLContext* gl = factory->getContextInfo(GrContextFactory::kNative_GLContextType,
-                                              GrContextFactory::kNone_GLContextOptions).fGLContext;
-    gl->makeCurrent();
     return surface;
 }
 
 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;
-    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);
+SkData* setupAndDrawToCanvasReturnPng(Request* request, int n) {
+    GrContextFactory* factory = request->fContextFactory;
+    SkGLContext* gl = factory->getContextInfo(GrContextFactory::kNative_GLContextType,
+                                              GrContextFactory::kNone_GLContextOptions).fGLContext;
+    gl->makeCurrent();
+    SkASSERT(request->fDebugCanvas);
+    SkCanvas* target = request->fSurface->getCanvas();
+    request->fDebugCanvas->drawTo(target, n);
+    return writeCanvasToPng(target);
 }
 
 SkSurface* setupCpuSurface() {
     SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType,
                                          kPremul_SkAlphaType);
     return SkSurface::NewRaster(info);
 }
 
 static const size_t kBufferSize = 1024;
 
@@ skipping 146 matching lines @@
         }
 
         int n;
         // /img or /img/N
         if (commands.count() == 1) {
             n = request->fDebugCanvas->getSize() - 1;
         } else {
             sscanf(commands[1].c_str(), "%d", &n);
         }
 
-        SkAutoTUnref<SkData> data(setupAndDrawToCanvasReturnPng(request->fDebugCanvas, n));
+        SkAutoTUnref<SkData> data(setupAndDrawToCanvasReturnPng(request, n));
         return SendData(connection, data, "image/png");
     }
 };
 
 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 29 matching lines @@
         uc->fPostProcessor = nullptr;
 
         // parse picture from stream
         request->fPicture.reset(
             SkPicture::CreateFromStream(request->fUploadContext->fStream.detachAsStream()));
         if (!request->fPicture.get()) {
             fprintf(stderr, "Could not create picture from stream.\n");
             return MHD_NO;
         }
 
+        // create surface
+        GrContextOptions grContextOpts;
+        request->fContextFactory.reset(new GrContextFactory(grContextOpts));
+        request->fSurface.reset(setupSurface(request->fContextFactory.get()));
+
         // pour picture into debug canvas
         request->fDebugCanvas.reset(new SkDebugCanvas(kImageWidth, kImageHeight));
         request->fDebugCanvas->drawPicture(request->fPicture);
 
         // clear upload context
         delete request->fUploadContext;
         request->fUploadContext = nullptr;
 
         return SendTemplate(connection, true, "/");
     }
@@ skipping 213 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