integrated SkDebugCanvas JSON support with UrlDataManager

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"
 #include "SkBlurMaskFilter.h"
 #include "SkColorFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkObjectParser.h"
 #include "SkPaintDefaults.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkTextBlob.h"
 #include "SkTextBlobRunIterator.h"
 #include "SkTHash.h"
 #include "SkTypeface.h"
 #include "SkValidatingReadBuffer.h"
 #include "SkWriteBuffer.h"
 
-#define SKDEBUGCANVAS_SEND_BINARIES               false
-
 #define SKDEBUGCANVAS_ATTRIBUTE_COMMAND           "command"
 #define SKDEBUGCANVAS_ATTRIBUTE_MATRIX            "matrix"
 #define SKDEBUGCANVAS_ATTRIBUTE_COORDS            "coords"
 #define SKDEBUGCANVAS_ATTRIBUTE_BOUNDS            "bounds"
 #define SKDEBUGCANVAS_ATTRIBUTE_PAINT             "paint"
 #define SKDEBUGCANVAS_ATTRIBUTE_OUTER             "outer"
 #define SKDEBUGCANVAS_ATTRIBUTE_INNER             "inner"
 #define SKDEBUGCANVAS_ATTRIBUTE_MODE              "mode"
 #define SKDEBUGCANVAS_ATTRIBUTE_POINTS            "points"
 #define SKDEBUGCANVAS_ATTRIBUTE_PATH              "path"
@@ skipping 17 matching lines @@
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN         "textAlign"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE          "textSize"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX        "textScaleX"
 #define SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX         "textSkewX"
 #define SKDEBUGCANVAS_ATTRIBUTE_DASHING           "dashing"
 #define SKDEBUGCANVAS_ATTRIBUTE_INTERVALS         "intervals"
 #define SKDEBUGCANVAS_ATTRIBUTE_PHASE             "phase"
 #define SKDEBUGCANVAS_ATTRIBUTE_FILLTYPE          "fillType"
 #define SKDEBUGCANVAS_ATTRIBUTE_VERBS             "verbs"
 #define SKDEBUGCANVAS_ATTRIBUTE_NAME              "name"
-#define SKDEBUGCANVAS_ATTRIBUTE_BYTES             "bytes"
+#define SKDEBUGCANVAS_ATTRIBUTE_DATA              "data"
 #define SKDEBUGCANVAS_ATTRIBUTE_SHADER            "shader"
 #define SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT        "pathEffect"
 #define SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER        "maskFilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_XFERMODE          "xfermode"
 #define SKDEBUGCANVAS_ATTRIBUTE_LOOPER            "looper"
 #define SKDEBUGCANVAS_ATTRIBUTE_BACKDROP          "backdrop"
 #define SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER       "colorfilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER       "imagefilter"
 #define SKDEBUGCANVAS_ATTRIBUTE_IMAGE             "image"
 #define SKDEBUGCANVAS_ATTRIBUTE_BITMAP            "bitmap"
@@ skipping 71 matching lines @@
 
 #define SKDEBUGCANVAS_ALPHATYPE_OPAQUE            "opaque"
 #define SKDEBUGCANVAS_ALPHATYPE_PREMUL            "premul"
 #define SKDEBUGCANVAS_ALPHATYPE_UNPREMUL          "unpremul"
 
 #define SKDEBUGCANVAS_FILTERQUALITY_NONE          "none"
 #define SKDEBUGCANVAS_FILTERQUALITY_LOW           "low"
 #define SKDEBUGCANVAS_FILTERQUALITY_MEDIUM        "medium"
 #define SKDEBUGCANVAS_FILTERQUALITY_HIGH          "high"
 
-typedef SkDrawCommand* (*FROM_JSON)(Json::Value);
+typedef SkDrawCommand* (*FROM_JSON)(Json::Value&, UrlDataManager&);
 
 // TODO(chudy): Refactor into non subclass model.
 
 SkDrawCommand::SkDrawCommand(OpType type)
     : fOpType(type)
     , fVisible(true) {
 }
 
 SkDrawCommand::~SkDrawCommand() {
     fInfo.deleteAll();
@@ skipping 38 matching lines @@
             break;
     }
     SkDEBUGFAIL("DrawType UNUSED\n");
     return nullptr;
 }
 
 SkString SkDrawCommand::toString() const {
     return SkString(GetCommandString(fOpType));
 }
 
-Json::Value SkDrawCommand::toJSON() const {
+Json::Value SkDrawCommand::toJSON(UrlDataManager& urlDataManager) const {
     Json::Value result;
     result[SKDEBUGCANVAS_ATTRIBUTE_COMMAND] = this->GetCommandString(fOpType);
     return result;
 }
 
 #define INSTALL_FACTORY(name) factories.set(SkString(GetCommandString(k ## name ##_OpType)), \
                                             (FROM_JSON) Sk ## name ## Command::fromJSON)
-SkDrawCommand* SkDrawCommand::fromJSON(Json::Value& command) {
+SkDrawCommand* SkDrawCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     static SkTHashMap<SkString, FROM_JSON> factories;
     static bool initialized = false;
     if (!initialized) {
         initialized = true;
         INSTALL_FACTORY(Restore);
         INSTALL_FACTORY(ClipPath);
         INSTALL_FACTORY(ClipRegion);
         INSTALL_FACTORY(ClipRect);
         INSTALL_FACTORY(ClipRRect);
         INSTALL_FACTORY(Concat);
@@ skipping 18 matching lines @@
         INSTALL_FACTORY(Save);
         INSTALL_FACTORY(SaveLayer);
         INSTALL_FACTORY(SetMatrix);
     }
     SkString name = SkString(command[SKDEBUGCANVAS_ATTRIBUTE_COMMAND].asCString());
     FROM_JSON* factory = factories.find(name);
     if (factory == nullptr) {
         SkDebugf("no JSON factory for '%s'\n", name.c_str());
         return nullptr;
     }
-    return (*factory)(command);
+    return (*factory)(command, urlDataManager);
 }
 
 namespace {
 
 void xlate_and_scale_to_bounds(SkCanvas* canvas, const SkRect& bounds) {
     const SkISize& size = canvas->getDeviceSize();
 
     static const SkScalar kInsetFrac = 0.9f; // Leave a border around object
 
     canvas->translate(size.fWidth/2.0f, size.fHeight/2.0f);
@@ skipping 300 matching lines @@
         (*target)[key] = Json::Value(value);
     }
 }
 
 static void store_bool(Json::Value* target, const char* key, bool value, bool defaultValue) {
     if (value != defaultValue) {
         (*target)[key] = Json::Value(value);
     }
 }
 
-static void encode_data(const void* data, size_t count, Json::Value* target) {
-    // just use a brain-dead JSON array for now, switch to base64 or something else smarter down the
-    // road
-    for (size_t i = 0; i < count; i++) {
-        target->append(((const uint8_t*)data)[i]);
-    }
+static void encode_data(const void* bytes, size_t count, const char* contentType, 
+                        UrlDataManager& urlDataManager, Json::Value* target) {
+    SkAutoTUnref<SkData> data(SkData::NewWithCopy(bytes, count));
+    SkString url = urlDataManager.addData(data, contentType);
+    *target = Json::Value(url.c_str());
 }
 
-static void flatten(const SkFlattenable* flattenable, Json::Value* target, bool sendBinaries) {
-    if (sendBinaries) {
-        SkWriteBuffer buffer;
-        flattenable->flatten(buffer);
-        void* data = sk_malloc_throw(buffer.bytesWritten());
-        buffer.writeToMemory(data);
-        Json::Value bytes;
-        encode_data(data, buffer.bytesWritten(), &bytes);
-        Json::Value jsonFlattenable;
-        jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME] = Json::Value(flattenable->getTypeName());
-        jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes;
-        (*target) = jsonFlattenable;
-        sk_free(data);
-    } else {
-        (*target)[SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION] = Json::Value(flattenable->getTypeName());
-    }
+static void flatten(const SkFlattenable* flattenable, Json::Value* target, 
+                    UrlDataManager& urlDataManager) {
+    SkWriteBuffer buffer;
+    flattenable->flatten(buffer);
+    void* data = sk_malloc_throw(buffer.bytesWritten());
+    buffer.writeToMemory(data);
+    Json::Value jsonData;
+    encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager, &jsonData);
+    Json::Value jsonFlattenable;
+    jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME] = Json::Value(flattenable->getTypeName());
+    jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
+    (*target) = jsonFlattenable;
+    sk_free(data);
 }
 
 static bool SK_WARN_UNUSED_RESULT flatten(const SkImage& image, Json::Value* target, 
-                                          bool sendBinaries) {
-    if (sendBinaries) {
-        SkData* encoded = image.encode(SkImageEncoder::kPNG_Type, 100);
+                                          UrlDataManager& urlDataManager) {
+    SkData* encoded = image.encode(SkImageEncoder::kPNG_Type, 100);
+    if (encoded == nullptr) {
+        // 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);
+        encoded = converted->encode(SkImageEncoder::kPNG_Type, 100);
         if (encoded == nullptr) {
-            // 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);
-            encoded = converted->encode(SkImageEncoder::kPNG_Type, 100);
-            if (encoded == nullptr) {
-                SkDebugf("image encode failed\n");
-                return false;
-            }
-            sk_free(converted);
-            sk_free(buffer);
+            SkDebugf("image encode failed\n");
+            return false;
         }
-        Json::Value bytes;
-        encode_data(encoded->data(), encoded->size(), &bytes);
-        (*target)[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes;
-        encoded->unref();
-    } else {
-        SkString description = SkStringPrintf("%dx%d pixel image", image.width(), image.height());
-        (*target)[SKDEBUGCANVAS_ATTRIBUTE_DESCRIPTION] = Json::Value(description.c_str());
+        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) {
     switch (colorType) {
         case kARGB_4444_SkColorType:
             return SKDEBUGCANVAS_COLORTYPE_ARGB4444;
         case kRGBA_8888_SkColorType:
             return SKDEBUGCANVAS_COLORTYPE_RGBA8888;
         case kBGRA_8888_SkColorType:
@@ skipping 19 matching lines @@
         case kPremul_SkAlphaType:
             return SKDEBUGCANVAS_ALPHATYPE_PREMUL;
         case kUnpremul_SkAlphaType:
             return SKDEBUGCANVAS_ALPHATYPE_UNPREMUL;
         default:
             SkASSERT(false);
             return SKDEBUGCANVAS_ALPHATYPE_OPAQUE;
     }
 }
 
-// note that the caller is responsible for freeing the pointer
-static Json::ArrayIndex decode_data(Json::Value bytes, void** target) {
-    Json::ArrayIndex size = bytes.size();
-    *target = sk_malloc_throw(size);
-    for (Json::ArrayIndex i = 0; i < size; i++) {
-        ((uint8_t*) *target)[i] = bytes[i].asInt();
+static Json::ArrayIndex decode_data(Json::Value data, UrlDataManager& urlDataManager, 
+                                    const void** target) {
+    UrlDataManager::UrlData* urlData = urlDataManager.getDataFromUrl(SkString(data.asCString()));
+    if (urlData == nullptr) {
+        SkASSERT(false);
+        *target = nullptr;
+        return 0;
     }
-    return size;
+    *target = urlData->fData->data();
+    // cast should be safe for any reasonably-sized object...
+    return (Json::ArrayIndex) urlData->fData->size();
 }
 
-static SkFlattenable* load_flattenable(Json::Value jsonFlattenable) {
+static SkFlattenable* load_flattenable(Json::Value jsonFlattenable, 
+                                       UrlDataManager& urlDataManager) {
     if (!jsonFlattenable.isMember(SKDEBUGCANVAS_ATTRIBUTE_NAME)) {
         return nullptr;
     }
     const char* name = jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_NAME].asCString();
     SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
     if (factory == nullptr) {
         SkDebugf("no factory for loading '%s'\n", name);
         return nullptr;
     }
-    void* data;
-    int size = decode_data(jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_BYTES], &data);
+    const void* data;
+    int size = decode_data(jsonFlattenable[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
     SkValidatingReadBuffer buffer(data, size);
     SkFlattenable* result = factory(buffer);
-    sk_free(data);
     if (!buffer.isValid()) {
         SkDebugf("invalid buffer loading flattenable\n");
         return nullptr;
     }
     return result;
 }
 
 static SkColorType colortype_from_name(const char* name) {
     if (!strcmp(name, SKDEBUGCANVAS_COLORTYPE_ARGB4444)) {
         return kARGB_4444_SkColorType;
@@ skipping 28 matching lines @@
     if (bitmap->copyTo(dst, colorType)) {
         delete bitmap;
         return dst;
     }
     SkASSERT(false);
     delete dst;
     return bitmap;
 }
 
 // caller is responsible for freeing return value
-static SkBitmap* load_bitmap(const Json::Value& jsonBitmap) {
-    if (!jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_BYTES)) {
+static SkBitmap* load_bitmap(const Json::Value& jsonBitmap, UrlDataManager& urlDataManager) {
+    if (!jsonBitmap.isMember(SKDEBUGCANVAS_ATTRIBUTE_DATA)) {
         SkDebugf("invalid bitmap\n");
         return nullptr;
     }
-    void* data;
-    int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_BYTES], &data);
+    const void* data;
+    int size = decode_data(jsonBitmap[SKDEBUGCANVAS_ATTRIBUTE_DATA], urlDataManager, &data);
     SkMemoryStream stream(data, size);
     SkImageDecoder* decoder = SkImageDecoder::Factory(&stream);
     SkBitmap* bitmap = new SkBitmap();
     SkImageDecoder::Result result = decoder->decode(&stream, bitmap, 
                                                     SkImageDecoder::kDecodePixels_Mode);
     sk_free(decoder);
     if (result != SkImageDecoder::kFailure) {
-        sk_free(data);
         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 = convert_colortype(bitmap, ct);
             }
         }
         return bitmap;
     }
     SkDebugf("image decode failed\n");
-    sk_free(data);
     return nullptr;
 }
 
-static SkImage* load_image(const Json::Value& jsonImage) {
-    SkBitmap* bitmap = load_bitmap(jsonImage);
+static 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);
     delete bitmap;
     return result;
 }
 
 static bool SK_WARN_UNUSED_RESULT flatten(const SkBitmap& bitmap, Json::Value* target, 
-                                          bool sendBinaries) {
+                                          UrlDataManager& urlDataManager) {
     bitmap.lockPixels();
     SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(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, sendBinaries);
+    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) {
         Json::Value colorValue(Json::arrayValue);
         colorValue.append(Json::Value(SkColorGetA(color)));
         colorValue.append(Json::Value(SkColorGetR(color)));
         colorValue.append(Json::Value(SkColorGetG(color)));
@@ skipping 73 matching lines @@
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY] = Json::Value(
                                                                 SKDEBUGCANVAS_FILTERQUALITY_MEDIUM);
             break;
         case kHigh_SkFilterQuality:
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_FILTERQUALITY] = Json::Value(
                                                                   SKDEBUGCANVAS_FILTERQUALITY_HIGH);
             break;
     }
 }
 
-static void apply_paint_maskfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_maskfilter(const SkPaint& paint, Json::Value* target, 
+                                   UrlDataManager& urlDataManager) {
     SkMaskFilter* maskFilter = paint.getMaskFilter();
     if (maskFilter != nullptr) {
         SkMaskFilter::BlurRec blurRec;
         if (maskFilter->asABlur(&blurRec)) {
             Json::Value blur(Json::objectValue);
             blur[SKDEBUGCANVAS_ATTRIBUTE_SIGMA] = Json::Value(blurRec.fSigma);
             switch (blurRec.fStyle) {
                 case SkBlurStyle::kNormal_SkBlurStyle:
                     blur[SKDEBUGCANVAS_ATTRIBUTE_STYLE] = Json::Value(
                                                                     SKDEBUGCANVAS_BLURSTYLE_NORMAL);
@@ skipping 21 matching lines @@
                 case SkBlurQuality::kHigh_SkBlurQuality:
                     blur[SKDEBUGCANVAS_ATTRIBUTE_QUALITY] = Json::Value(
                                                                     SKDEBUGCANVAS_BLURQUALITY_HIGH);
                     break;
                 default:
                     SkASSERT(false);
             }
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_BLUR] = blur;
         } else {
             Json::Value jsonMaskFilter;
-            flatten(maskFilter, &jsonMaskFilter, sendBinaries);
+            flatten(maskFilter, &jsonMaskFilter, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER] = jsonMaskFilter;
         }
     }
 }
 
-static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_patheffect(const SkPaint& paint, Json::Value* target, 
+                                   UrlDataManager& urlDataManager) {
     SkPathEffect* pathEffect = paint.getPathEffect();
     if (pathEffect != nullptr) {
         SkPathEffect::DashInfo dashInfo;
         SkPathEffect::DashType dashType = pathEffect->asADash(&dashInfo);
         if (dashType == SkPathEffect::kDash_DashType) {
             dashInfo.fIntervals = (SkScalar*) sk_malloc_throw(dashInfo.fCount * sizeof(SkScalar));
             pathEffect->asADash(&dashInfo);
             Json::Value dashing(Json::objectValue);
             Json::Value intervals(Json::arrayValue);
             for (int32_t i = 0; i < dashInfo.fCount; i++) {
                 intervals.append(Json::Value(dashInfo.fIntervals[i]));
             }
             sk_free(dashInfo.fIntervals);
             dashing[SKDEBUGCANVAS_ATTRIBUTE_INTERVALS] = intervals;
             dashing[SKDEBUGCANVAS_ATTRIBUTE_PHASE] = dashInfo.fPhase;
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_DASHING] = dashing;
         } else {
             Json::Value jsonPathEffect;
-            flatten(pathEffect, &jsonPathEffect, sendBinaries);
+            flatten(pathEffect, &jsonPathEffect, urlDataManager);
             (*target)[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT] = jsonPathEffect;
         }
     }
 }
     
 static void apply_paint_textalign(const SkPaint& paint, Json::Value* target) {
     SkPaint::Align textAlign = paint.getTextAlign();
     if (textAlign != SkPaint::kLeft_Align) {
         switch (textAlign) {
             case SkPaint::kCenter_Align: {
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN] = SKDEBUGCANVAS_ALIGN_CENTER;
                 break;
             }
             case SkPaint::kRight_Align: {
                 (*target)[SKDEBUGCANVAS_ATTRIBUTE_TEXTALIGN] = SKDEBUGCANVAS_ALIGN_RIGHT;
                 break;
             }
             default: SkASSERT(false);
         }
     }
 }
 
 static void apply_paint_typeface(const SkPaint& paint, Json::Value* target, 
-                                 bool sendBinaries) {
+                                 UrlDataManager& urlDataManager) {
     SkTypeface* typeface = paint.getTypeface();
     if (typeface != nullptr) {
-        if (sendBinaries) {
-            Json::Value jsonTypeface;
-            SkDynamicMemoryWStream buffer;
-            typeface->serialize(&buffer);
-            void* data = sk_malloc_throw(buffer.bytesWritten());
-            buffer.copyTo(data);
-            Json::Value bytes;
-            encode_data(data, buffer.bytesWritten(), &bytes);
-            jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_BYTES] = bytes;
-            sk_free(data);
-            (*target)[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface;
-        }
+        Json::Value jsonTypeface;
+        SkDynamicMemoryWStream buffer;
+        typeface->serialize(&buffer);
+        void* data = sk_malloc_throw(buffer.bytesWritten());
+        buffer.copyTo(data);
+        Json::Value jsonData;
+        encode_data(data, buffer.bytesWritten(), "application/octet-stream", urlDataManager, 
+                    &jsonData);
+        jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
+        sk_free(data);
+        (*target)[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface;
     }
 }
 
-static void apply_paint_shader(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_shader(const SkPaint& paint, Json::Value* target, 
+                               UrlDataManager& urlDataManager) {
     SkFlattenable* shader = paint.getShader();
     if (shader != nullptr) {
         Json::Value jsonShader;
-        flatten(shader, &jsonShader, sendBinaries);
+        flatten(shader, &jsonShader, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_SHADER] = jsonShader;
     }
 }
 
-static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target, 
+                                 UrlDataManager& urlDataManager) {
     SkFlattenable* xfermode = paint.getXfermode();
     if (xfermode != nullptr) {
         Json::Value jsonXfermode;
-        flatten(xfermode, &jsonXfermode, sendBinaries);
+        flatten(xfermode, &jsonXfermode, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
 }
 
-static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target,
+                                    UrlDataManager& urlDataManager) {
     SkFlattenable* imageFilter = paint.getImageFilter();
     if (imageFilter != nullptr) {
         Json::Value jsonImageFilter;
-        flatten(imageFilter, &jsonImageFilter, sendBinaries);
+        flatten(imageFilter, &jsonImageFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER] = jsonImageFilter;
     }
 }
 
-static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target, 
+                                    UrlDataManager& urlDataManager) {
     SkFlattenable* colorFilter = paint.getColorFilter();
     if (colorFilter != nullptr) {
         Json::Value jsonColorFilter;
-        flatten(colorFilter, &jsonColorFilter, sendBinaries);
+        flatten(colorFilter, &jsonColorFilter, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER] = jsonColorFilter;
     }
 }
 
-static void apply_paint_looper(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+static void apply_paint_looper(const SkPaint& paint, Json::Value* target, 
+                               UrlDataManager& urlDataManager) {
     SkFlattenable* looper = paint.getLooper();
     if (looper != nullptr) {
         Json::Value jsonLooper;
-        flatten(looper, &jsonLooper, sendBinaries);
+        flatten(looper, &jsonLooper, urlDataManager);
         (*target)[SKDEBUGCANVAS_ATTRIBUTE_LOOPER] = jsonLooper;
     }
 }
 
-Json::Value make_json_paint(const SkPaint& paint, bool sendBinaries) {
+Json::Value make_json_paint(const SkPaint& paint, UrlDataManager& urlDataManager) {
     Json::Value result(Json::objectValue);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(), 
                  SkPaintDefaults_MiterLimit);
     store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
     store_bool(&result, SKDEBUGCANVAS_ATTRIBUTE_DITHER, paint.isDither(), false);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSIZE, paint.getTextSize(), 
                  SkPaintDefaults_TextSize);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextScaleX(), SK_Scalar1);
     store_scalar(&result, SKDEBUGCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextSkewX(), 0.0f);
     apply_paint_color(paint, &result);
     apply_paint_style(paint, &result);
     apply_paint_cap(paint, &result);
     apply_paint_join(paint, &result);
     apply_paint_filterquality(paint, &result);
     apply_paint_textalign(paint, &result);
-    apply_paint_patheffect(paint, &result, sendBinaries);
-    apply_paint_maskfilter(paint, &result, sendBinaries);
-    apply_paint_shader(paint, &result, sendBinaries);
-    apply_paint_xfermode(paint, &result, sendBinaries);
-    apply_paint_looper(paint, &result, sendBinaries);
-    apply_paint_imagefilter(paint, &result, sendBinaries);
-    apply_paint_colorfilter(paint, &result, sendBinaries);
-    apply_paint_typeface(paint, &result, sendBinaries);
+    apply_paint_patheffect(paint, &result, urlDataManager);
+    apply_paint_maskfilter(paint, &result, urlDataManager);
+    apply_paint_shader(paint, &result, urlDataManager);
+    apply_paint_xfermode(paint, &result, urlDataManager);
+    apply_paint_looper(paint, &result, urlDataManager);
+    apply_paint_imagefilter(paint, &result, urlDataManager);
+    apply_paint_colorfilter(paint, &result, urlDataManager);
+    apply_paint_typeface(paint, &result, urlDataManager);
     return result;
 }
 
 static SkPoint get_json_point(Json::Value point) {
     return SkPoint::Make(point[0].asFloat(), point[1].asFloat());
 }
 
 static SkColor get_json_color(Json::Value color) {
     return SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(), color[3].asInt());
 }
 
 static void extract_json_paint_color(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLOR)) {
         target->setColor(get_json_color(jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLOR]));
     }
 }
 
-static void extract_json_paint_shader(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_shader(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                      SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_SHADER)) {
         Json::Value jsonShader = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_SHADER];
-        SkShader* shader = (SkShader*) load_flattenable(jsonShader);
+        SkShader* shader = (SkShader*) load_flattenable(jsonShader, urlDataManager);
         if (shader != nullptr) {
             target->setShader(shader);
             shader->unref();
         }
     }
 }
 
-static void extract_json_paint_patheffect(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_patheffect(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                          SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT)) {
         Json::Value jsonPathEffect = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_PATHEFFECT];
-        SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect);
+        SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect, urlDataManager);
         if (pathEffect != nullptr) {
             target->setPathEffect(pathEffect);
             pathEffect->unref();
         }
     }
 }
 
-static void extract_json_paint_maskfilter(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_maskfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                          SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER)) {
         Json::Value jsonMaskFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_MASKFILTER];
-        SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter);
+        SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter, urlDataManager);
         if (maskFilter != nullptr) {
             target->setMaskFilter(maskFilter);
             maskFilter->unref();
         }
     }
 }
 
-static void extract_json_paint_colorfilter(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_colorfilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                           SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER)) {
         Json::Value jsonColorFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_COLORFILTER];
-        SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter);
+        SkColorFilter* colorFilter = (SkColorFilter*) load_flattenable(jsonColorFilter, 
+                                                                       urlDataManager);
         if (colorFilter != nullptr) {
             target->setColorFilter(colorFilter);
             colorFilter->unref();
         }
     }
 }
 
-static void extract_json_paint_xfermode(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_xfermode(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                        SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
         Json::Value jsonXfermode = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
-        SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode);
+        SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode, urlDataManager);
         if (xfermode != nullptr) {
             target->setXfermode(xfermode);
             xfermode->unref();
         }
     }
 }
 
-static void extract_json_paint_looper(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_looper(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                      SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_LOOPER)) {
         Json::Value jsonLooper = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_LOOPER];
-        SkDrawLooper* looper = (SkDrawLooper*) load_flattenable(jsonLooper);
+        SkDrawLooper* looper = (SkDrawLooper*) load_flattenable(jsonLooper, urlDataManager);
         if (looper != nullptr) {
             target->setLooper(looper);
             looper->unref();
         }
     }
 }
 
-static void extract_json_paint_imagefilter(Json::Value& jsonPaint, SkPaint* target) {
+static void extract_json_paint_imagefilter(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                           SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER)) {
         Json::Value jsonImageFilter = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_IMAGEFILTER];
-        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter);
+        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter, 
+                                                                       urlDataManager);
         if (imageFilter != nullptr) {
             target->setImageFilter(imageFilter);
             imageFilter->unref();
         }
     }
 }
 
+static void extract_json_paint_typeface(Json::Value& jsonPaint, UrlDataManager& urlDataManager, 
+                                        SkPaint* target) {
+    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE)) {
+        Json::Value jsonTypeface = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE];
+        Json::Value jsonData = jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_DATA];
+        const void* data;
+        Json::ArrayIndex length = decode_data(jsonData, urlDataManager, &data);
+        SkMemoryStream buffer(data, length);
+        SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
+        target->setTypeface(typeface);
+    }
+}
+
 static void extract_json_paint_style(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_STYLE)) {
         const char* style = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_STYLE].asCString();
         if (!strcmp(style, SKDEBUGCANVAS_STYLE_FILL)) {
             target->setStyle(SkPaint::kFill_Style);
         }
         else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKE)) {
             target->setStyle(SkPaint::kStroke_Style);
         }
         else if (!strcmp(style, SKDEBUGCANVAS_STYLE_STROKEANDFILL)) {
@@ skipping 167 matching lines @@
     }
 }
 
 static void extract_json_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX)) {
         float textSkewX = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
         target->setTextSkewX(textSkewX);
     }
 }
 
-static void extract_json_paint_typeface(Json::Value& jsonPaint, SkPaint* target) {
-    if (jsonPaint.isMember(SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE)) {
-        Json::Value jsonTypeface = jsonPaint[SKDEBUGCANVAS_ATTRIBUTE_TYPEFACE];
-        Json::Value bytes = jsonTypeface[SKDEBUGCANVAS_ATTRIBUTE_BYTES];
-        void* data;
-        Json::ArrayIndex length = decode_data(bytes, &data);
-        SkMemoryStream buffer(data, length);
-        SkTypeface* typeface = SkTypeface::Deserialize(&buffer);
-        sk_free(data);
-        target->setTypeface(typeface);
-    }
-}
-
-static void extract_json_paint(Json::Value& paint, SkPaint* result) {
+static void extract_json_paint(Json::Value& paint, UrlDataManager& urlDataManager, 
+                               SkPaint* result) {
     extract_json_paint_color(paint, result);
-    extract_json_paint_shader(paint, result);
-    extract_json_paint_patheffect(paint, result);
-    extract_json_paint_maskfilter(paint, result);
-    extract_json_paint_colorfilter(paint, result);
-    extract_json_paint_xfermode(paint, result);
-    extract_json_paint_looper(paint, result);
-    extract_json_paint_imagefilter(paint, result);
+    extract_json_paint_shader(paint, urlDataManager, result);
+    extract_json_paint_patheffect(paint, urlDataManager, result);
+    extract_json_paint_maskfilter(paint, urlDataManager, result);
+    extract_json_paint_colorfilter(paint, urlDataManager, result);
+    extract_json_paint_xfermode(paint, urlDataManager, result);
+    extract_json_paint_looper(paint, urlDataManager, result);
+    extract_json_paint_imagefilter(paint, urlDataManager, result);
+    extract_json_paint_typeface(paint, urlDataManager, result);
     extract_json_paint_style(paint, result);
     extract_json_paint_strokewidth(paint, result);
     extract_json_paint_strokemiter(paint, result);
     extract_json_paint_strokejoin(paint, result);
     extract_json_paint_cap(paint, result);
     extract_json_paint_filterquality(paint, result);
     extract_json_paint_antialias(paint, result);
     extract_json_paint_dither(paint, result);
     extract_json_paint_blur(paint, result);
     extract_json_paint_dashing(paint, result);
     extract_json_paint_textalign(paint, result);
     extract_json_paint_textsize(paint, result);
     extract_json_paint_textscalex(paint, result);
     extract_json_paint_textskewx(paint, result);
-    extract_json_paint_typeface(paint, result);
 }
 
 static void extract_json_rect(Json::Value& rect, SkRect* result) {
     result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
 }
 
 static void extract_json_irect(Json::Value& rect, SkIRect* result) {
     result->set(rect[0].asInt(), rect[1].asInt(), rect[2].asInt(), rect[3].asInt());
 }
 
@@ skipping 98 matching lines @@
 
 SkClearCommand::SkClearCommand(SkColor color) : INHERITED(kDrawClear_OpType) {
     fColor = color;
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 
 void SkClearCommand::execute(SkCanvas* canvas) const {
     canvas->clear(fColor);
 }
 
-Json::Value SkClearCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkClearCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COLOR] = make_json_color(fColor);
     return result;
 }
 
- SkClearCommand* SkClearCommand::fromJSON(Json::Value& command) {
+ SkClearCommand* SkClearCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     Json::Value color = command[SKDEBUGCANVAS_ATTRIBUTE_COLOR];
     return new SkClearCommand(get_json_color(color));
 }
 
 SkClipPathCommand::SkClipPathCommand(const SkPath& path, SkRegion::Op op, bool doAA)
     : INHERITED(kClipPath_OpType) {
     fPath = path;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void SkClipPathCommand::execute(SkCanvas* canvas) const {
     canvas->clipPath(fPath, fOp, fDoAA);
 }
 
 bool SkClipPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 
-Json::Value SkClipPathCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkClipPathCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = fDoAA;
     return result;
 }
 
-SkClipPathCommand* SkClipPathCommand::fromJSON(Json::Value& command) {
+SkClipPathCommand* SkClipPathCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     return new SkClipPathCommand(path, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkClipRegionCommand::SkClipRegionCommand(const SkRegion& region, SkRegion::Op op)
     : INHERITED(kClipRegion_OpType) {
     fRegion = region;
     fOp = op;
 
     fInfo.push(SkObjectParser::RegionToString(region));
     fInfo.push(SkObjectParser::RegionOpToString(op));
 }
 
 void SkClipRegionCommand::execute(SkCanvas* canvas) const {
     canvas->clipRegion(fRegion, fOp);
 }
 
-Json::Value SkClipRegionCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkClipRegionCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGION] = make_json_region(fRegion);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     return result;
 }
 
-SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command) {
+SkClipRegionCommand* SkClipRegionCommand::fromJSON(Json::Value& command, 
+                                                   UrlDataManager& urlDataManager) {
     SkASSERT(false);
     return nullptr;
 }
 
 SkClipRectCommand::SkClipRectCommand(const SkRect& rect, SkRegion::Op op, bool doAA)
     : INHERITED(kClipRect_OpType) {
     fRect = rect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void SkClipRectCommand::execute(SkCanvas* canvas) const {
     canvas->clipRect(fRect, fOp, fDoAA);
 }
 
-Json::Value SkClipRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkClipRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = Json::Value(fDoAA);
     return result;
 }
 
-SkClipRectCommand* SkClipRectCommand::fromJSON(Json::Value& command) {
+SkClipRectCommand* SkClipRectCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     SkRect rect;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rect);
     return new SkClipRectCommand(rect, get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
                                  command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkClipRRectCommand::SkClipRRectCommand(const SkRRect& rrect, SkRegion::Op op, bool doAA)
     : INHERITED(kClipRRect_OpType) {
     fRRect = rrect;
     fOp = op;
     fDoAA = doAA;
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::RegionOpToString(op));
     fInfo.push(SkObjectParser::BoolToString(doAA));
 }
 
 void SkClipRRectCommand::execute(SkCanvas* canvas) const {
     canvas->clipRRect(fRRect, fOp, fDoAA);
 }
 
 bool SkClipRRectCommand::render(SkCanvas* canvas) const {
     render_rrect(canvas, fRRect);
     return true;
 }
 
-Json::Value SkClipRRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkClipRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect);
     result[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP] = make_json_regionop(fOp);
     result[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS] = Json::Value(fDoAA);
     return result;
 }
 
-SkClipRRectCommand* SkClipRRectCommand::fromJSON(Json::Value& command) {
+SkClipRRectCommand* SkClipRRectCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     SkRRect rrect;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &rrect);
     return new SkClipRRectCommand(rrect, 
                                   get_json_regionop(command[SKDEBUGCANVAS_ATTRIBUTE_REGIONOP]), 
                                   command[SKDEBUGCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 SkConcatCommand::SkConcatCommand(const SkMatrix& matrix)
     : INHERITED(kConcat_OpType) {
     fMatrix = matrix;
 
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
 void SkConcatCommand::execute(SkCanvas* canvas) const {
     canvas->concat(fMatrix);
 }
 
-Json::Value SkConcatCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkConcatCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = make_json_matrix(fMatrix);
     return result;
 }
 
-SkConcatCommand* SkConcatCommand::fromJSON(Json::Value& command) {
+SkConcatCommand* SkConcatCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkConcatCommand(matrix);
 }
 
 SkDrawBitmapCommand::SkDrawBitmapCommand(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                                          const SkPaint* paint)
     : INHERITED(kDrawBitmap_OpType) {
     fBitmap = bitmap;
     fLeft = left;
@@ skipping 15 matching lines @@
 
 void SkDrawBitmapCommand::execute(SkCanvas* canvas) const {
     canvas->drawBitmap(fBitmap, fLeft, fTop, fPaintPtr);
 }
 
 bool SkDrawBitmapCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap);
     return true;
 }
 
-Json::Value SkDrawBitmapCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawBitmapCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
-    if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
+    if (flatten(fBitmap, &encoded, urlDataManager)) {
         Json::Value command(Json::objectValue);
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, 
-                                                                    SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command) {
-    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]);
+SkDrawBitmapCommand* SkDrawBitmapCommand::fromJSON(Json::Value& command, 
+                                                   UrlDataManager& urlDataManager) {
+    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == 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], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkDrawBitmapCommand* result = new SkDrawBitmapCommand(*bitmap, point[0].asFloat(), 
                                                           point[1].asFloat(), paintPtr);
     delete bitmap;
     return result;
 }
@@ skipping 22 matching lines @@
 void SkDrawBitmapNineCommand::execute(SkCanvas* canvas) const {
     canvas->drawBitmapNine(fBitmap, fCenter, fDst, fPaintPtr);
 }
 
 bool SkDrawBitmapNineCommand::render(SkCanvas* canvas) const {
     SkRect tmp = SkRect::Make(fCenter);
     render_bitmap(canvas, fBitmap, &tmp);
     return true;
 }
 
-Json::Value SkDrawBitmapNineCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawBitmapNineCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
-    if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
+    if (flatten(fBitmap, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_CENTER] = make_json_irect(fCenter);
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr,
-                                                                    SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command) {
-    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]);
+SkDrawBitmapNineCommand* SkDrawBitmapNineCommand::fromJSON(Json::Value& command, 
+                                                           UrlDataManager& urlDataManager) {
+    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == nullptr) {
         return nullptr;
     }
     SkIRect center;
     extract_json_irect(command[SKDEBUGCANVAS_ATTRIBUTE_CENTER], &center);
     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], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkDrawBitmapNineCommand* result = new SkDrawBitmapNineCommand(*bitmap, center, dst, paintPtr);
     delete bitmap;
     return result;
 }
 
@@ skipping 30 matching lines @@
 
 void SkDrawBitmapRectCommand::execute(SkCanvas* canvas) const {
     canvas->legacy_drawBitmapRect(fBitmap, this->srcRect(), fDst, fPaintPtr, fConstraint);
 }
 
 bool SkDrawBitmapRectCommand::render(SkCanvas* canvas) const {
     render_bitmap(canvas, fBitmap, this->srcRect());
     return true;
 }
 
-Json::Value SkDrawBitmapRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawBitmapRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
-    if (flatten(fBitmap, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
+    if (flatten(fBitmap, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         if (!fSrc.isEmpty()) {
             result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(fSrc);
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
         if (fPaintPtr != nullptr) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr,
-                                                                    SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
-SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command) {
-    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP]);
+SkDrawBitmapRectCommand* SkDrawBitmapRectCommand::fromJSON(Json::Value& command, 
+                                                           UrlDataManager& urlDataManager) {
+    SkBitmap* bitmap = load_bitmap(command[SKDEBUGCANVAS_ATTRIBUTE_BITMAP], urlDataManager);
     if (bitmap == 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], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkCanvas::SrcRectConstraint constraint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) && 
         command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
         constraint = SkCanvas::kStrict_SrcRectConstraint;
     }
@@ skipping 40 matching lines @@
     SkAutoCanvasRestore acr(canvas, true);
     canvas->clear(0xFFFFFFFF);
 
     xlate_and_scale_to_bounds(canvas, SkRect::MakeXYWH(fLeft, fTop,
                                                        SkIntToScalar(fImage->width()),
                                                        SkIntToScalar(fImage->height())));
     this->execute(canvas);
     return true;
 }
 
-Json::Value SkDrawImageCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawImageCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
-    if (flatten(*fImage, &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
+    if (flatten(*fImage, &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_IMAGE] = encoded;
         result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fLeft, fTop);
         if (fPaint.isValid()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(),
-                                                                    SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
         }
     }
     return result;
 }
 
-SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command) {
-    SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE]);
+SkDrawImageCommand* SkDrawImageCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
+    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], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkDrawImageCommand* result = new SkDrawImageCommand(image, point[0].asFloat(), 
                                                         point[1].asFloat(), paintPtr);
     image->unref();
     return result;
 }
@@ skipping 33 matching lines @@
 bool SkDrawImageRectCommand::render(SkCanvas* canvas) const {
     SkAutoCanvasRestore acr(canvas, true);
     canvas->clear(0xFFFFFFFF);
 
     xlate_and_scale_to_bounds(canvas, fDst);
 
     this->execute(canvas);
     return true;
 }
 
-Json::Value SkDrawImageRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawImageRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value encoded;
-    if (flatten(*fImage.get(), &encoded, SKDEBUGCANVAS_SEND_BINARIES)) {
+    if (flatten(*fImage.get(), &encoded, urlDataManager)) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BITMAP] = encoded;
         if (fSrc.isValid()) {
             result[SKDEBUGCANVAS_ATTRIBUTE_SRC] = make_json_rect(*fSrc.get());
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_DST] = make_json_rect(fDst);
         if (fPaint.isValid()) {
-            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(),
-                                                                    SKDEBUGCANVAS_SEND_BINARIES);
+            result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaint.get(), urlDataManager);
         }
         if (fConstraint == SkCanvas::kStrict_SrcRectConstraint) {
             result[SKDEBUGCANVAS_ATTRIBUTE_STRICT] = Json::Value(true);
         }
     }
     return result;
 }
 
-SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command) {
-    SkImage* image = load_image(command[SKDEBUGCANVAS_ATTRIBUTE_IMAGE]);
+SkDrawImageRectCommand* SkDrawImageRectCommand::fromJSON(Json::Value& command, 
+                                                         UrlDataManager& urlDataManager) {
+    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], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         paintPtr = &paint;
     }
     else {
         paintPtr = nullptr;
     }
     SkCanvas::SrcRectConstraint constraint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_STRICT) && 
         command[SKDEBUGCANVAS_ATTRIBUTE_STRICT].asBool()) {
         constraint = SkCanvas::kStrict_SrcRectConstraint;
     }
@@ skipping 37 matching lines @@
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
 
     canvas->drawOval(fOval, p);
     canvas->restore();
 
     return true;
 }
 
-Json::Value SkDrawOvalCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawOvalCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fOval);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command) {
+SkDrawOvalCommand* SkDrawOvalCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawOvalCommand(coords, paint);
 }
 
 SkDrawPaintCommand::SkDrawPaintCommand(const SkPaint& paint)
     : INHERITED(kDrawPaint_OpType) {
     fPaint = paint;
 
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPaintCommand::execute(SkCanvas* canvas) const {
     canvas->drawPaint(fPaint);
 }
 
 bool SkDrawPaintCommand::render(SkCanvas* canvas) const {
     canvas->clear(0xFFFFFFFF);
     canvas->drawPaint(fPaint);
     return true;
 }
 
-Json::Value SkDrawPaintCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+Json::Value SkDrawPaintCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command) {
+SkDrawPaintCommand* SkDrawPaintCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPaintCommand(paint);
 }
 
 SkDrawPathCommand::SkDrawPathCommand(const SkPath& path, const SkPaint& paint)
     : INHERITED(kDrawPath_OpType) {
     fPath = path;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::PathToString(path));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPathCommand::execute(SkCanvas* canvas) const {
     canvas->drawPath(fPath, fPaint);
 }
 
 bool SkDrawPathCommand::render(SkCanvas* canvas) const {
     render_path(canvas, fPath);
     return true;
 }
 
-Json::Value SkDrawPathCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawPathCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command) {
+SkDrawPathCommand* SkDrawPathCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPathCommand(path, paint);
 }
 
 SkBeginDrawPictureCommand::SkBeginDrawPictureCommand(const SkPicture* picture,
                                                      const SkMatrix* matrix,
                                                      const SkPaint* paint)
     : INHERITED(kBeginDrawPicture_OpType)
     , fPicture(SkRef(picture)) {
 
     SkString* str = new SkString;
@@ skipping 89 matching lines @@
     SkPaint p;
     p.setColor(SK_ColorBLACK);
     p.setStyle(SkPaint::kStroke_Style);
 
     canvas->drawPoints(fMode, fCount, fPts, p);
     canvas->restore();
 
     return true;
 }
 
-Json::Value SkDrawPointsCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawPointsCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_MODE] = make_json_pointmode(fMode);
     Json::Value points(Json::arrayValue);
     for (size_t i = 0; i < fCount; i++) {
         points.append(make_json_point(fPts[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_POINTS] = points;
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command) {
+SkDrawPointsCommand* SkDrawPointsCommand::fromJSON(Json::Value& command, 
+                                                   UrlDataManager& urlDataManager) {
     SkCanvas::PointMode mode;
     const char* jsonMode = command[SKDEBUGCANVAS_ATTRIBUTE_MODE].asCString();
     if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POINTS)) {
         mode = SkCanvas::kPoints_PointMode;
     }
     else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_LINES)) {
         mode = SkCanvas::kLines_PointMode;
     }
     else if (!strcmp(jsonMode, SKDEBUGCANVAS_POINTMODE_POLYGON)) {
         mode = SkCanvas::kPolygon_PointMode;
     }
     else {
         SkASSERT(false);
         return nullptr;
     }
     Json::Value jsonPoints = command[SKDEBUGCANVAS_ATTRIBUTE_POINTS];
     int count = (int) jsonPoints.size();
     SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint));
     for (int i = 0; i < count; i++) {
         points[i] = SkPoint::Make(jsonPoints[i][0].asFloat(), jsonPoints[i][1].asFloat());
     }
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     SkDrawPointsCommand* result = new SkDrawPointsCommand(mode, count, points, paint);
     sk_free(points);
     return result;
 }
 
 SkDrawPosTextCommand::SkDrawPosTextCommand(const void* text, size_t byteLength,
                                            const SkPoint pos[], const SkPaint& paint)
     : INHERITED(kDrawPosText_OpType) {
     size_t numPts = paint.countText(text, byteLength);
 
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
 
     fPos = new SkPoint[numPts];
     memcpy(fPos, pos, numPts * sizeof(SkPoint));
 
     fPaint = paint;
 
     fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
     // TODO(chudy): Test that this works.
     fInfo.push(SkObjectParser::PointsToString(pos, 1));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPosTextCommand::execute(SkCanvas* canvas) const {
     canvas->drawPosText(fText, fByteLength, fPos, fPaint);
 }
 
-Json::Value SkDrawPosTextCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawPosTextCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     for (size_t i = 0; i < fByteLength; i++) {
         coords.append(make_json_point(fPos[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = coords;
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command) {
+SkDrawPosTextCommand* SkDrawPosTextCommand::fromJSON(Json::Value& command, 
+                                                     UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     int count = (int) coords.size();
     SkPoint* points = (SkPoint*) sk_malloc_throw(count * sizeof(SkPoint));
     for (int i = 0; i < count; i++) {
         points[i] = SkPoint::Make(coords[i][0].asFloat(), coords[i][1].asFloat());
     }
     return new SkDrawPosTextCommand(text, strlen(text), points, paint);
 }
 
 SkDrawPosTextHCommand::SkDrawPosTextHCommand(const void* text, size_t byteLength,
@@ skipping 78 matching lines @@
     SkRect bounds = fBlob->bounds().makeOffset(fXPos, fYPos);
     xlate_and_scale_to_bounds(canvas, bounds);
 
     canvas->drawTextBlob(fBlob.get(), fXPos, fYPos, fPaint);
 
     canvas->restore();
 
     return true;
 }
 
-Json::Value SkDrawTextBlobCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawTextBlobCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value runs(Json::arrayValue);
     SkTextBlobRunIterator iter(fBlob.get());
     while (!iter.done()) {
         Json::Value run(Json::objectValue);
         Json::Value jsonPositions(Json::arrayValue);
         Json::Value jsonGlyphs(Json::arrayValue);
         const SkScalar* iterPositions = iter.pos();
         const uint16_t* iterGlyphs = iter.glyphs();
         for (uint32_t i = 0; i < iter.glyphCount(); i++) {
             switch (iter.positioning()) {
                 case SkTextBlob::kFull_Positioning:
                     jsonPositions.append(make_json_point(iterPositions[i * 2],
                                                          iterPositions[i * 2 + 1]));
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
                     jsonPositions.append(Json::Value(iterPositions[i]));
                     break;
                 case SkTextBlob::kDefault_Positioning:
                     break;
             }
             jsonGlyphs.append(Json::Value(iterGlyphs[i]));
         }
         if (iter.positioning() != SkTextBlob::kDefault_Positioning) {
             run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS] = jsonPositions;
         }
         run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS] = jsonGlyphs;
         SkPaint fontPaint;
         iter.applyFontToPaint(&fontPaint);
-        run[SKDEBUGCANVAS_ATTRIBUTE_FONT] = make_json_paint(fontPaint, SKDEBUGCANVAS_SEND_BINARIES);
+        run[SKDEBUGCANVAS_ATTRIBUTE_FONT] = make_json_paint(fontPaint, urlDataManager);
         run[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(iter.offset());
         runs.append(run);
         iter.next();
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_RUNS] = runs;
     result[SKDEBUGCANVAS_ATTRIBUTE_X] = Json::Value(fXPos);
     result[SKDEBUGCANVAS_ATTRIBUTE_Y] = Json::Value(fYPos);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command) {
+SkDrawTextBlobCommand* SkDrawTextBlobCommand::fromJSON(Json::Value& command, 
+                                                       UrlDataManager& urlDataManager) {
     SkTextBlobBuilder builder;
     Json::Value runs = command[SKDEBUGCANVAS_ATTRIBUTE_RUNS];
     for (Json::ArrayIndex i = 0 ; i < runs.size(); i++) {
         Json::Value run = runs[i];
         SkPaint font;
         font.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
-        extract_json_paint(run[SKDEBUGCANVAS_ATTRIBUTE_FONT], &font);
+        extract_json_paint(run[SKDEBUGCANVAS_ATTRIBUTE_FONT], urlDataManager, &font);
         Json::Value glyphs = run[SKDEBUGCANVAS_ATTRIBUTE_GLYPHS];
         int count = glyphs.size();
         Json::Value coords = run[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
         SkScalar x = coords[0].asFloat();
         SkScalar y = coords[1].asFloat();
         if (run.isMember(SKDEBUGCANVAS_ATTRIBUTE_POSITIONS)) {
             Json::Value positions = run[SKDEBUGCANVAS_ATTRIBUTE_POSITIONS];
             if (positions.size() > 0 && positions[0].isNumeric()) {
                 SkTextBlobBuilder::RunBuffer buffer = builder.allocRunPosH(font, count, y);
                 for (int j = 0; j < count; j++) {
@@ skipping 13 matching lines @@
         else {
             SkTextBlobBuilder::RunBuffer buffer = builder.allocRun(font, count, x, y);
             for (int j = 0; j < count; j++) {
                 buffer.glyphs[j] = glyphs[j].asUInt();
             }
         }
     }
     SkScalar x = command[SKDEBUGCANVAS_ATTRIBUTE_X].asFloat();
     SkScalar y = command[SKDEBUGCANVAS_ATTRIBUTE_Y].asFloat();
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawTextBlobCommand(builder.build(), x, y, paint);
 }
 
 SkDrawPatchCommand::SkDrawPatchCommand(const SkPoint cubics[12], const SkColor colors[4],
                                        const SkPoint texCoords[4], SkXfermode* xfermode,
                                        const SkPaint& paint)
     : INHERITED(kDrawPatch_OpType) {
     memcpy(fCubics, cubics, sizeof(fCubics));
     if (colors != nullptr) {
         memcpy(fColors, colors, sizeof(fColors));
@@ skipping 12 matching lines @@
     }
     fPaint = paint;
 
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawPatchCommand::execute(SkCanvas* canvas) const {
     canvas->drawPatch(fCubics, fColorsPtr, fTexCoordsPtr, fXfermode, fPaint);
 }
 
-Json::Value SkDrawPatchCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawPatchCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     Json::Value cubics = Json::Value(Json::arrayValue);
     for (int i = 0; i < 12; i++) {
         cubics.append(make_json_point(fCubics[i]));
     }
     result[SKDEBUGCANVAS_ATTRIBUTE_CUBICS] = cubics;
     if (fColorsPtr != nullptr) {
         Json::Value colors = Json::Value(Json::arrayValue);
         for (int i = 0; i < 4; i++) {
             colors.append(make_json_color(fColorsPtr[i]));
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_COLORS] = colors;
     }
     if (fTexCoordsPtr != nullptr) {
         Json::Value texCoords = Json::Value(Json::arrayValue);
         for (int i = 0; i < 4; i++) {
             texCoords.append(make_json_point(fTexCoords[i]));
         }
         result[SKDEBUGCANVAS_ATTRIBUTE_TEXTURECOORDS] = texCoords;
     }
     if (fXfermode.get() != nullptr) {
         Json::Value jsonXfermode;
-        flatten(fXfermode, &jsonXfermode, SKDEBUGCANVAS_SEND_BINARIES);
+        flatten(fXfermode, &jsonXfermode, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
     return result;
 }
 
-SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command) {
+SkDrawPatchCommand* SkDrawPatchCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     Json::Value jsonCubics = command[SKDEBUGCANVAS_ATTRIBUTE_CUBICS];
     SkPoint cubics[12];
     for (int i = 0; i < 12; i++) {
         cubics[i] = get_json_point(jsonCubics[i]);
     }
     SkColor* colorsPtr;
     SkColor colors[4];
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_COLORS)) {
         Json::Value jsonColors = command[SKDEBUGCANVAS_ATTRIBUTE_COLORS];
         for (int i = 0; i < 4; i++) {
@@ skipping 12 matching lines @@
             texCoords[i] = get_json_point(jsonTexCoords[i]);
         }
         texCoordsPtr = texCoords;
     }
     else {
         texCoordsPtr = nullptr;
     }
     SkAutoTUnref<SkXfermode> xfermode;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_XFERMODE)) {
         Json::Value jsonXfermode = command[SKDEBUGCANVAS_ATTRIBUTE_XFERMODE];
-        xfermode.reset((SkXfermode*) load_flattenable(jsonXfermode));
+        xfermode.reset((SkXfermode*) load_flattenable(jsonXfermode, urlDataManager));
     }
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawPatchCommand(cubics, colorsPtr, texCoordsPtr, xfermode, paint);
 }
 
 SkDrawRectCommand::SkDrawRectCommand(const SkRect& rect, const SkPaint& paint)
     : INHERITED(kDrawRect_OpType) {
     fRect = rect;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::RectToString(rect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawRectCommand::execute(SkCanvas* canvas) const {
     canvas->drawRect(fRect, fPaint);
 }
 
-Json::Value SkDrawRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rect(fRect);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command) {
+SkDrawRectCommand* SkDrawRectCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     SkRect coords;
     extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRectCommand(coords, paint);
 }
 
 SkDrawRRectCommand::SkDrawRRectCommand(const SkRRect& rrect, const SkPaint& paint)
     : INHERITED(kDrawRRect_OpType) {
     fRRect = rrect;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::RRectToString(rrect));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawRRectCommand::execute(SkCanvas* canvas) const {
     canvas->drawRRect(fRRect, fPaint);
 }
 
 bool SkDrawRRectCommand::render(SkCanvas* canvas) const {
     render_rrect(canvas, fRRect);
     return true;
 }
 
-Json::Value SkDrawRRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_rrect(fRRect);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command) {
+SkDrawRRectCommand* SkDrawRRectCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     SkRRect coords;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_COORDS], &coords);
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawRRectCommand(coords, paint);
 }
 
 SkDrawDRRectCommand::SkDrawDRRectCommand(const SkRRect& outer,
                                          const SkRRect& inner,
                                          const SkPaint& paint)
     : INHERITED(kDrawDRRect_OpType) {
     fOuter = outer;
     fInner = inner;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::RRectToString(outer));
     fInfo.push(SkObjectParser::RRectToString(inner));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawDRRectCommand::execute(SkCanvas* canvas) const {
     canvas->drawDRRect(fOuter, fInner, fPaint);
 }
 
 bool SkDrawDRRectCommand::render(SkCanvas* canvas) const {
     render_drrect(canvas, fOuter, fInner);
     return true;
 }
 
-Json::Value SkDrawDRRectCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawDRRectCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_OUTER] = make_json_rrect(fOuter);
     result[SKDEBUGCANVAS_ATTRIBUTE_INNER] = make_json_rrect(fInner);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command) {
+SkDrawDRRectCommand* SkDrawDRRectCommand::fromJSON(Json::Value& command, 
+                                                   UrlDataManager& urlDataManager) {
     SkRRect outer;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &outer);
     SkRRect inner;
     extract_json_rrect(command[SKDEBUGCANVAS_ATTRIBUTE_INNER], &inner);
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     return new SkDrawDRRectCommand(outer, inner, paint);
 }
 
 SkDrawTextCommand::SkDrawTextCommand(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                      const SkPaint& paint)
     : INHERITED(kDrawText_OpType) {
     fText = new char[byteLength];
     memcpy(fText, text, byteLength);
     fByteLength = byteLength;
     fX = x;
     fY = y;
     fPaint = paint;
 
     fInfo.push(SkObjectParser::TextToString(text, byteLength, paint.getTextEncoding()));
     fInfo.push(SkObjectParser::ScalarToString(x, "SkScalar x: "));
     fInfo.push(SkObjectParser::ScalarToString(y, "SkScalar y: "));
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawTextCommand::execute(SkCanvas* canvas) const {
     canvas->drawText(fText, fByteLength, fX, fY, fPaint);
 }
 
-Json::Value SkDrawTextCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawTextCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     result[SKDEBUGCANVAS_ATTRIBUTE_COORDS] = make_json_point(fX, fY);
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command) {
+SkDrawTextCommand* SkDrawTextCommand::fromJSON(Json::Value& command, 
+                                               UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     Json::Value coords = command[SKDEBUGCANVAS_ATTRIBUTE_COORDS];
     return new SkDrawTextCommand(text, strlen(text), coords[0].asFloat(), coords[1].asFloat(), 
                                  paint);
 }
 
 SkDrawTextOnPathCommand::SkDrawTextOnPathCommand(const void* text, size_t byteLength,
                                                  const SkPath& path, const SkMatrix* matrix,
                                                  const SkPaint& paint)
     : INHERITED(kDrawTextOnPath_OpType) {
     fText = new char[byteLength];
@@ skipping 14 matching lines @@
     }
     fInfo.push(SkObjectParser::PaintToString(paint));
 }
 
 void SkDrawTextOnPathCommand::execute(SkCanvas* canvas) const {
     canvas->drawTextOnPath(fText, fByteLength, fPath,
                            fMatrix.isIdentity() ? nullptr : &fMatrix,
                            fPaint);
 }
 
-Json::Value SkDrawTextOnPathCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkDrawTextOnPathCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_TEXT] = Json::Value((const char*) fText, 
                                                        ((const char*) fText) + fByteLength);
     Json::Value coords(Json::arrayValue);
     result[SKDEBUGCANVAS_ATTRIBUTE_PATH] = make_json_path(fPath);
     if (!fMatrix.isIdentity()) {
         result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = make_json_matrix(fMatrix);
     }
-    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, SKDEBUGCANVAS_SEND_BINARIES);
+    result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(fPaint, urlDataManager);
     return result;
 }
 
-SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command) {
+SkDrawTextOnPathCommand* SkDrawTextOnPathCommand::fromJSON(Json::Value& command, 
+                                                           UrlDataManager& urlDataManager) {
     const char* text = command[SKDEBUGCANVAS_ATTRIBUTE_TEXT].asCString();
     SkPaint paint;
-    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+    extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
     SkPath path;
     extract_json_path(command[SKDEBUGCANVAS_ATTRIBUTE_PATH], &path);
     SkMatrix* matrixPtr;
     SkMatrix matrix;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_MATRIX)) {
         extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
         matrixPtr = &matrix;
     }
     else {
         matrixPtr = nullptr;
@@ skipping 64 matching lines @@
 
 SkRestoreCommand::SkRestoreCommand()
     : INHERITED(kRestore_OpType) {
     fInfo.push(SkObjectParser::CustomTextToString("No Parameters"));
 }
 
 void SkRestoreCommand::execute(SkCanvas* canvas) const {
     canvas->restore();
 }
 
-SkRestoreCommand* SkRestoreCommand::fromJSON(Json::Value& command) {
+SkRestoreCommand* SkRestoreCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     return new SkRestoreCommand();
 }
 
 SkSaveCommand::SkSaveCommand()
     : INHERITED(kSave_OpType) {
 }
 
 void SkSaveCommand::execute(SkCanvas* canvas) const {
     canvas->save();
 }
 
-SkSaveCommand* SkSaveCommand::fromJSON(Json::Value& command) {
+SkSaveCommand* SkSaveCommand::fromJSON(Json::Value& command, UrlDataManager& urlDataManager) {
     return new SkSaveCommand();
 }
 
 SkSaveLayerCommand::SkSaveLayerCommand(const SkCanvas::SaveLayerRec& rec)
     : INHERITED(kSaveLayer_OpType) {
     if (rec.fBounds) {
         fBounds = *rec.fBounds;
     } else {
         fBounds.setEmpty();
     }
@@ skipping 31 matching lines @@
 void SkSaveLayerCommand::execute(SkCanvas* canvas) const {
     canvas->saveLayer(SkCanvas::SaveLayerRec(fBounds.isEmpty() ? nullptr : &fBounds,
                                              fPaintPtr,
                                              fSaveLayerFlags));
 }
 
 void SkSaveLayerCommand::vizExecute(SkCanvas* canvas) const {
     canvas->save();
 }
 
-Json::Value SkSaveLayerCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkSaveLayerCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     if (!fBounds.isEmpty()) {
         result[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS] = make_json_rect(fBounds);
     }
     if (fPaintPtr != nullptr) {
         result[SKDEBUGCANVAS_ATTRIBUTE_PAINT] = make_json_paint(*fPaintPtr, 
-                                                                SKDEBUGCANVAS_SEND_BINARIES);
+                                                                urlDataManager);
     }
     if (fBackdrop != nullptr) {
         Json::Value jsonBackdrop;
-        flatten(fBackdrop, &jsonBackdrop, SKDEBUGCANVAS_SEND_BINARIES);
+        flatten(fBackdrop, &jsonBackdrop, urlDataManager);
         result[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP] = jsonBackdrop;
     }
     if (fSaveLayerFlags != 0) {
         SkDebugf("unsupported: saveLayer flags\n");
         SkASSERT(false);
     }
     return result;
 }
 
-SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command) {
+SkSaveLayerCommand* SkSaveLayerCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     SkCanvas::SaveLayerRec rec;
     SkRect bounds;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BOUNDS)) {
         extract_json_rect(command[SKDEBUGCANVAS_ATTRIBUTE_BOUNDS], &bounds);
         rec.fBounds = &bounds;
     }
     SkPaint paint;
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_PAINT)) {
-        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], &paint);
+        extract_json_paint(command[SKDEBUGCANVAS_ATTRIBUTE_PAINT], urlDataManager, &paint);
         rec.fPaint = &paint;
     }
     if (command.isMember(SKDEBUGCANVAS_ATTRIBUTE_BACKDROP)) {
         Json::Value backdrop = command[SKDEBUGCANVAS_ATTRIBUTE_BACKDROP];
-        rec.fBackdrop = (SkImageFilter*) load_flattenable(backdrop);
+        rec.fBackdrop = (SkImageFilter*) load_flattenable(backdrop, urlDataManager);
     }
     SkSaveLayerCommand* result = new SkSaveLayerCommand(rec);
     if (rec.fBackdrop != nullptr) {
         rec.fBackdrop->unref();
     }
     return result;
 }
 
 SkSetMatrixCommand::SkSetMatrixCommand(const SkMatrix& matrix)
     : INHERITED(kSetMatrix_OpType) {
     fUserMatrix.reset();
     fMatrix = matrix;
     fInfo.push(SkObjectParser::MatrixToString(matrix));
 }
 
 void SkSetMatrixCommand::setUserMatrix(const SkMatrix& userMatrix) {
     fUserMatrix = userMatrix;
 }
 
 void SkSetMatrixCommand::execute(SkCanvas* canvas) const {
     SkMatrix temp = SkMatrix::Concat(fUserMatrix, fMatrix);
     canvas->setMatrix(temp);
 }
 
-Json::Value SkSetMatrixCommand::toJSON() const {
-    Json::Value result = INHERITED::toJSON();
+Json::Value SkSetMatrixCommand::toJSON(UrlDataManager& urlDataManager) const {
+    Json::Value result = INHERITED::toJSON(urlDataManager);
     result[SKDEBUGCANVAS_ATTRIBUTE_MATRIX] = make_json_matrix(fMatrix);
     return result;
 }
 
-SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command) {
+SkSetMatrixCommand* SkSetMatrixCommand::fromJSON(Json::Value& command, 
+                                                 UrlDataManager& urlDataManager) {
     SkMatrix matrix;
     extract_json_matrix(command[SKDEBUGCANVAS_ATTRIBUTE_MATRIX], &matrix);
     return new SkSetMatrixCommand(matrix);
 }