Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.

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 "SkPictureRecorder.h"
@@ skipping 34 matching lines @@
 SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
     SkBitmap* bmp = new SkBitmap();
     bmp->setInfo(canvas->imageInfo());
     if (!canvas->readPixels(bmp, 0, 0)) {
         fprintf(stderr, "Can't read pixels\n");
         return nullptr;
     }
     return bmp;
 }
 
-SkData* Request::writeCanvasToPng(SkCanvas* canvas) {
+sk_sp<SkData> Request::writeCanvasToPng(SkCanvas* canvas) {
     // capture pixels
     SkAutoTDelete<SkBitmap> bmp(this->getBitmapFromCanvas(canvas));
     SkASSERT(bmp);
 
     // Convert to format suitable for PNG output
     sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(*bmp);
     SkASSERT(encodedBitmap.get());
 
     // write to an opaque png (black background)
     SkDynamicMemoryWStream buffer;
     SkDrawCommand::WritePNG((const png_bytep) encodedBitmap->bytes(), bmp->width(), bmp->height(),
                             buffer, true);
-    return buffer.copyToData();
+    return sk_sp<SkData>(buffer.copyToData());
 }
 
 SkCanvas* Request::getCanvas() {
 #if SK_SUPPORT_GPU
     GrContextFactory* factory = fContextFactory;
     GLTestContext* gl = factory->getContextInfo(GrContextFactory::kNativeGL_ContextType,
                                                 GrContextFactory::kNone_ContextOptions).glContext();
     if (!gl) {
         gl = factory->getContextInfo(GrContextFactory::kMESA_ContextType,
                                      GrContextFactory::kNone_ContextOptions).glContext();
@@ skipping 10 matching lines @@
     }
     SkCanvas* target = fSurface->getCanvas();
     return target;
 }
 
 void Request::drawToCanvas(int n, int m) {
     SkCanvas* target = this->getCanvas();
     fDebugCanvas->drawTo(target, n, m);
 }
 
-SkData* Request::drawToPng(int n, int m) {
+sk_sp<SkData> Request::drawToPng(int n, int m) {
     this->drawToCanvas(n, m);
     return writeCanvasToPng(this->getCanvas());
 }
 
-SkData* Request::writeOutSkp() {
+sk_sp<SkData> Request::writeOutSkp() {
     // Playback into picture recorder
     SkIRect bounds = this->getBounds();
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(bounds.width()),
                                                SkIntToScalar(bounds.height()));
 
     fDebugCanvas->draw(canvas);
 
     sk_sp<SkPicture> picture(recorder.finishRecordingAsPicture());
 
     SkDynamicMemoryWStream outStream;
 
     SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
     picture->serialize(&outStream, serializer);
 
-    return outStream.copyToData();
+    return sk_sp<SkData>(outStream.copyToData());
 }
 
 GrContext* Request::getContext() {
 #if SK_SUPPORT_GPU
     GrContext* result = fContextFactory->get(GrContextFactory::kNativeGL_ContextType,
                                              GrContextFactory::kNone_ContextOptions);
     if (!result) {
         result = fContextFactory->get(GrContextFactory::kMESA_ContextType,
                                       GrContextFactory::kNone_ContextOptions);
     }
@@ skipping 104 matching lines @@
     SkIRect bounds = this->getBounds();
     fDebugCanvas.reset(new SkDebugCanvas(bounds.width(), bounds.height()));
     fDebugCanvas->drawPicture(fPicture);
 
     // for some reason we need to 'flush' the debug canvas by drawing all of the ops
     fDebugCanvas->drawTo(this->getCanvas(), this->getLastOp());
     this->getCanvas()->flush();
     return true;
 }
 
-SkData* Request::getJsonOps(int n) {
+sk_sp<SkData> Request::getJsonOps(int n) {
     SkCanvas* canvas = this->getCanvas();
     Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
     root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
     root["drawGpuBatchBounds"] = Json::Value(fDebugCanvas->getDrawGpuBatchBounds());
     root["colorMode"] = Json::Value(fColorMode);
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(root).c_str());
 
-    return stream.copyToData();
+    return sk_sp<SkData>(stream.copyToData());
 }
 
-SkData* Request::getJsonBatchList(int n) {
+sk_sp<SkData> Request::getJsonBatchList(int n) {
     SkCanvas* canvas = this->getCanvas();
     SkASSERT(fGPUEnabled);
 
     Json::Value result = fDebugCanvas->toJSONBatchList(n, canvas);
 
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(result).c_str());
 
-    return stream.copyToData();
+    return sk_sp<SkData>(stream.copyToData());
 }
 
-SkData* Request::getJsonInfo(int n) {
+sk_sp<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"] = SkDrawCommand::MakeJsonMatrix(vm);
     info["ClipRect"] = SkDrawCommand::MakeJsonIRect(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()));
+    return SkData::MakeWithCopy(json.c_str(), strlen(json.c_str()));
 }
 
 SkColor Request::getPixel(int x, int y) {
     SkCanvas* canvas = this->getCanvas();
     canvas->flush();
     SkAutoTDelete<SkBitmap> bitmap(this->getBitmapFromCanvas(canvas));
     SkASSERT(bitmap);
 
     // Convert to format suitable for inspection
     sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(*bitmap);
     SkASSERT(encodedBitmap.get());
 
     const uint8_t* start = encodedBitmap->bytes() + ((y * bitmap->width() + x) * 4);
     SkColor result = SkColorSetARGB(start[3], start[0], start[1], start[2]);
     return result;
 }