Added JSON support for TextBlob

tools/json/SkJSONCanvas.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkJSONCanvas.h"
+#include "SkColorFilter.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkPaintDefaults.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "SkRRect.h"
+#include "SkTextBlob.h"
+#include "SkTextBlobRunIterator.h"
+#include "SkTypeface.h"
 #include "SkWriteBuffer.h"
 
 SkJSONCanvas::SkJSONCanvas(int width, int height, SkWStream& out, bool sendBinaries) 
     : INHERITED(width, height)
     , fOut(out)
     , fRoot(Json::objectValue)
     , fCommands(Json::arrayValue) 
     , fSendBinaries(sendBinaries) {
     fRoot[SKJSONCANVAS_VERSION] = Json::Value(1);
 }
@@ skipping 366 matching lines @@
             }
             case SkPaint::kRight_Align: {
                 (*target)[SKJSONCANVAS_ATTRIBUTE_TEXTALIGN] = SKJSONCANVAS_ALIGN_RIGHT;
                 break;
             }
             default: SkASSERT(false);
         }
     }
 }
 
+static void apply_paint_typeface(const SkPaint& paint, Json::Value* target, 
+                                 bool sendBinaries) {
+    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[SKJSONCANVAS_ATTRIBUTE_BYTES] = bytes;
+            free(data);
+            (*target)[SKJSONCANVAS_ATTRIBUTE_TYPEFACE] = jsonTypeface;
+        }
+    }
+}
+
 static void apply_paint_shader(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
     SkFlattenable* shader = paint.getShader();
     if (shader != nullptr) {
         Json::Value jsonShader;
         flatten(shader, &jsonShader, sendBinaries);
         (*target)[SKJSONCANVAS_ATTRIBUTE_SHADER] = jsonShader;
     }
 }
 
 static void apply_paint_xfermode(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
     SkFlattenable* xfermode = paint.getXfermode();
     if (xfermode != nullptr) {
         Json::Value jsonXfermode;
         flatten(xfermode, &jsonXfermode, sendBinaries);
         (*target)[SKJSONCANVAS_ATTRIBUTE_XFERMODE] = jsonXfermode;
     }
 }
 
 static void apply_paint_imagefilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
     SkFlattenable* imageFilter = paint.getImageFilter();
     if (imageFilter != nullptr) {
         Json::Value jsonImageFilter;
         flatten(imageFilter, &jsonImageFilter, sendBinaries);
         (*target)[SKJSONCANVAS_ATTRIBUTE_IMAGEFILTER] = jsonImageFilter;
     }
 }
 
+static void apply_paint_colorfilter(const SkPaint& paint, Json::Value* target, bool sendBinaries) {
+    SkFlattenable* colorFilter = paint.getColorFilter();
+    if (colorFilter != nullptr) {
+        Json::Value jsonColorFilter;
+        flatten(colorFilter, &jsonColorFilter, sendBinaries);
+        (*target)[SKJSONCANVAS_ATTRIBUTE_COLORFILTER] = jsonColorFilter;
+    }
+}
+
 Json::Value SkJSONCanvas::makePaint(const SkPaint& paint) {
     Json::Value result(Json::objectValue);
     store_scalar(&result, SKJSONCANVAS_ATTRIBUTE_STROKEWIDTH, paint.getStrokeWidth(), 0.0f);
     store_scalar(&result, SKJSONCANVAS_ATTRIBUTE_STROKEMITER, paint.getStrokeMiter(), 
                  SkPaintDefaults_MiterLimit);
     store_bool(&result, SKJSONCANVAS_ATTRIBUTE_ANTIALIAS, paint.isAntiAlias(), false);
     store_scalar(&result, SKJSONCANVAS_ATTRIBUTE_TEXTSIZE, paint.getTextSize(), 
                  SkPaintDefaults_TextSize);
     store_scalar(&result, SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextScaleX(), SK_Scalar1);
     store_scalar(&result, SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX, paint.getTextSkewX(), 0.0f);
     apply_paint_color(paint, &result);
     apply_paint_style(paint, &result);
     apply_paint_cap(paint, &result);
     apply_paint_textalign(paint, &result);
     apply_paint_patheffect(paint, &result, fSendBinaries);
     apply_paint_maskfilter(paint, &result, fSendBinaries);
     apply_paint_shader(paint, &result, fSendBinaries);
     apply_paint_xfermode(paint, &result, fSendBinaries);
     apply_paint_imagefilter(paint, &result, fSendBinaries);
+    apply_paint_colorfilter(paint, &result, fSendBinaries);
+    apply_paint_typeface(paint, &result, fSendBinaries);
     return result;
 }
 
 Json::Value SkJSONCanvas::MakeIRect(const SkIRect& rect) {
     Json::Value result(Json::arrayValue);
     result.append(Json::Value(rect.left()));
     result.append(Json::Value(rect.top()));
     result.append(Json::Value(rect.right()));
     result.append(Json::Value(rect.bottom()));
     return result;
@@ skipping 292 matching lines @@
     command[SKJSONCANVAS_ATTRIBUTE_PATH] = this->makePath(path);
     if (matrix != nullptr) {
         command[SKJSONCANVAS_ATTRIBUTE_MATRIX] = this->MakeMatrix(*matrix);
     }
     command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                   const SkPaint& paint) {
-    SkDebugf("unsupported: drawTextBlob\n");
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_TEXTBLOB);
+    Json::Value runs(Json::arrayValue);
+    SkTextBlobRunIterator iter(blob);
+    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(this->makePoint(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[SKJSONCANVAS_ATTRIBUTE_POSITIONS] = jsonPositions;
+        }
+        run[SKJSONCANVAS_ATTRIBUTE_GLYPHS] = jsonGlyphs;
+        SkPaint fontPaint;
+        iter.applyFontToPaint(&fontPaint);
+        run[SKJSONCANVAS_ATTRIBUTE_FONT] = this->makePaint(fontPaint);
+        run[SKJSONCANVAS_ATTRIBUTE_COORDS] = this->makePoint(iter.offset());
+        runs.append(run);
+        iter.next();
+    }
+    command[SKJSONCANVAS_ATTRIBUTE_RUNS] = runs;
+    command[SKJSONCANVAS_ATTRIBUTE_X] = Json::Value(x);
+    command[SKJSONCANVAS_ATTRIBUTE_Y] = Json::Value(y);
+    command[SKJSONCANVAS_ATTRIBUTE_PAINT] = this->makePaint(paint);
     fCommands.append(command);
 }
 
 void SkJSONCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                                const SkPoint texCoords[4], SkXfermode* xmode, 
                                const SkPaint& paint) {
     SkDebugf("unsupported: drawPatch\n");
     Json::Value command(Json::objectValue);
     command[SKJSONCANVAS_COMMAND] = Json::Value(SKJSONCANVAS_COMMAND_PATCH);
     fCommands.append(command);
@@ skipping 66 matching lines @@
         Json::Value backdrop;
         flatten(rec.fBackdrop, &backdrop, fSendBinaries);
         command[SKJSONCANVAS_ATTRIBUTE_BACKDROP] = backdrop;
     }
     if (rec.fSaveLayerFlags != 0) {
         SkDebugf("unsupported: saveLayer flags\n");
     }
     fCommands.append(command);
     return this->INHERITED::getSaveLayerStrategy(rec);
 }