Move annotations to canvas virtual (patchset #8 id:140001 of https://codereview.chromium.org/174410…

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"
@@ skipping 101 matching lines @@
                 : fEncoder(encoder) {
                 fIDs.misc        = fEncoder->define(Misc::CreateFrom(paint));
                 fIDs.patheffect  = fEncoder->define(paint.getPathEffect());
                 fIDs.shader      = fEncoder->define(paint.getShader());
                 fIDs.xfermode    = fEncoder->define(paint.getXfermode());
                 fIDs.maskfilter  = fEncoder->define(paint.getMaskFilter());
                 fIDs.colorfilter = fEncoder->define(paint.getColorFilter());
                 fIDs.rasterizer  = fEncoder->define(paint.getRasterizer());
                 fIDs.looper      = fEncoder->define(paint.getLooper());
                 fIDs.imagefilter = fEncoder->define(paint.getImageFilter());
-                fIDs.annotation  = fEncoder->define(paint.getAnnotation());
             }
             ~AutoCommonIDs() {
                 if (fEncoder) {
                     fEncoder->undefine(fIDs.misc);
                     fEncoder->undefine(fIDs.patheffect);
                     fEncoder->undefine(fIDs.shader);
                     fEncoder->undefine(fIDs.xfermode);
                     fEncoder->undefine(fIDs.maskfilter);
                     fEncoder->undefine(fIDs.colorfilter);
                     fEncoder->undefine(fIDs.rasterizer);
                     fEncoder->undefine(fIDs.looper);
                     fEncoder->undefine(fIDs.imagefilter);
-                    fEncoder->undefine(fIDs.annotation);
                 }
             }
 
             AutoCommonIDs(AutoCommonIDs&& o) : fEncoder(o.fEncoder), fIDs(o.fIDs) {
                 o.fEncoder = nullptr;
             }
             AutoID& operator=(AutoID&&) = delete;
 
             operator Encoder::CommonIDs () const { return fIDs; }
 
@@ skipping 300 matching lines @@
         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);
             };
         }
 
         void applyCommon(const CommonIDs& common, SkPaint* paint) const {
             fMisc.find(common.misc).applyTo(paint);
             paint->setPathEffect (fPathEffect .find(common.patheffect));
             paint->setShader     (fShader     .find(common.shader));
             paint->setXfermode   (fXfermode   .find(common.xfermode));
             paint->setMaskFilter (fMaskFilter .find(common.maskfilter));
             paint->setColorFilter(fColorFilter.find(common.colorfilter));
             paint->setRasterizer (fRasterizer .find(common.rasterizer));
             paint->setLooper     (fDrawLooper .find(common.looper));
             paint->setImageFilter(fImageFilter.find(common.imagefilter));
-            paint->setAnnotation (fAnnotation .find(common.annotation));
         }
 
         void    save() override { fCanvas->save(); }
         void restore() override { fCanvas->restore(); }
         void saveLayer(ID bounds, CommonIDs common, SkCanvas::SaveLayerFlags flags) override {
             SkPaint paint;
             this->applyCommon(common, &paint);
             SkRect rect;
 
             fCanvas->saveLayer({ fPath.find(bounds).isRect(&rect) ? &rect : nullptr,
@@ skipping 102 matching lines @@
               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 {
@@ skipping 15 matching lines @@
             fStroke     .foreach(undef);
             fTextBlob   .foreach(undef);
             fPathEffect .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(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::SaveLayerFlags flags) override {
             fWrapped->saveLayer(bounds, common, flags);
         }
 
         void setMatrix(ID matrix) override { fWrapped->setMatrix(matrix); }
@@ skipping 49 matching lines @@
         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