update callsites for Make image factories

tools/debugger/SkDrawCommand.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkDrawCommand.h"
@@ skipping 602 matching lines @@
         // PNG encode doesn't necessarily support all color formats, convert to a different
         // format
         size_t rowBytes = 4 * image.width();
         void* buffer = sk_malloc_throw(rowBytes * image.height());
         SkImageInfo dstInfo = SkImageInfo::Make(image.width(), image.height(), 
                                                 kN32_SkColorType, kPremul_SkAlphaType);
         if (!image.readPixels(dstInfo, buffer, rowBytes, 0, 0)) {
             SkDebugf("readPixels failed\n");
             return false;
         }
-        SkImage* converted = SkImage::NewRasterCopy(dstInfo, buffer, rowBytes);
+        sk_sp<SkImage> converted = SkImage::MakeRasterCopy(SkPixmap(dstInfo, buffer, rowBytes));
         encoded = converted->encode(SkImageEncoder::kPNG_Type, 100);
         if (encoded == nullptr) {
             SkDebugf("image encode failed\n");
             return false;
         }
-        sk_free(converted);
         sk_free(buffer);
     }
     Json::Value jsonData;
     encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager, &jsonData);
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
     encoded->unref();
     return true;
 }
 
 static const char* color_type_name(SkColorType colorType) {
@@ skipping 108 matching lines @@
 }
 
 // caller is responsible for freeing return value
 static SkBitmap* load_bitmap(const Json::Value& jsonBitmap, UrlDataManager& urlDataManager) {
     if (!jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_DATA)) {
         SkDebugf("invalid bitmap\n");
         return nullptr;
     }
     const void* data;
     int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
-    SkAutoTUnref<SkData> encoded(SkData::NewWithoutCopy(data, size));
-    SkAutoTDelete<SkImage> image(SkImage::NewFromEncoded(encoded, nullptr));
+    sk_sp<SkData> encoded(SkData::NewWithoutCopy(data, size));
+    sk_sp<SkImage> image(SkImage::MakeFromEncoded(std::move(encoded), nullptr));
 
     SkAutoTDelete<SkBitmap> bitmap(new SkBitmap());
     if (nullptr != image) {
         if (!image->asLegacyBitmap(bitmap, SkImage::kRW_LegacyBitmapMode)) {
             SkDebugf("image decode failed\n");
             return nullptr;
         }
 
         if (jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) {
             const char* ctName = jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_COLOR].asCString();
             SkColorType ct = colortype_from_name(ctName);
             if (ct != kIndex_8_SkColorType) {
                 bitmap.reset(convert_colortype(bitmap.release(), ct));
             }
         }
         return bitmap.release();
     }
     SkDebugf("image decode failed\n");
     return nullptr;
 }
 
-static SkImage* load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) {
+static sk_sp<SkImage> load_image(const Json::Value& jsonImage, UrlDataManager& urlDataManager) {
     SkBitmap* bitmap = load_bitmap(jsonImage, urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
-    SkImage* result = SkImage::NewFromBitmap(*bitmap);
+    auto result = SkImage::MakeFromBitmap(*bitmap);
     delete bitmap;
     return result;
 }
 
 static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target, 
                                           UrlDataManager& urlDataManager) {
     bitmap.lockPixels();
-    SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
+    sk_sp<SkImage> image(SkImage::MakeFromBitmap(bitmap));
     bitmap.unlockPixels();
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = Json::Value(color_type_name(bitmap.colorType()));
     (*target)[SKDEBUGCANVAS_ATTRIBUTE_ALPHA] = Json::Value(alpha_type_name(bitmap.alphaType()));
     bool success = flatten(*image, target, urlDataManager);
     return success;
 }
 
 static void apply_paint_color(const SkPaint& paint, Json::Value* target) {
     SkColor color = paint.getColor();
     if (color != SK_ColorBLACK) {
@@ skipping 1153 matching lines @@
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
         if (fPaint.isValid()) {
             result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
         }
     }
     return result;
 }
 
 SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command, 
                                                  UrlDataManager& urlDataManager) {
-    SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
+    sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
     if (image == nullptr) {
         return nullptr;
     }
     Json::Value point = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
-    SkDrawImageCommand* result = new SkDrawImageCommand(image, point[0].asFloat(), 
+    SkDrawImageCommand* result = new SkDrawImageCommand(image.get(), point[0].asFloat(),
                                                         point[1].asFloat(), paintPtr);
-    image->unref();
     return result;
 }
 
 SkDrawImageRectCommand::SkDrawImageRectCommand(const SkImage* image, const SkRect* src,
                                                const SkRect& dst, const SkPaint* paint,
                                                SkCanvas::SrcRectConstraint constraint)
     : INHERITED(kDrawImageRect_OpType)
     , fImage(SkRef(image))
     , fDst(dst)
     , fConstraint(constraint) {
@@ skipping 46 matching lines @@
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
 SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command, 
                                                          UrlDataManager& urlDataManager) {
-    SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
+    sk_sp<SkImage> image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE], urlDataManager);
     if (image == nullptr) {
         return nullptr;
     }
     SkRect dst;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_DST], &dst);
     SkPaint* paintPtr;
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
         extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
@@ skipping 11 matching lines @@
     }
     SkRect* srcPtr;
     SkRect src;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_SRC)) {
         extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_SRC], &src);
         srcPtr = &src;
     }
     else {
         srcPtr = nullptr;
     }
-    SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image, srcPtr, dst, paintPtr, 
+    SkDrawImageRectCommand* result = new SkDrawImageRectCommand(image.get(), srcPtr, dst, paintPtr,
                                                                 constraint);
-    image->unref();
     return result;
 }
 
 SkDrawOvalCommand::SkDrawOvalCommand(const SkRect& oval, const SkPaint& paint)
     : INHERITED(kDrawOval_OpType) {
     fOval = oval;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::RectToString(oval));
     fInfo.push(SkObjectParser::PaintToString(paint));
@@ skipping 1010 matching lines @@
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = MakeJsonMatrix(fMatrix);
     return result;
 }
 
 SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command, 
                                                  UrlDataManager& urlDataManager) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkSetMatrixCommand(matrix);
 }