SkRemote

src/core/SkRemote_protocol.h

Index: src/core/SkRemote_protocol.h
diff --git a/src/core/SkRemote_protocol.h b/src/core/SkRemote_protocol.h
new file mode 100644
index 0000000000000000000000000000000000000000..a677642ceaa529408073f80578d132c0da4fd4e4
--- /dev/null
+++ b/src/core/SkRemote_protocol.h
@@ -0,0 +1,49 @@
+/*
+ * 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 {
+        kNone,
+
+        kMatrix,
+        kMisc,
+        kPath,
+        kStroke,
+    };
+
+    class ID {
+    public:
+        explicit ID(Type type = Type::kNone) : fVal((uint64_t)type << 56) {}
+
+        Type    type() const { return (Type)(fVal >> 56); }
+        uint64_t val() const { return fVal & ~((uint64_t)0xFF << 56); }

[hal.canary, 2015/10/16 16:57:55]

given a type and a value, how does a decoder create an ID? (other than a union
or memcpy).

[mtklein, 2015/10/16 17:20:33]

I had been imagining it couldn't, but good point, that's silly.  I've added
another constructor.

+
+        bool operator==(ID o) const { return fVal == o.fVal; }
+        ID operator++(int) {
+            ID prev = *this;
+            fVal++;
+            SkASSERT(this->val() != 0);  // Overflow is particularly bad as it'd change our Type.
+            return prev;
+        }
+
+    private:
+        // High 8 bits hold a Type.  Low 56 bits are unique within that Type.
+        // Any change to this format will break protocol compatibility.
+        uint64_t fVal;
+    };
+
+}  // namespace SkRemote
+
+#endif//SkRemote_protocol_DEFINED