SkRecord: text blobs

src/core/SkRemote.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAnnotation.h"
 #include "SkCanvas.h"
 #include "SkColorFilter.h"
 #include "SkDrawLooper.h"
 #include "SkImage.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkNinePatchIter.h"
 #include "SkPath.h"
 #include "SkPathEffect.h"
 #include "SkRasterizer.h"
 #include "SkRect.h"
 #include "SkRemote.h"
 #include "SkShader.h"
 #include "SkTHash.h"
+#include "SkTextBlob.h"
 
 namespace SkRemote {
 
     Misc Misc::CreateFrom(const SkPaint& paint) {
         Misc misc = {
             paint.getColor(),
             paint.getFilterQuality(),
             paint.isAntiAlias(),
             paint.isDither(),
         };
@@ skipping 318 matching lines @@
                              const SkIRect& center,
                              const SkRect& dst,
                              const SkPaint* paint) override {
             SkNinePatchIter iter(image->width(), image->height(), center, dst);
             SkRect s,d;
             while (iter.next(&s, &d)) {
                 this->onDrawImageRect(image, &s, d, paint, kStrict_SrcRectConstraint);
             }
         }
 
+        void onDrawTextBlob(const SkTextBlob* text,
+                            SkScalar x,
+                            SkScalar y,
+                            const SkPaint& paint) override {
+            SkPoint offset{x,y};
+            auto t = this->id(text);
+            auto common = this->commonIDs(paint);
+
+            if (paint.getStyle() == SkPaint::kFill_Style) {
+                fEncoder->fillText(t, offset, common);
+            } else {
+                // TODO: handle kStrokeAndFill_Style
+                fEncoder->strokeText(t, offset, common, this->id(Stroke::CreateFrom(paint)));
+            }
+        }
+
         void onDrawText(const void* text, size_t byteLength,
                         SkScalar x, SkScalar y, const SkPaint& paint) override {
             // Text-as-paths is a temporary hack.
             // TODO: send SkTextBlobs and SkTypefaces
             SkPath path;
             paint.getTextPath(text, byteLength, x, y, &path);
             this->onDrawPath(path, paint);
         }
 
         void onDrawPosText(const void* text, size_t byteLength,
@@ skipping 54 matching lines @@
 
     private:
         template <typename Map, typename T>
         ID define(Type type, Map* map, const T& val) {
             ID id(type, fNextID++);
             map->set(id, val);
             return id;
         }
 
     #define O override
-        ID define(const SkMatrix& v) O {return this->define(Type::kMatrix,      &fMatrix,      v);}
-        ID define(const Misc&     v) O {return this->define(Type::kMisc,        &fMisc,        v);}
-        ID define(const SkPath&   v) O {return this->define(Type::kPath,        &fPath,        v);}
-        ID define(const Stroke&   v) O {return this->define(Type::kStroke,      &fStroke,      v);}
-        ID define(SkPathEffect*   v) O {return this->define(Type::kPathEffect,  &fPathEffect,  v);}
-        ID define(SkShader*       v) O {return this->define(Type::kShader,      &fShader,      v);}
-        ID define(SkXfermode*     v) O {return this->define(Type::kXfermode,    &fXfermode,    v);}
-        ID define(SkMaskFilter*   v) O {return this->define(Type::kMaskFilter,  &fMaskFilter,  v);}
-        ID define(SkColorFilter*  v) O {return this->define(Type::kColorFilter, &fColorFilter, v);}
-        ID define(SkRasterizer*   v) O {return this->define(Type::kRasterizer,  &fRasterizer,  v);}
-        ID define(SkDrawLooper*   v) O {return this->define(Type::kDrawLooper,  &fDrawLooper,  v);}
-        ID define(SkImageFilter*  v) O {return this->define(Type::kImageFilter, &fImageFilter, v);}
-        ID define(SkAnnotation*   v) O {return this->define(Type::kAnnotation,  &fAnnotation,  v);}
+        ID define(const SkMatrix&   v)O{return this->define(Type::kMatrix,      &fMatrix,      v);}
+        ID define(const Misc&       v)O{return this->define(Type::kMisc,        &fMisc,        v);}
+        ID define(const SkPath&     v)O{return this->define(Type::kPath,        &fPath,        v);}
+        ID define(const Stroke&     v)O{return this->define(Type::kStroke,      &fStroke,      v);}
+        ID define(const SkTextBlob* v)O{return this->define(Type::kTextBlob,    &fTextBlob,    v);}
+        ID define(SkPathEffect*     v)O{return this->define(Type::kPathEffect,  &fPathEffect,  v);}
+        ID define(SkShader*         v)O{return this->define(Type::kShader,      &fShader,      v);}
+        ID define(SkXfermode*       v)O{return this->define(Type::kXfermode,    &fXfermode,    v);}
+        ID define(SkMaskFilter*     v)O{return this->define(Type::kMaskFilter,  &fMaskFilter,  v);}
+        ID define(SkColorFilter*    v)O{return this->define(Type::kColorFilter, &fColorFilter, v);}
+        ID define(SkRasterizer*     v)O{return this->define(Type::kRasterizer,  &fRasterizer,  v);}
+        ID define(SkDrawLooper*     v)O{return this->define(Type::kDrawLooper,  &fDrawLooper,  v);}
+        ID define(SkImageFilter*    v)O{return this->define(Type::kImageFilter, &fImageFilter, v);}
+        ID define(SkAnnotation*     v)O{return this->define(Type::kAnnotation,  &fAnnotation,  v);}
     #undef O
 
 
         void undefine(ID id) override {
             switch(id.type()) {
                 case Type::kMatrix:      return fMatrix     .remove(id);
                 case Type::kMisc:        return fMisc       .remove(id);
                 case Type::kPath:        return fPath       .remove(id);
                 case Type::kStroke:      return fStroke     .remove(id);
+                case Type::kTextBlob:    return fTextBlob   .remove(id);
                 case Type::kPathEffect:  return fPathEffect .remove(id);
                 case Type::kShader:      return fShader     .remove(id);
                 case Type::kXfermode:    return fXfermode   .remove(id);
                 case Type::kMaskFilter:  return fMaskFilter .remove(id);
                 case Type::kColorFilter: return fColorFilter.remove(id);
                 case Type::kRasterizer:  return fRasterizer .remove(id);
                 case Type::kDrawLooper:  return fDrawLooper .remove(id);
                 case Type::kImageFilter: return fImageFilter.remove(id);
                 case Type::kAnnotation:  return fAnnotation .remove(id);
             };
@@ skipping 32 matching lines @@
             this->applyCommon(common, &paint);
             fCanvas->drawPath(fPath.find(path), paint);
         }
         void strokePath(ID path, CommonIDs common, ID stroke) override {
             SkPaint paint;
             paint.setStyle(SkPaint::kStroke_Style);
             this->applyCommon(common, &paint);
             fStroke.find(stroke).applyTo(&paint);
             fCanvas->drawPath(fPath.find(path), paint);
         }
+        void fillText(ID text, SkPoint offset, CommonIDs common) override {
+            SkPaint paint;
+            paint.setStyle(SkPaint::kFill_Style);
+            this->applyCommon(common, &paint);
+            fCanvas->drawTextBlob(fTextBlob.find(text), offset.x(), offset.y(), paint);
+        }
+        void strokeText(ID text, SkPoint offset, CommonIDs common, ID stroke) override {
+            SkPaint paint;
+            this->applyCommon(common, &paint);
+            fStroke.find(stroke).applyTo(&paint);
+            fCanvas->drawTextBlob(fTextBlob.find(text), offset.x(), offset.y(), paint);
+        }
 
         // Maps ID -> T.
         template <typename T, Type kType>
         class IDMap {
         public:
             ~IDMap() {
                 // A well-behaved client always cleans up its definitions.
                 SkASSERT(fMap.count() == 0);
             }
 
@@ skipping 46 matching lines @@
                 T** val = fMap.find(id);
                 SkASSERT(val);
                 return *val;
             }
 
         private:
             SkTHashMap<ID, T*> fMap;
         };
 
 
-              IDMap<SkMatrix     , Type::kMatrix     > fMatrix;
-              IDMap<Misc         , Type::kMisc       > fMisc;
-              IDMap<SkPath       , Type::kPath       > fPath;
-              IDMap<Stroke       , Type::kStroke     > fStroke;
-        ReffedIDMap<SkPathEffect , Type::kPathEffect > fPathEffect;
-        ReffedIDMap<SkShader     , Type::kShader     > fShader;
-        ReffedIDMap<SkXfermode   , Type::kXfermode   > fXfermode;
-        ReffedIDMap<SkMaskFilter , Type::kMaskFilter > fMaskFilter;
-        ReffedIDMap<SkColorFilter, Type::kColorFilter> fColorFilter;
-        ReffedIDMap<SkRasterizer , Type::kRasterizer > fRasterizer;
-        ReffedIDMap<SkDrawLooper , Type::kDrawLooper > fDrawLooper;
-        ReffedIDMap<SkImageFilter, Type::kImageFilter> fImageFilter;
-        ReffedIDMap<SkAnnotation , Type::kAnnotation > fAnnotation;
+              IDMap<SkMatrix        , Type::kMatrix     > fMatrix;
+              IDMap<Misc            , Type::kMisc       > fMisc;
+              IDMap<SkPath          , Type::kPath       > fPath;
+              IDMap<Stroke          , Type::kStroke     > fStroke;
+        ReffedIDMap<const SkTextBlob, Type::kTextBlob   > fTextBlob;
+        ReffedIDMap<SkPathEffect    , Type::kPathEffect > fPathEffect;
+        ReffedIDMap<SkShader        , Type::kShader     > fShader;
+        ReffedIDMap<SkXfermode      , Type::kXfermode   > fXfermode;
+        ReffedIDMap<SkMaskFilter    , Type::kMaskFilter > fMaskFilter;
+        ReffedIDMap<SkColorFilter   , Type::kColorFilter> fColorFilter;
+        ReffedIDMap<SkRasterizer    , Type::kRasterizer > fRasterizer;
+        ReffedIDMap<SkDrawLooper    , Type::kDrawLooper > fDrawLooper;
+        ReffedIDMap<SkImageFilter   , Type::kImageFilter> fImageFilter;
+        ReffedIDMap<SkAnnotation    , Type::kAnnotation > fAnnotation;
 
         SkCanvas* fCanvas;
         uint64_t fNextID = 0;
     };
 
     Encoder* NewDecoder(SkCanvas* canvas) { return new Decoder(canvas); }
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
 
     class CachingEncoder final : public Encoder {
     public:
         explicit CachingEncoder(Encoder* wrapped) : fWrapped(wrapped) {}
 
     private:
         struct Undef {
             Encoder* fEncoder;
             template <typename T>
             void operator()(const T&, ID* id) const { fEncoder->undefine(*id); }
         };
 
         ~CachingEncoder() override {
             Undef undef{fWrapped};
             fMatrix     .foreach(undef);
             fMisc       .foreach(undef);
             fPath       .foreach(undef);
+            fStroke     .foreach(undef);
+            fTextBlob   .foreach(undef);
             fPathEffect .foreach(undef);
-            fStroke     .foreach(undef);
             fShader     .foreach(undef);
             fXfermode   .foreach(undef);
             fMaskFilter .foreach(undef);
             fColorFilter.foreach(undef);
             fRasterizer .foreach(undef);
             fDrawLooper .foreach(undef);
             fImageFilter.foreach(undef);
             fAnnotation .foreach(undef);
         }
 
         template <typename Map, typename T>
         ID define(Map* map, const T& v) {
             if (const ID* id = map->find(v)) {
                 return *id;
             }
             ID id = fWrapped->define(v);
             map->set(v, id);
             return id;
         }
 
-        ID define(const SkMatrix& v) override { return this->define(&fMatrix     , v); }
-        ID define(const Misc&     v) override { return this->define(&fMisc       , v); }
-        ID define(const SkPath&   v) override { return this->define(&fPath       , v); }
-        ID define(const Stroke&   v) override { return this->define(&fStroke     , v); }
-        ID define(SkPathEffect*   v) override { return this->define(&fPathEffect , v); }
-        ID define(SkShader*       v) override { return this->define(&fShader     , v); }
-        ID define(SkXfermode*     v) override { return this->define(&fXfermode   , v); }
-        ID define(SkMaskFilter*   v) override { return this->define(&fMaskFilter , v); }
-        ID define(SkColorFilter*  v) override { return this->define(&fColorFilter, v); }
-        ID define(SkRasterizer*   v) override { return this->define(&fRasterizer , v); }
-        ID define(SkDrawLooper*   v) override { return this->define(&fDrawLooper , v); }
-        ID define(SkImageFilter*  v) override { return this->define(&fImageFilter, v); }
-        ID define(SkAnnotation*   v) override { return this->define(&fAnnotation , v); }
+        ID define(const SkMatrix&   v) override { return this->define(&fMatrix     , v); }
+        ID define(const Misc&       v) override { return this->define(&fMisc       , v); }
+        ID define(const SkPath&     v) override { return this->define(&fPath       , v); }
+        ID define(const Stroke&     v) override { return this->define(&fStroke     , v); }
+        ID define(const SkTextBlob* v) override { return this->define(&fTextBlob   , v); }
+        ID define(SkPathEffect*     v) override { return this->define(&fPathEffect , v); }
+        ID define(SkShader*         v) override { return this->define(&fShader     , v); }
+        ID define(SkXfermode*       v) override { return this->define(&fXfermode   , v); }
+        ID define(SkMaskFilter*     v) override { return this->define(&fMaskFilter , v); }
+        ID define(SkColorFilter*    v) override { return this->define(&fColorFilter, v); }
+        ID define(SkRasterizer*     v) override { return this->define(&fRasterizer , v); }
+        ID define(SkDrawLooper*     v) override { return this->define(&fDrawLooper , v); }
+        ID define(SkImageFilter*    v) override { return this->define(&fImageFilter, v); }
+        ID define(SkAnnotation*     v) override { return this->define(&fAnnotation , v); }
 
         void undefine(ID) override {}
 
         void    save() override { fWrapped->   save(); }
         void restore() override { fWrapped->restore(); }
         void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveFlags flags) override {
             fWrapped->saveLayer(bounds, common, flags);
         }
 
         void setMatrix(ID matrix) override { fWrapped->setMatrix(matrix); }
 
         void clipPath(ID path, SkRegion::Op op, bool aa) override {
             fWrapped->clipPath(path, op, aa);
         }
         void fillPath(ID path, CommonIDs common) override {
             fWrapped->fillPath(path, common);
         }
         void strokePath(ID path, CommonIDs common, ID stroke) override {
             fWrapped->strokePath(path, common, stroke);
         }
+        void fillText(ID text, SkPoint offset, CommonIDs common) override {
+            fWrapped->fillText(text, offset, common);
+        }
+        void strokeText(ID text, SkPoint offset, CommonIDs common, ID stroke) override {
+            fWrapped->strokeText(text, offset, common, stroke);
+        }
 
         // Maps const T* -> ID, and refs the key.
         template <typename T, Type kType>
         class RefKeyMap {
         public:
             RefKeyMap() {}
             ~RefKeyMap() { fMap.foreach([](const T* key, ID*) { SkSafeUnref(key); }); }
 
             void set(const T* key, ID id) {
                 SkASSERT(id.type() == kType);
@@ skipping 10 matching lines @@
             }
 
             template <typename Fn>
             void foreach(const Fn& fn) {
                 fMap.foreach(fn);
             }
         private:
             SkTHashMap<const T*, ID> fMap;
         };
 
-        SkTHashMap<SkMatrix, ID>                     fMatrix;
-        SkTHashMap<Misc, ID, MiscHash>               fMisc;
-        SkTHashMap<SkPath, ID>                       fPath;
-        SkTHashMap<Stroke, ID>                       fStroke;
-        RefKeyMap<SkPathEffect , Type::kPathEffect > fPathEffect;
-        RefKeyMap<SkShader     , Type::kShader     > fShader;
-        RefKeyMap<SkXfermode   , Type::kXfermode   > fXfermode;
-        RefKeyMap<SkMaskFilter , Type::kMaskFilter > fMaskFilter;
-        RefKeyMap<SkColorFilter, Type::kColorFilter> fColorFilter;
-        RefKeyMap<SkRasterizer , Type::kRasterizer > fRasterizer;
-        RefKeyMap<SkDrawLooper , Type::kDrawLooper > fDrawLooper;
-        RefKeyMap<SkImageFilter, Type::kImageFilter> fImageFilter;
-        RefKeyMap<SkAnnotation , Type::kAnnotation > fAnnotation;
+        SkTHashMap<SkMatrix, ID>                        fMatrix;
+        SkTHashMap<Misc, ID, MiscHash>                  fMisc;
+        SkTHashMap<SkPath, ID>                          fPath;
+        SkTHashMap<Stroke, ID>                          fStroke;
+        RefKeyMap<const SkTextBlob, Type::kTextBlob   > fTextBlob;
+        RefKeyMap<SkPathEffect    , Type::kPathEffect > fPathEffect;
+        RefKeyMap<SkShader        , Type::kShader     > fShader;
+        RefKeyMap<SkXfermode      , Type::kXfermode   > fXfermode;
+        RefKeyMap<SkMaskFilter    , Type::kMaskFilter > fMaskFilter;
+        RefKeyMap<SkColorFilter   , Type::kColorFilter> fColorFilter;
+        RefKeyMap<SkRasterizer    , Type::kRasterizer > fRasterizer;
+        RefKeyMap<SkDrawLooper    , Type::kDrawLooper > fDrawLooper;
+        RefKeyMap<SkImageFilter   , Type::kImageFilter> fImageFilter;
+        RefKeyMap<SkAnnotation    , Type::kAnnotation > fAnnotation;
 
         Encoder* fWrapped;
     };
 
     Encoder* NewCachingEncoder(Encoder* wrapped) { return new CachingEncoder(wrapped); }
 
 } // namespace SkRemote