add pipecanvas

src/core/SkPipe.h

Index: src/core/SkPipe.h
diff --git a/src/core/SkPipe.h b/src/core/SkPipe.h
new file mode 100644
index 0000000000000000000000000000000000000000..33fbd293111fa8b6d1f64d19aacd5cbcd7af054f
--- /dev/null
+++ b/src/core/SkPipe.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPipe_DEFINED
+#define SkPipe_DEFINED
+
+#include "SkTypes.h"
+
+class SkCanvas;
+class SkImage;
+class SkPicture;
+class SkTypefaceSerializer;
+class SkTypefaceDeserializer;
+class SkWStream;
+
+class SkPipeSerializer {
+public:
+    SkPipeSerializer();
+    ~SkPipeSerializer();
+
+    void setTypefaceSerializer(SkTypefaceSerializer*);

[mtklein_C, 2016/09/12 19:47:58]

Ownership transfer here is unclear.  This reads like it takes no ownership, but
in SampleApp we call setTypefaceSerializer(new ...) directly.  Might wanna pass
this by std::unique_ptr?

[reed1, 2016/09/12 21:35:23]

updated dox

+
+    void resetCache();
+
+    void write(SkPicture*, SkWStream*);
+    void write(SkImage*, SkWStream*);
+
+    SkCanvas* beginWrite(const SkRect& cullBounds, SkWStream*);
+    void endWrite();
+
+private:
+    class Impl;
+    Impl* fImpl;

[mtklein_C, 2016/09/12 19:47:58]

The usual idiom these days is

private:
  class Impl;
  std::unique_ptr<Impl> fImpl;

This'll work as long as your destructor is defined in the same translation unit
as Impl is defined (as is true here for both your types.)

+};
+
+class SkPipeDeserializer {
+public:
+    SkPipeDeserializer();
+    ~SkPipeDeserializer();
+
+    void setTypefaceDeserializer(SkTypefaceDeserializer*);

[mtklein_C, 2016/09/12 19:47:58]

Ditto.

+
+    sk_sp<SkPicture> readPicture(const void*, size_t);
+    sk_sp<SkImage> readImage(const void*, size_t);
+    bool playback(const void*, size_t, SkCanvas*);
+
+private:
+    class Impl;
+    Impl* fImpl;
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+class SkTypefaceSerializer {

[mtklein_C, 2016/09/12 19:47:58]

Another option you might want to consider for this sort of thing is

using SkTypefaceSerializer   = std::function<sk_sp<SkData> (SkTypeface*)>;
using SkTypefaceDeserializer = std::function<SkTypeface* (const void*, size_t)>;

[reed1, 2016/09/12 21:35:22]

Just keeping my options open as we think more about these. Picture serialization
(the public api) might end up wanting the same sort of object(s), and they may
want more than one method (don't know yet). But I see that if these stay
singe-method, then std::function would be clean.

+public:
+    virtual ~SkTypefaceSerializer() {}
+
+    virtual sk_sp<SkData> serialize(SkTypeface*) = 0;
+};
+
+class SkTypefaceDeserializer {
+public:
+    virtual ~SkTypefaceDeserializer() {}
+
+    virtual sk_sp<SkTypeface> deserialize(const void* data, size_t size) = 0;
+};
+
+#endif