Archive SkRemote-related code. I want to start fresh.
BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1774013002
Review URL: https://codereview.chromium.org/1774013002
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 6830cee..d70914d 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -775,8 +775,6 @@
VIA("sp", ViaSingletonPictures, wrapped);
VIA("tiles", ViaTiles, 256, 256, nullptr, wrapped);
VIA("tiles_rt", ViaTiles, 256, 256, new SkRTreeFactory, wrapped);
- VIA("remote", ViaRemote, false, wrapped);
- VIA("remote_cache", ViaRemote, true, wrapped);
VIA("mojo", ViaMojo, wrapped);
if (FLAGS_matrix.count() == 4) {
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index ead02c2..9e45ce9 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -24,7 +24,6 @@
#include "SkRandom.h"
#include "SkRecordDraw.h"
#include "SkRecorder.h"
-#include "SkRemote.h"
#include "SkSVGCanvas.h"
#include "SkStream.h"
#include "SkTLogic.h"
@@ -1164,18 +1163,6 @@
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-Error ViaRemote::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
- return draw_to_canvas(fSink, bitmap, stream, log, src.size(), [&](SkCanvas* target) {
- SkAutoTDelete<SkRemote::Encoder> decoder(SkRemote::NewDecoder(target));
- SkAutoTDelete<SkRemote::Encoder> cache(fCache ? SkRemote::NewCachingEncoder(decoder)
- : nullptr);
- SkAutoTDelete<SkCanvas> canvas(SkRemote::NewCanvas(cache ? cache : decoder));
- return src.draw(canvas);
- });
-}
-
-/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
-
Error ViaSerialization::draw(
const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
// Record our Src into a picture.
diff --git a/dm/DMSrcSink.h b/dm/DMSrcSink.h
index bbf47cf..638d138 100644
--- a/dm/DMSrcSink.h
+++ b/dm/DMSrcSink.h
@@ -310,14 +310,6 @@
const SkMatrix fMatrix;
};
-class ViaRemote : public Via {
-public:
- ViaRemote(bool cache, Sink* sink) : Via(sink), fCache(cache) {}
- Error draw(const Src&, SkBitmap*, SkWStream*, SkString*) const override;
-private:
- bool fCache;
-};
-
class ViaSerialization : public Via {
public:
explicit ViaSerialization(Sink* sink) : Via(sink) {}
diff --git a/gyp/core.gypi b/gyp/core.gypi
index 71a9d6f..548eeea 100644
--- a/gyp/core.gypi
+++ b/gyp/core.gypi
@@ -232,7 +232,6 @@
'<(skia_src_path)/core/SkRegion.cpp',
'<(skia_src_path)/core/SkRegionPriv.h',
'<(skia_src_path)/core/SkRegion_path.cpp',
- '<(skia_src_path)/core/SkRemote.cpp',
'<(skia_src_path)/core/SkResourceCache.cpp',
'<(skia_src_path)/core/SkRRect.cpp',
'<(skia_src_path)/core/SkRTree.h',
diff --git a/src/core/SkRemote.cpp b/src/core/SkRemote.cpp
deleted file mode 100644
index 9b0383d..0000000
--- a/src/core/SkRemote.cpp
+++ /dev/null
@@ -1,749 +0,0 @@
-/*
- * 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 "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(),
- };
- return misc;
- }
-
- void Misc::applyTo(SkPaint* paint) const {
- paint->setColor (fColor);
- paint->setFilterQuality(fFilterQuality);
- paint->setAntiAlias (fAntiAlias);
- paint->setDither (fDither);
- }
-
- static bool operator==(const Misc& a, const Misc& b) {
- return a.fColor == b.fColor
- && a.fFilterQuality == b.fFilterQuality
- && a.fAntiAlias == b.fAntiAlias
- && a.fDither == b.fDither;
- }
-
- // Misc carries 10 bytes of data in a 12 byte struct, so we need a custom hash.
- static_assert(sizeof(Misc) > offsetof(Misc, fDither) + sizeof(Misc().fDither), "");
- struct MiscHash {
- uint32_t operator()(const Misc& misc) {
- return SkChecksum::Murmur3(&misc, offsetof(Misc, fDither) + sizeof(Misc().fDither));
- }
- };
-
- Stroke Stroke::CreateFrom(const SkPaint& paint) {
- Stroke stroke = {
- paint.getStrokeWidth(),
- paint.getStrokeMiter(),
- paint.getStrokeCap(),
- paint.getStrokeJoin(),
- };
- return stroke;
- }
-
- void Stroke::applyTo(SkPaint* paint) const {
- paint->setStrokeWidth(fWidth);
- paint->setStrokeMiter(fMiter);
- paint->setStrokeCap (fCap);
- paint->setStrokeJoin (fJoin);
- }
-
- static bool operator==(const Stroke& a, const Stroke& b) {
- return a.fWidth == b.fWidth
- && a.fMiter == b.fMiter
- && a.fCap == b.fCap
- && a.fJoin == b.fJoin;
- }
-
- // The default SkGoodHash works fine for Stroke, as it's dense.
- static_assert(sizeof(Stroke) == offsetof(Stroke, fJoin) + sizeof(Stroke().fJoin), "");
-
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
-
- class Canvas final : public SkCanvas {
- public:
- explicit Canvas(Encoder* encoder)
- : SkCanvas(1,1)
- , fEncoder(encoder) {}
-
- private:
- // Calls Encoder::define() when created, Encoder::undefine() when destroyed.
- class AutoID : ::SkNoncopyable {
- public:
- template <typename T>
- explicit AutoID(Encoder* encoder, const T& val)
- : fEncoder(encoder)
- , fID(encoder->define(val)) {}
- ~AutoID() { if (fEncoder) fEncoder->undefine(fID); }
-
- AutoID(AutoID&& o) : fEncoder(o.fEncoder), fID(o.fID) {
- o.fEncoder = nullptr;
- }
- AutoID& operator=(AutoID&&) = delete;
-
- operator ID () const { return fID; }
-
- private:
- Encoder* fEncoder;
- const ID fID;
- };
-
- // Like AutoID, but for CommonIDs.
- class AutoCommonIDs : ::SkNoncopyable {
- public:
- explicit AutoCommonIDs(Encoder* encoder, const SkPaint& paint)
- : 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());
- }
- ~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);
- }
- }
-
- AutoCommonIDs(AutoCommonIDs&& o) : fEncoder(o.fEncoder), fIDs(o.fIDs) {
- o.fEncoder = nullptr;
- }
- AutoID& operator=(AutoID&&) = delete;
-
- operator Encoder::CommonIDs () const { return fIDs; }
-
- private:
- Encoder* fEncoder;
- Encoder::CommonIDs fIDs;
- };
-
- template <typename T>
- AutoID id(const T& val) { return AutoID(fEncoder, val); }
-
- AutoCommonIDs commonIDs(const SkPaint& paint) { return AutoCommonIDs(fEncoder, paint); }
-
- void willSave() override { fEncoder-> save(); }
- void didRestore() override { fEncoder->restore(); }
- SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec& rec) override {
- SkPath path;
- if (rec.fBounds) {
- path.addRect(*rec.fBounds);
- }
- const SkPaint defaultPaint;
- const SkPaint* paint = rec.fPaint;
- if (!paint) {
- paint = &defaultPaint;
- }
- fEncoder->saveLayer(this->id(path), this->commonIDs(*paint), rec.fSaveLayerFlags);
- return kNoLayer_SaveLayerStrategy;
- }
-
- void didConcat(const SkMatrix&) override { this->didSetMatrix(this->getTotalMatrix()); }
- void didSetMatrix(const SkMatrix& matrix) override {
- fEncoder->setMatrix(this->id(matrix));
- }
-
- void onDrawOval(const SkRect& oval, const SkPaint& paint) override {
- SkPath path;
- path.addOval(oval);
- this->onDrawPath(path, paint);
- }
-
- void onDrawRect(const SkRect& rect, const SkPaint& paint) override {
- SkPath path;
- path.addRect(rect);
- this->onDrawPath(path, paint);
- }
-
- void onDrawRRect(const SkRRect& rrect, const SkPaint& paint) override {
- SkPath path;
- path.addRRect(rrect);
- this->onDrawPath(path, paint);
- }
-
- void onDrawDRRect(const SkRRect& outside, const SkRRect& inside,
- const SkPaint& paint) override {
- SkPath path;
- path.addRRect(outside);
- path.addRRect(inside, SkPath::kCCW_Direction);
- this->onDrawPath(path, paint);
- }
-
- void onDrawPath(const SkPath& path, const SkPaint& paint) override {
- auto common = this->commonIDs(paint);
- auto p = this->id(path);
-
- if (paint.getStyle() == SkPaint::kFill_Style) {
- fEncoder->fillPath(p, common);
- } else {
- // TODO: handle kStrokeAndFill_Style
- fEncoder->strokePath(p, common, this->id(Stroke::CreateFrom(paint)));
- }
- }
-
- void onDrawPaint(const SkPaint& paint) override {
- SkPath path;
- path.setFillType(SkPath::kInverseWinding_FillType); // Either inverse FillType is fine.
- this->onDrawPath(path, paint);
- }
-
- void onDrawPoints(PointMode mode,
- size_t count,
- const SkPoint pts[],
- const SkPaint& paint) override {
- // TODO
- }
-
- void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override {
- // TODO
- this->INHERITED::onDrawDrawable(drawable, matrix);
- }
-
- void onDrawPicture(const SkPicture* pic,
- const SkMatrix* matrix,
- const SkPaint* paint) override {
- // TODO
- this->INHERITED::onDrawPicture(pic, matrix, paint);
- }
-
- void onDrawVertices(VertexMode vmode,
- int vertexCount,
- const SkPoint vertices[],
- const SkPoint texs[],
- const SkColor colors[],
- SkXfermode* xmode,
- const uint16_t indices[],
- int indexCount,
- const SkPaint& paint) override {
- // TODO
- }
-
- void onDrawPatch(const SkPoint cubics[12],
- const SkColor colors[4],
- const SkPoint texCoords[4],
- SkXfermode* xmode,
- const SkPaint& paint) override {
- // TODO
- }
-
- void onDrawAtlas(const SkImage* atlas,
- const SkRSXform xform[],
- const SkRect tex[],
- const SkColor colors[],
- int count,
- SkXfermode::Mode mode,
- const SkRect* cull,
- const SkPaint* paint) override {
- // TODO
- }
-
- void onDrawBitmap(const SkBitmap& bitmap,
- SkScalar left,
- SkScalar top,
- const SkPaint* paint) override {
- auto src = SkRect::MakeWH(bitmap.width(), bitmap.height()),
- dst = src.makeOffset(left, top);
- this->onDrawBitmapRect(bitmap, &src, dst, paint, kStrict_SrcRectConstraint);
- }
-
- void onDrawBitmapRect(const SkBitmap& bitmap,
- const SkRect* src,
- const SkRect& dst,
- const SkPaint* paint,
- SrcRectConstraint constraint) override {
- SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
- this->onDrawImageRect(image, src, dst, paint, constraint);
- }
-
- void onDrawImage(const SkImage* image,
- SkScalar left,
- SkScalar top,
- const SkPaint* paint) override {
- if (!image) {
- return;
- }
- auto src = SkRect::MakeWH(image->width(), image->height()),
- dst = src.makeOffset(left, top);
- this->onDrawImageRect(image, &src, dst, paint, kStrict_SrcRectConstraint);
- }
-
- void onDrawImageRect(const SkImage* image,
- const SkRect* src,
- const SkRect& dst,
- const SkPaint* paint,
- SrcRectConstraint constraint) override {
- // TODO: this is all a (likely buggy) hack to get images drawing quickly.
- if (!image) {
- return;
- }
-
- auto bounds = SkRect::MakeWH(image->width(), image->height());
- if (!src) {
- src = &bounds;
- }
- auto matrix = SkMatrix::MakeRectToRect(*src, dst, SkMatrix::kFill_ScaleToFit);
-
- SkAutoTUnref<SkImage> subset;
- if (src) {
- if (!bounds.intersect(*src)) {
- return;
- }
- subset.reset(image->newSubset(bounds.roundOut()));
- image = subset;
- }
-
- auto paintWithShader = paint ? *paint : SkPaint();
- SkAutoTUnref<SkShader> shader(
- image->newShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode, &matrix));
- paintWithShader.setShader(shader);
-
- this->onDrawRect(dst, paintWithShader);
- }
-
- void onDrawBitmapNine(const SkBitmap& bitmap,
- const SkIRect& center,
- const SkRect& dst,
- const SkPaint* paint) override {
- SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(bitmap));
- this->onDrawImageNine(image, center, dst, paint);
- }
-
- void onDrawImageNine(const SkImage* image,
- 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,
- const SkPoint pos[], const SkPaint& paint) override {
- // Text-as-paths is a temporary hack.
- // TODO: send SkTextBlobs and SkTypefaces
- SkPath path;
- paint.getPosTextPath(text, byteLength, pos, &path);
- this->onDrawPath(path, paint);
- }
-
- void onDrawPosTextH(const void* text, size_t byteLength,
- const SkScalar xpos[], SkScalar constY, const SkPaint& paint) override {
- size_t length = paint.countText(text, byteLength);
- SkAutoTArray<SkPoint> pos(length);
- for(size_t i = 0; i < length; ++i) {
- pos[i].set(xpos[i], constY);
- }
- this->onDrawPosText(text, byteLength, &pos[0], paint);
- }
-
- // All clip calls need to call their parent method or we'll not get any quick rejects.
- void onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
- this->INHERITED::onClipRect(rect, op, edgeStyle);
- SkPath path;
- path.addRect(rect);
- this->onClipPath(path, op, edgeStyle);
- }
-
- void onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
- this->INHERITED::onClipRRect(rrect, op, edgeStyle);
- SkPath path;
- path.addRRect(rrect);
- this->onClipPath(path, op, edgeStyle);
- }
-
- void onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) override {
- this->INHERITED::onClipPath(path, op, edgeStyle);
- fEncoder->clipPath(this->id(path), op, edgeStyle == kSoft_ClipEdgeStyle);
- }
-
- void onClipRegion(const SkRegion& region, SkRegion::Op op) override {
- this->INHERITED::onClipRegion(region, op);
- // TODO
- }
-
- Encoder* fEncoder;
- typedef SkCanvas INHERITED;
- };
-
- SkCanvas* NewCanvas(Encoder* encoder) { return new Canvas(encoder); }
-
- // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
-
- class Decoder final : public Encoder {
- public:
- explicit Decoder(SkCanvas* canvas) : fCanvas(canvas) {}
-
- 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(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);}
- #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);
- };
- }
-
- 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));
- }
-
- 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,
- &paint, flags });
- }
-
- void setMatrix(ID matrix) override { fCanvas->setMatrix(fMatrix.find(matrix)); }
-
- void clipPath(ID path, SkRegion::Op op, bool aa) override {
- fCanvas->clipPath(fPath.find(path), op, aa);
- }
- void fillPath(ID path, CommonIDs common) override {
- SkPaint paint;
- paint.setStyle(SkPaint::kFill_Style);
- 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);
- }
-
- void set(const ID& id, const T& val) {
- SkASSERT(id.type() == kType);
- fMap.set(id, val);
- }
-
- void remove(const ID& id) {
- SkASSERT(id.type() == kType);
- fMap.remove(id);
- }
-
- const T& find(const ID& id) const {
- SkASSERT(id.type() == kType);
- T* val = fMap.find(id);
- SkASSERT(val != nullptr);
- return *val;
- }
-
- private:
- SkTHashMap<ID, T> fMap;
- };
-
- // Maps ID -> T*, and keeps the T alive by reffing it.
- template <typename T, Type kType>
- class ReffedIDMap {
- public:
- ReffedIDMap() {}
- ~ReffedIDMap() {
- // A well-behaved client always cleans up its definitions.
- SkASSERT(fMap.count() == 0);
- }
-
- void set(const ID& id, T* val) {
- SkASSERT(id.type() == kType);
- fMap.set(id, SkSafeRef(val));
- }
-
- void remove(const ID& id) {
- SkASSERT(id.type() == kType);
- T** val = fMap.find(id);
- SkASSERT(val);
- SkSafeUnref(*val);
- fMap.remove(id);
- }
-
- T* find(const ID& id) const {
- SkASSERT(id.type() == kType);
- 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<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;
-
- 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);
- fShader .foreach(undef);
- fXfermode .foreach(undef);
- fMaskFilter .foreach(undef);
- fColorFilter.foreach(undef);
- fRasterizer .foreach(undef);
- fDrawLooper .foreach(undef);
- fImageFilter.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); }
-
- 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); }
-
- 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);
- fMap.set(SkSafeRef(key), id);
- }
-
- void remove(const T* key) {
- fMap.remove(key);
- SkSafeUnref(key);
- }
-
- const ID* find(const T* key) const {
- return fMap.find(key);
- }
-
- 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<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;
-
- Encoder* fWrapped;
- };
-
- Encoder* NewCachingEncoder(Encoder* wrapped) { return new CachingEncoder(wrapped); }
-
-} // namespace SkRemote
diff --git a/src/core/SkRemote.h b/src/core/SkRemote.h
deleted file mode 100644
index a8126d6..0000000
--- a/src/core/SkRemote.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkRemote_DEFINED
-#define SkRemote_DEFINED
-
-#include "SkPaint.h"
-#include "SkRegion.h"
-#include "SkRemote_protocol.h"
-#include "SkTypes.h"
-
-class SkCanvas;
-class SkMatrix;
-class SkPath;
-class SkShader;
-class SkTextBlob;
-class SkXfermode;
-
-// TODO: document
-
-namespace SkRemote {
-
- // General purpose identifier. Holds a Type and a 56-bit value.
- class ID {
- public:
- ID() {}
- ID(Type type, uint64_t val) {
- fVal = (uint64_t)type << 56 | val;
- SkASSERT(this->type() == type && this->val() == val);
- }
-
- Type type() const { return (Type)(fVal >> 56); }
- uint64_t val() const { return fVal & ~((uint64_t)0xFF << 56); }
-
- bool operator==(ID o) const { return fVal == o.fVal; }
-
- private:
- uint64_t fVal;
- };
-
- // Fields from SkPaint used by stroke, fill, and text draws.
- struct Misc {
- SkColor fColor;
- SkFilterQuality fFilterQuality;
- bool fAntiAlias, fDither;
-
- static Misc CreateFrom(const SkPaint&);
- void applyTo(SkPaint*) const;
- };
-
- // Fields from SkPaint used by stroke draws only.
- struct Stroke {
- SkScalar fWidth, fMiter;
- SkPaint::Cap fCap;
- SkPaint::Join fJoin;
-
- static Stroke CreateFrom(const SkPaint&);
- void applyTo(SkPaint*) const;
- };
-
- // TODO: document
- struct Encoder {
- virtual ~Encoder() {}
-
- virtual ID define(const SkMatrix&) = 0;
- virtual ID define(const Misc&) = 0;
- virtual ID define(const SkPath&) = 0;
- virtual ID define(const Stroke&) = 0;
- virtual ID define(const SkTextBlob*) = 0;
- virtual ID define(SkPathEffect*) = 0;
- virtual ID define(SkShader*) = 0;
- virtual ID define(SkXfermode*) = 0;
- virtual ID define(SkMaskFilter*) = 0;
- virtual ID define(SkColorFilter*) = 0;
- virtual ID define(SkRasterizer*) = 0;
- virtual ID define(SkDrawLooper*) = 0;
- virtual ID define(SkImageFilter*) = 0;
-
- virtual void undefine(ID) = 0;
-
- // TODO: do these all belong here in CommonIDs?
- struct CommonIDs {
- ID misc, patheffect, shader, xfermode, maskfilter,
- colorfilter, rasterizer, looper, imagefilter;
- };
-
- virtual void save() = 0;
- virtual void restore() = 0;
- virtual void saveLayer(ID bounds, CommonIDs, uint32_t saveLayerFlags) = 0;
-
- virtual void setMatrix(ID matrix) = 0;
-
- virtual void clipPath(ID path, SkRegion::Op, bool aa) = 0;
- virtual void fillPath(ID path, CommonIDs) = 0;
- virtual void strokePath(ID path, CommonIDs, ID stroke) = 0;
- virtual void fillText(ID text, SkPoint, CommonIDs) = 0;
- virtual void strokeText(ID text, SkPoint, CommonIDs, ID stroke) = 0;
- };
-
- // None of these factories take ownership of their arguments.
-
- // Returns a new SkCanvas that translates to the Encoder API.
- SkCanvas* NewCanvas(Encoder*);
- // Returns an Encoder that translates back to the SkCanvas API.
- Encoder* NewDecoder(SkCanvas*);
- // Wraps another Encoder with a cache. TODO: parameterize
- Encoder* NewCachingEncoder(Encoder*);
-
-} // namespace SkRemote
-
-#endif//SkRemote_DEFINED
diff --git a/src/core/SkRemote_protocol.h b/src/core/SkRemote_protocol.h
deleted file mode 100644
index 825a1c2..0000000
--- a/src/core/SkRemote_protocol.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkRemote_protocol_DEFINED
-#define SkRemote_protocol_DEFINED
-
-// ATTENTION! Changes to this file can break protocol compatibility. Tread carefully.
-
-namespace SkRemote {
-
- // It is safe to append to this enum without breaking protocol compatibility.
- // Resorting, deleting, or inserting anywhere but the end will break compatibility.
- enum class Type : uint8_t {
- kMatrix,
- kMisc,
- kPath,
- kStroke,
- kTextBlob,
- kPathEffect,
- kShader,
- kXfermode,
- kMaskFilter,
- kColorFilter,
- kRasterizer,
- kDrawLooper,
- kImageFilter,
- };
-
-} // namespace SkRemote
-
-#endif//SkRemote_protocol_DEFINED
diff --git a/tools/dm_flags.json b/tools/dm_flags.json
index 7af09f0..5999c1a 100644
--- a/tools/dm_flags.json
+++ b/tools/dm_flags.json
@@ -2149,8 +2149,6 @@
"srgb",
"sp-8888",
"2ndpic-8888",
- "remote-8888",
- "remote_cache-8888",
"msaa16",
"pdf",
"pdf_poppler",
@@ -2383,8 +2381,6 @@
"srgb",
"sp-8888",
"2ndpic-8888",
- "remote-8888",
- "remote_cache-8888",
"msaa16",
"pdf",
"pdf_poppler",
@@ -2614,8 +2610,6 @@
"srgb",
"sp-8888",
"2ndpic-8888",
- "remote-8888",
- "remote_cache-8888",
"msaa16",
"pdf",
"pdf_poppler",
diff --git a/tools/dm_flags.py b/tools/dm_flags.py
index 4d2adf7..a790184 100755
--- a/tools/dm_flags.py
+++ b/tools/dm_flags.py
@@ -34,7 +34,6 @@
if '-GCE-' in bot:
configs.extend(['f16', 'srgb']) # Gamma-correct formats.
configs.extend(['sp-8888', '2ndpic-8888']) # Test niche uses of SkPicture.
- configs.extend(['remote-8888', 'remote_cache-8888']) # Hacking, WIP.
if '-TSAN' not in bot:
if ('TegraK1' in bot or