src/core/SkRemote.cpp - skia - Git at Google

 /*
  * 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 "SkPath.h"
 #include "SkRect.h"
 #include "SkRemote.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 LookupScope {
     public:
         LookupScope(Cache* cache, Encoder* encoder) : fCache(cache), fEncoder(encoder) {}
         ~LookupScope() { for (ID id : fToUndefine) { fEncoder->undefine(id); } }
         void undefineWhenDone(ID id) { fToUndefine.push_back(id); }

         template <typename T>
         ID lookup(const T& val) {
             ID id;
             if (!fCache->lookup(val, &id, this)) {
                 fEncoder->define(id, val);
             }
             return id;
         }

     private:
         Cache*   fCache;
         Encoder* fEncoder;
         SkSTArray<4, ID> fToUndefine;
     };


     Cache* Cache::CreateNeverCache() {
         struct NeverCache final : public Cache {
             NeverCache()
                 : fNextMatrix  (Type::kMatrix)
                 , fNextMisc    (Type::kMisc)
                 , fNextPath    (Type::kPath)
                 , fNextStroke  (Type::kStroke)
                 , fNextShader  (Type::kShader)
                 , fNextXfermode(Type::kXfermode)
             {}
             void cleanup(Encoder*) override {}

             static bool Helper(ID* next, ID* id, LookupScope* ls) {
                 *id = ++(*next);
                 ls->undefineWhenDone(*id);
                 return false;
             }

             bool lookup(const SkMatrix&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextMatrix, id, ls);
             }
             bool lookup(const Misc&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextMisc, id, ls);
             }
             bool lookup(const SkPath&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextPath, id, ls);
             }
             bool lookup(const Stroke&, ID* id, LookupScope* ls) override {
                 return Helper(&fNextStroke, id, ls);
             }
             bool lookup(const SkShader* shader, ID* id, LookupScope* ls) override {
                 if (!shader) {
                     *id = ID(Type::kShader);
                     return true;  // Null IDs are always defined.
                 }
                 return Helper(&fNextShader, id, ls);
             }
             bool lookup(const SkXfermode* xfermode, ID* id, LookupScope* ls) override {
                 if (!xfermode) {
                     *id = ID(Type::kXfermode);
                     return true;  // Null IDs are always defined.
                 }
                 return Helper(&fNextXfermode, id, ls);
             }

             ID fNextMatrix,
                fNextMisc,
                fNextPath,
                fNextStroke,
                fNextShader,
                fNextXfermode;
         };
         return new NeverCache;
     }

     // These can't be declared locally inside AlwaysCache because of the templating.  :(
     namespace {
         template <typename T, typename Map>
         static bool always_cache_lookup(const T& val, Map* map, ID* next, ID* id) {
             if (const ID* found = map->find(val)) {
                 *id = *found;
                 return true;
             }
             *id = ++(*next);
             map->set(val, *id);
             return false;
         }

         struct Undefiner {
             Encoder* fEncoder;

             template <typename T>
             void operator()(const T&, ID* id) const { fEncoder->undefine(*id); }
         };

         // Maps const T* -> ID, and refs the key.  nullptr always maps to ID(kType).
         template <typename T, Type kType>
         class RefKeyMap {
         public:
             RefKeyMap() {}
             ~RefKeyMap() { fMap.foreach([](const T* key, ID*) { key->unref(); }); }

             void set(const T* key, const ID& id) {
                 SkASSERT(key && id.type() == kType);
                 fMap.set(SkRef(key), id);
             }

             void remove(const T* key) {
                 SkASSERT(key);
                 fMap.remove(key);
                 key->unref();
             }

             const ID* find(const T* key) const {
                 static const ID nullID(kType);
                 return key ? fMap.find(key) : &nullID;
             }

             template <typename Fn>
             void foreach(const Fn& fn) { fMap.foreach(fn); }
         private:
             SkTHashMap<const T*, ID> fMap;
         };
     } // namespace

     Cache* Cache::CreateAlwaysCache() {
         struct AlwaysCache final : public Cache {
             AlwaysCache()
                 : fNextMatrix  (Type::kMatrix)
                 , fNextMisc    (Type::kMisc)
                 , fNextPath    (Type::kPath)
                 , fNextStroke  (Type::kStroke)
                 , fNextShader  (Type::kShader)
                 , fNextXfermode(Type::kXfermode)
             {}

             void cleanup(Encoder* encoder) override {
                 Undefiner undef{encoder};
                 fMatrix  .foreach(undef);
                 fMisc    .foreach(undef);
                 fPath    .foreach(undef);
                 fStroke  .foreach(undef);
                 fShader  .foreach(undef);
                 fXfermode.foreach(undef);
             }


             bool lookup(const SkMatrix& matrix, ID* id, LookupScope*) override {
                 return always_cache_lookup(matrix, &fMatrix, &fNextMatrix, id);
             }
             bool lookup(const Misc& misc, ID* id, LookupScope*) override {
                 return always_cache_lookup(misc, &fMisc, &fNextMisc, id);
             }
             bool lookup(const SkPath& path, ID* id, LookupScope*) override {
                 return always_cache_lookup(path, &fPath, &fNextPath, id);
             }
             bool lookup(const Stroke& stroke, ID* id, LookupScope*) override {
                 return always_cache_lookup(stroke, &fStroke, &fNextStroke, id);
             }
             bool lookup(const SkShader* shader, ID* id, LookupScope*) override {
                 return always_cache_lookup(shader, &fShader, &fNextShader, id);
             }
             bool lookup(const SkXfermode* xfermode, ID* id, LookupScope*) override {
                 return always_cache_lookup(xfermode, &fXfermode, &fNextXfermode, id);
             }

             SkTHashMap<SkMatrix, ID>               fMatrix;
             SkTHashMap<Misc,     ID, MiscHash>     fMisc;
             SkTHashMap<SkPath,   ID>               fPath;
             SkTHashMap<Stroke,   ID>               fStroke;
             RefKeyMap<SkShader,   Type::kShader>   fShader;
             RefKeyMap<SkXfermode, Type::kXfermode> fXfermode;

             ID fNextMatrix,
                fNextMisc,
                fNextPath,
                fNextStroke,
                fNextShader,
                fNextXfermode;
         };
         return new AlwaysCache;
     }

     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //

     Client::Client(Cache* cache, Encoder* encoder)
         : SkCanvas(1,1)
         , fCache(cache)
         , fEncoder(encoder)
     {}

     Client::~Client() {
         fCache->cleanup(fEncoder);
     }

     void Client::willSave()   { fEncoder->save(); }
     void Client::didRestore() { fEncoder->restore(); }

     void Client::didConcat   (const SkMatrix&) { this->didSetMatrix(this->getTotalMatrix()); }
     void Client::didSetMatrix(const SkMatrix& matrix) {
         LookupScope ls(fCache, fEncoder);
         fEncoder->setMatrix(ls.lookup(matrix));
     }

     void Client::onDrawOval(const SkRect& oval, const SkPaint& paint) {
         SkPath path;
         path.addOval(oval);
         this->onDrawPath(path, paint);
     }

     void Client::onDrawRect(const SkRect& rect, const SkPaint& paint) {
         SkPath path;
         path.addRect(rect);
         this->onDrawPath(path, paint);
     }

     void Client::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
         SkPath path;
         path.addRRect(rrect);
         this->onDrawPath(path, paint);
     }

     void Client::onDrawDRRect(const SkRRect& outside,
                               const SkRRect& inside,
                               const SkPaint& paint) {
         SkPath path;
         path.addRRect(outside);
         path.addRRect(inside, SkPath::kCCW_Direction);
         this->onDrawPath(path, paint);
     }

     void Client::onDrawPath(const SkPath& path, const SkPaint& paint) {
         LookupScope ls(fCache, fEncoder);
         ID p = ls.lookup(path),
            m = ls.lookup(Misc::CreateFrom(paint)),
            s = ls.lookup(paint.getShader()),
            x = ls.lookup(paint.getXfermode());

         if (paint.getStyle() == SkPaint::kFill_Style) {
             fEncoder->fillPath(p, m, s, x);
         } else {
             // TODO: handle kStrokeAndFill_Style
             fEncoder->strokePath(p, m, s, x, ls.lookup(Stroke::CreateFrom(paint)));
         }
     }

     void Client::onDrawPaint(const SkPaint& paint) {
         SkPath path;
         path.setFillType(SkPath::kInverseWinding_FillType);  // Either inverse FillType works fine.
         this->onDrawPath(path, paint);
     }

     void Client::onDrawText(const void* text, size_t byteLength, SkScalar x,
                             SkScalar y, const SkPaint& paint) {
         // 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 Client::onDrawPosText(const void* text, size_t byteLength,
                                const SkPoint pos[], const SkPaint& paint) {
         // 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 Client::onDrawPosTextH(const void* text, size_t byteLength,
                                 const SkScalar xpos[], SkScalar constY,
                                 const SkPaint& paint) {
         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);
     }

     void Client::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
         SkPath path;
         path.addRect(rect);
         this->onClipPath(path, op, edgeStyle);
     }

     void Client::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
         SkPath path;
         path.addRRect(rrect);
         this->onClipPath(path, op, edgeStyle);
     }

     void Client::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
         LookupScope ls(fCache, fEncoder);
         fEncoder->clipPath(ls.lookup(path), op, edgeStyle == kSoft_ClipEdgeStyle);
     }

     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //

     Server::Server(SkCanvas* canvas) : fCanvas(canvas) {}

     void Server::define(ID id, const SkMatrix& v) { fMatrix  .set(id, v); }
     void Server::define(ID id, const Misc&     v) { fMisc    .set(id, v); }
     void Server::define(ID id, const SkPath&   v) { fPath    .set(id, v); }
     void Server::define(ID id, const Stroke&   v) { fStroke  .set(id, v); }
     void Server::define(ID id, SkShader*       v) { fShader  .set(id, v); }
     void Server::define(ID id, SkXfermode*     v) { fXfermode.set(id, v); }

     void Server::undefine(ID id) {
         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::kShader:   return fShader  .remove(id);
             case Type::kXfermode: return fXfermode.remove(id);

             case Type::kNone: SkASSERT(false);
         };
     }

     void Server::   save() { fCanvas->save(); }
     void Server::restore() { fCanvas->restore(); }

     void Server::setMatrix(ID matrix) { fCanvas->setMatrix(fMatrix.find(matrix)); }

     void Server::clipPath(ID path, SkRegion::Op op, bool aa) {
         fCanvas->clipPath(fPath.find(path), op, aa);
     }
     void Server::fillPath(ID path, ID misc, ID shader, ID xfermode) {
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
         fMisc.find(misc).applyTo(&paint);
         paint.setShader  (fShader  .find(shader));
         paint.setXfermode(fXfermode.find(xfermode));
         fCanvas->drawPath(fPath.find(path), paint);
     }
     void Server::strokePath(ID path, ID misc, ID shader, ID xfermode, ID stroke) {
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         fMisc  .find(misc  ).applyTo(&paint);
         fStroke.find(stroke).applyTo(&paint);
         paint.setShader  (fShader  .find(shader));
         paint.setXfermode(fXfermode.find(xfermode));
         fCanvas->drawPath(fPath.find(path), paint);
     }

 } // namespace SkRemote
	/*
	* 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 "SkPath.h"
	#include "SkRect.h"
	#include "SkRemote.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 LookupScope {
	public:
	LookupScope(Cache* cache, Encoder* encoder) : fCache(cache), fEncoder(encoder) {}
	~LookupScope() { for (ID id : fToUndefine) { fEncoder->undefine(id); } }
	void undefineWhenDone(ID id) { fToUndefine.push_back(id); }

	template <typename T>
	ID lookup(const T& val) {
	ID id;
	if (!fCache->lookup(val, &id, this)) {
	fEncoder->define(id, val);
	}
	return id;
	}

	private:
	Cache* fCache;
	Encoder* fEncoder;
	SkSTArray<4, ID> fToUndefine;
	};


	Cache* Cache::CreateNeverCache() {
	struct NeverCache final : public Cache {
	NeverCache()
	: fNextMatrix (Type::kMatrix)
	, fNextMisc (Type::kMisc)
	, fNextPath (Type::kPath)
	, fNextStroke (Type::kStroke)
	, fNextShader (Type::kShader)
	, fNextXfermode(Type::kXfermode)
	{}
	void cleanup(Encoder*) override {}

	static bool Helper(ID* next, ID* id, LookupScope* ls) {
	id = ++(next);
	ls->undefineWhenDone(*id);
	return false;
	}

	bool lookup(const SkMatrix&, ID* id, LookupScope* ls) override {
	return Helper(&fNextMatrix, id, ls);
	}
	bool lookup(const Misc&, ID* id, LookupScope* ls) override {
	return Helper(&fNextMisc, id, ls);
	}
	bool lookup(const SkPath&, ID* id, LookupScope* ls) override {
	return Helper(&fNextPath, id, ls);
	}
	bool lookup(const Stroke&, ID* id, LookupScope* ls) override {
	return Helper(&fNextStroke, id, ls);
	}
	bool lookup(const SkShader* shader, ID* id, LookupScope* ls) override {
	if (!shader) {
	*id = ID(Type::kShader);
	return true; // Null IDs are always defined.
	}
	return Helper(&fNextShader, id, ls);
	}
	bool lookup(const SkXfermode* xfermode, ID* id, LookupScope* ls) override {
	if (!xfermode) {
	*id = ID(Type::kXfermode);
	return true; // Null IDs are always defined.
	}
	return Helper(&fNextXfermode, id, ls);
	}

	ID fNextMatrix,
	fNextMisc,
	fNextPath,
	fNextStroke,
	fNextShader,
	fNextXfermode;
	};
	return new NeverCache;
	}

	// These can't be declared locally inside AlwaysCache because of the templating. :(
	namespace {
	template <typename T, typename Map>
	static bool always_cache_lookup(const T& val, Map* map, ID* next, ID* id) {
	if (const ID* found = map->find(val)) {
	id = found;
	return true;
	}
	id = ++(next);
	map->set(val, *id);
	return false;
	}

	struct Undefiner {
	Encoder* fEncoder;

	template <typename T>
	void operator()(const T&, ID* id) const { fEncoder->undefine(*id); }
	};

	// Maps const T* -> ID, and refs the key. nullptr always maps to ID(kType).
	template <typename T, Type kType>
	class RefKeyMap {
	public:
	RefKeyMap() {}
	~RefKeyMap() { fMap.foreach([](const T* key, ID*) { key->unref(); }); }

	void set(const T* key, const ID& id) {
	SkASSERT(key && id.type() == kType);
	fMap.set(SkRef(key), id);
	}

	void remove(const T* key) {
	SkASSERT(key);
	fMap.remove(key);
	key->unref();
	}

	const ID* find(const T* key) const {
	static const ID nullID(kType);
	return key ? fMap.find(key) : &nullID;
	}

	template <typename Fn>
	void foreach(const Fn& fn) { fMap.foreach(fn); }
	private:
	SkTHashMap<const T*, ID> fMap;
	};
	} // namespace

	Cache* Cache::CreateAlwaysCache() {
	struct AlwaysCache final : public Cache {
	AlwaysCache()
	: fNextMatrix (Type::kMatrix)
	, fNextMisc (Type::kMisc)
	, fNextPath (Type::kPath)
	, fNextStroke (Type::kStroke)
	, fNextShader (Type::kShader)
	, fNextXfermode(Type::kXfermode)
	{}

	void cleanup(Encoder* encoder) override {
	Undefiner undef{encoder};
	fMatrix .foreach(undef);
	fMisc .foreach(undef);
	fPath .foreach(undef);
	fStroke .foreach(undef);
	fShader .foreach(undef);
	fXfermode.foreach(undef);
	}


	bool lookup(const SkMatrix& matrix, ID* id, LookupScope*) override {
	return always_cache_lookup(matrix, &fMatrix, &fNextMatrix, id);
	}
	bool lookup(const Misc& misc, ID* id, LookupScope*) override {
	return always_cache_lookup(misc, &fMisc, &fNextMisc, id);
	}
	bool lookup(const SkPath& path, ID* id, LookupScope*) override {
	return always_cache_lookup(path, &fPath, &fNextPath, id);
	}
	bool lookup(const Stroke& stroke, ID* id, LookupScope*) override {
	return always_cache_lookup(stroke, &fStroke, &fNextStroke, id);
	}
	bool lookup(const SkShader* shader, ID* id, LookupScope*) override {
	return always_cache_lookup(shader, &fShader, &fNextShader, id);
	}
	bool lookup(const SkXfermode* xfermode, ID* id, LookupScope*) override {
	return always_cache_lookup(xfermode, &fXfermode, &fNextXfermode, id);
	}

	SkTHashMap<SkMatrix, ID> fMatrix;
	SkTHashMap<Misc, ID, MiscHash> fMisc;
	SkTHashMap<SkPath, ID> fPath;
	SkTHashMap<Stroke, ID> fStroke;
	RefKeyMap<SkShader, Type::kShader> fShader;
	RefKeyMap<SkXfermode, Type::kXfermode> fXfermode;

	ID fNextMatrix,
	fNextMisc,
	fNextPath,
	fNextStroke,
	fNextShader,
	fNextXfermode;
	};
	return new AlwaysCache;
	}

	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //

	Client::Client(Cache* cache, Encoder* encoder)
	: SkCanvas(1,1)
	, fCache(cache)
	, fEncoder(encoder)
	{}

	Client::~Client() {
	fCache->cleanup(fEncoder);
	}

	void Client::willSave() { fEncoder->save(); }
	void Client::didRestore() { fEncoder->restore(); }

	void Client::didConcat (const SkMatrix&) { this->didSetMatrix(this->getTotalMatrix()); }
	void Client::didSetMatrix(const SkMatrix& matrix) {
	LookupScope ls(fCache, fEncoder);
	fEncoder->setMatrix(ls.lookup(matrix));
	}

	void Client::onDrawOval(const SkRect& oval, const SkPaint& paint) {
	SkPath path;
	path.addOval(oval);
	this->onDrawPath(path, paint);
	}

	void Client::onDrawRect(const SkRect& rect, const SkPaint& paint) {
	SkPath path;
	path.addRect(rect);
	this->onDrawPath(path, paint);
	}

	void Client::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
	SkPath path;
	path.addRRect(rrect);
	this->onDrawPath(path, paint);
	}

	void Client::onDrawDRRect(const SkRRect& outside,
	const SkRRect& inside,
	const SkPaint& paint) {
	SkPath path;
	path.addRRect(outside);
	path.addRRect(inside, SkPath::kCCW_Direction);
	this->onDrawPath(path, paint);
	}

	void Client::onDrawPath(const SkPath& path, const SkPaint& paint) {
	LookupScope ls(fCache, fEncoder);
	ID p = ls.lookup(path),
	m = ls.lookup(Misc::CreateFrom(paint)),
	s = ls.lookup(paint.getShader()),
	x = ls.lookup(paint.getXfermode());

	if (paint.getStyle() == SkPaint::kFill_Style) {
	fEncoder->fillPath(p, m, s, x);
	} else {
	// TODO: handle kStrokeAndFill_Style
	fEncoder->strokePath(p, m, s, x, ls.lookup(Stroke::CreateFrom(paint)));
	}
	}

	void Client::onDrawPaint(const SkPaint& paint) {
	SkPath path;
	path.setFillType(SkPath::kInverseWinding_FillType); // Either inverse FillType works fine.
	this->onDrawPath(path, paint);
	}

	void Client::onDrawText(const void* text, size_t byteLength, SkScalar x,
	SkScalar y, const SkPaint& paint) {
	// 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 Client::onDrawPosText(const void* text, size_t byteLength,
	const SkPoint pos[], const SkPaint& paint) {
	// 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 Client::onDrawPosTextH(const void* text, size_t byteLength,
	const SkScalar xpos[], SkScalar constY,
	const SkPaint& paint) {
	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);
	}

	void Client::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
	SkPath path;
	path.addRect(rect);
	this->onClipPath(path, op, edgeStyle);
	}

	void Client::onClipRRect(const SkRRect& rrect, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
	SkPath path;
	path.addRRect(rrect);
	this->onClipPath(path, op, edgeStyle);
	}

	void Client::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle edgeStyle) {
	LookupScope ls(fCache, fEncoder);
	fEncoder->clipPath(ls.lookup(path), op, edgeStyle == kSoft_ClipEdgeStyle);
	}

	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //

	Server::Server(SkCanvas* canvas) : fCanvas(canvas) {}

	void Server::define(ID id, const SkMatrix& v) { fMatrix .set(id, v); }
	void Server::define(ID id, const Misc& v) { fMisc .set(id, v); }
	void Server::define(ID id, const SkPath& v) { fPath .set(id, v); }
	void Server::define(ID id, const Stroke& v) { fStroke .set(id, v); }
	void Server::define(ID id, SkShader* v) { fShader .set(id, v); }
	void Server::define(ID id, SkXfermode* v) { fXfermode.set(id, v); }

	void Server::undefine(ID id) {
	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::kShader: return fShader .remove(id);
	case Type::kXfermode: return fXfermode.remove(id);

	case Type::kNone: SkASSERT(false);
	};
	}

	void Server:: save() { fCanvas->save(); }
	void Server::restore() { fCanvas->restore(); }

	void Server::setMatrix(ID matrix) { fCanvas->setMatrix(fMatrix.find(matrix)); }

	void Server::clipPath(ID path, SkRegion::Op op, bool aa) {
	fCanvas->clipPath(fPath.find(path), op, aa);
	}
	void Server::fillPath(ID path, ID misc, ID shader, ID xfermode) {
	SkPaint paint;
	paint.setStyle(SkPaint::kFill_Style);
	fMisc.find(misc).applyTo(&paint);
	paint.setShader (fShader .find(shader));
	paint.setXfermode(fXfermode.find(xfermode));
	fCanvas->drawPath(fPath.find(path), paint);
	}
	void Server::strokePath(ID path, ID misc, ID shader, ID xfermode, ID stroke) {
	SkPaint paint;
	paint.setStyle(SkPaint::kStroke_Style);
	fMisc .find(misc ).applyTo(&paint);
	fStroke.find(stroke).applyTo(&paint);
	paint.setShader (fShader .find(shader));
	paint.setXfermode(fXfermode.find(xfermode));
	fCanvas->drawPath(fPath.find(path), paint);
	}

	} // namespace SkRemote