[DevTools] Roll inspector_protocol (v8)

powdercloud · Commit Bot · commit 6f6942db910d · 2019-10-29T16:36:56.000Z
New revision: d2fc9b958e1eeb1e956f3e2208afa9923bdc9b67 To roll this I need to update some call sites; this is because the Serializable interface is changing. Upstream change / review was here: https://chromium-review.googlesource.com/c/deps/inspector_protocol/+/1879870 Change-Id: I93c4747609c6003baf1c160a68b8fb6bb07ac565 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1879519 Reviewed-by: Yang Guo <yangguo@chromium.org> Commit-Queue: Johannes Henkel <johannes@chromium.org> Cr-Commit-Position: refs/heads/master@{#64618}
diff --git a/src/inspector/v8-inspector-session-impl.cc b/src/inspector/v8-inspector-session-impl.cc
@@ -163,7 +163,7 @@ protocol::DictionaryValue* V8InspectorSessionImpl::agentState(
 
 std::unique_ptr<StringBuffer> V8InspectorSessionImpl::serializeForFrontend(
     std::unique_ptr<protocol::Serializable> message) {
-  std::vector<uint8_t> cbor = message->serializeToBinary();
+  std::vector<uint8_t> cbor = std::move(*message).TakeSerialized();
   if (use_binary_protocol_)
     return std::unique_ptr<StringBuffer>(
         new BinaryStringBuffer(std::move(cbor)));
@@ -366,9 +366,7 @@ void V8InspectorSessionImpl::dispatchProtocolMessage(
 }
 
 std::vector<uint8_t> V8InspectorSessionImpl::state() {
-  std::vector<uint8_t> out;
-  m_state->writeBinary(&out);
-  return out;
+  return std::move(*m_state).TakeSerialized();
 }
 
 std::vector<std::unique_ptr<protocol::Schema::API::Domain>>
diff --git a/third_party/inspector_protocol/README.v8 b/third_party/inspector_protocol/README.v8
@@ -2,7 +2,7 @@ Name: inspector protocol
 Short Name: inspector_protocol
 URL: https://chromium.googlesource.com/deps/inspector_protocol/
 Version: 0
-Revision: bbc72612409377752c8fd2e7a63a1a5947b7dc4b
+Revision: d2fc9b958e1eeb1e956f3e2208afa9923bdc9b67
 License: BSD
 License File: LICENSE
 Security Critical: no
diff --git a/third_party/inspector_protocol/lib/DispatcherBase_cpp.template b/third_party/inspector_protocol/lib/DispatcherBase_cpp.template
@@ -142,9 +142,9 @@ public:
         return std::unique_ptr<ProtocolError>(new ProtocolError(code, errorMessage));
     }
 
-    std::vector<uint8_t> serializeToBinary() override
+    void AppendSerialized(std::vector<uint8_t>* out) const override
     {
-        return serialize()->serializeToBinary();
+        toDictionary()->AppendSerialized(out);
     }
 
     ~ProtocolError() override {}
@@ -156,7 +156,7 @@ private:
     {
     }
 
-    std::unique_ptr<DictionaryValue> serialize() {
+    std::unique_ptr<DictionaryValue> toDictionary() const {
         std::unique_ptr<protocol::DictionaryValue> error = DictionaryValue::create();
         error->setInteger("code", m_code);
         error->setString("message", m_errorMessage);
@@ -299,13 +299,13 @@ UberDispatcher::~UberDispatcher() = default;
 // static
 std::unique_ptr<Serializable> InternalResponse::createResponse(int callId, std::unique_ptr<Serializable> params)
 {
-    return std::unique_ptr<Serializable>(new InternalResponse(callId, String(), std::move(params)));
+    return std::unique_ptr<Serializable>(new InternalResponse(callId, nullptr, std::move(params)));
 }
 
 // static
-std::unique_ptr<Serializable> InternalResponse::createNotification(const String& notification, std::unique_ptr<Serializable> params)
+std::unique_ptr<Serializable> InternalResponse::createNotification(const char* method, std::unique_ptr<Serializable> params)
 {
-    return std::unique_ptr<Serializable>(new InternalResponse(0, notification, std::move(params)));
+    return std::unique_ptr<Serializable>(new InternalResponse(0, method, std::move(params)));
 }
 
 // static
@@ -314,23 +314,39 @@ std::unique_ptr<Serializable> InternalResponse::createErrorResponse(int callId,
     return ProtocolError::createErrorResponse(callId, code, message, nullptr);
 }
 
-std::vector<uint8_t> InternalResponse::serializeToBinary()
+void InternalResponse::AppendSerialized(std::vector<uint8_t>* out) const
 {
-    std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
-    std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());
-    if (m_notification.length()) {
-        result->setString("method", m_notification);
-        result->setValue("params", SerializedValue::fromBinary(params->serializeToBinary()));
+    using {{config.encoding_lib.namespace}}::cbor::NewCBOREncoder;
+    using {{config.encoding_lib.namespace}}::StreamingParserHandler;
+    using {{config.encoding_lib.namespace}}::Status;
+    using {{config.encoding_lib.namespace}}::SpanFrom;
+
+    Status status;
+    std::unique_ptr<StreamingParserHandler> encoder =
+        NewCBOREncoder(out, &status);
+    encoder->HandleMapBegin();
+    if (m_method) {
+        encoder->HandleString8(SpanFrom("method"));
+        encoder->HandleString8(SpanFrom(m_method));
+        encoder->HandleString8(SpanFrom("params"));
     } else {
-        result->setInteger("id", m_callId);
-        result->setValue("result", SerializedValue::fromBinary(params->serializeToBinary()));
+        encoder->HandleString8(SpanFrom("id"));
+        encoder->HandleInt32(m_callId);
+        encoder->HandleString8(SpanFrom("result"));
     }
-    return result->serializeToBinary();
+    if (m_params) {
+        m_params->AppendSerialized(out);
+    } else {
+        encoder->HandleMapBegin();
+        encoder->HandleMapEnd();
+    }
+    encoder->HandleMapEnd();
+    DCHECK(status.ok());
 }
 
-InternalResponse::InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params)
+InternalResponse::InternalResponse(int callId, const char* method, std::unique_ptr<Serializable> params)
     : m_callId(callId)
-    , m_notification(notification)
+    , m_method(method)
     , m_params(params ? std::move(params) : nullptr)
 {
 }
diff --git a/third_party/inspector_protocol/lib/DispatcherBase_h.template b/third_party/inspector_protocol/lib/DispatcherBase_h.template
@@ -129,18 +129,18 @@ class InternalResponse : public Serializable {
     PROTOCOL_DISALLOW_COPY(InternalResponse);
 public:
     static std::unique_ptr<Serializable> createResponse(int callId, std::unique_ptr<Serializable> params);
-    static std::unique_ptr<Serializable> createNotification(const String& notification, std::unique_ptr<Serializable> params = nullptr);
+    static std::unique_ptr<Serializable> createNotification(const char* method, std::unique_ptr<Serializable> params = nullptr);
     static std::unique_ptr<Serializable> createErrorResponse(int callId, DispatchResponse::ErrorCode code, const String& message);
 
-    std::vector<uint8_t> serializeToBinary() override;
+    void AppendSerialized(std::vector<uint8_t>* out) const override;
 
     ~InternalResponse() override {}
 
 private:
-    InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params);
+    InternalResponse(int callId, const char* method, std::unique_ptr<Serializable> params);
 
     int m_callId;
-    String m_notification;
+    const char* m_method = nullptr;
     std::unique_ptr<Serializable> m_params;
 };
 
@@ -153,11 +153,15 @@ public:
 
     ~InternalRawNotification() override {}
 
-    std::vector<uint8_t> serializeToBinary() override
-    {
+    std::vector<uint8_t> TakeSerialized() && override {
         return std::move(m_binaryNotification);
     }
 
+    void AppendSerialized(std::vector<uint8_t>* out) const override
+    {
+        out->insert(out->end(), m_binaryNotification.begin(), m_binaryNotification.end());
+    }
+
 private:
   explicit InternalRawNotification(std::vector<uint8_t> notification)
     : m_binaryNotification(std::move(notification)) { }
diff --git a/third_party/inspector_protocol/lib/FrontendChannel_h.template b/third_party/inspector_protocol/lib/FrontendChannel_h.template
@@ -13,7 +13,12 @@ namespace {{namespace}} {
 
 class {{config.lib.export_macro}} Serializable {
 public:
-    virtual std::vector<uint8_t> serializeToBinary() = 0;
+    virtual std::vector<uint8_t> TakeSerialized() && {
+      std::vector<uint8_t> out;
+      AppendSerialized(&out);
+      return out;
+    }
+    virtual void AppendSerialized(std::vector<uint8_t>* out) const = 0;
     virtual ~Serializable() = default;
 };
 
diff --git a/third_party/inspector_protocol/lib/Values_cpp.template b/third_party/inspector_protocol/lib/Values_cpp.template
@@ -281,7 +281,7 @@ void Value::writeJSON(StringBuilder* output) const
     StringUtil::builderAppend(*output, nullValueString, 4);
 }
 
-void Value::writeBinary(std::vector<uint8_t>* bytes) const {
+void Value::AppendSerialized(std::vector<uint8_t>* bytes) const {
     DCHECK(m_type == TypeNull);
     bytes->push_back(cbor::EncodeNull());
 }
@@ -299,12 +299,6 @@ String Value::toJSONString() const
     return StringUtil::builderToString(result);
 }
 
-std::vector<uint8_t> Value::serializeToBinary() {
-    std::vector<uint8_t> bytes;
-    writeBinary(&bytes);
-    return bytes;
-}
-
 bool FundamentalValue::asBoolean(bool* output) const
 {
     if (type() != TypeBoolean)
@@ -353,7 +347,7 @@ void FundamentalValue::writeJSON(StringBuilder* output) const
     }
 }
 
-void FundamentalValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void FundamentalValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     switch (type()) {
     case TypeDouble:
         cbor::EncodeDouble(m_doubleValue, bytes);
@@ -422,7 +416,7 @@ void EncodeString(const String& s, std::vector<uint8_t>* out) {
 }
 }  // namespace
 
-void StringValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void StringValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
   EncodeString(m_stringValue, bytes);
 }
 
@@ -443,7 +437,7 @@ void BinaryValue::writeJSON(StringBuilder* output) const
     StringUtil::builderAppendQuotedString(*output, m_binaryValue.toBase64());
 }
 
-void BinaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void BinaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EncodeBinary(span<uint8_t>(m_binaryValue.data(),
                                      m_binaryValue.size()), bytes);
 }
@@ -459,7 +453,11 @@ void SerializedValue::writeJSON(StringBuilder* output) const
     StringUtil::builderAppend(*output, m_serializedJSON);
 }
 
-void SerializedValue::writeBinary(std::vector<uint8_t>* output) const
+std::vector<uint8_t> SerializedValue::TakeSerialized() && {
+    return std::move(m_serializedBinary);
+}
+
+void SerializedValue::AppendSerialized(std::vector<uint8_t>* output) const
 {
     DCHECK(type() == TypeSerialized);
     output->insert(output->end(), m_serializedBinary.begin(), m_serializedBinary.end());
@@ -607,7 +605,7 @@ void DictionaryValue::writeJSON(StringBuilder* output) const
     StringUtil::builderAppend(*output, '}');
 }
 
-void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void DictionaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EnvelopeEncoder encoder;
     encoder.EncodeStart(bytes);
     bytes->push_back(cbor::EncodeIndefiniteLengthMapStart());
@@ -616,7 +614,7 @@ void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
         Dictionary::const_iterator value = m_data.find(key);
         DCHECK(value != m_data.cend() && value->second);
         EncodeString(key, bytes);
-        value->second->writeBinary(bytes);
+        value->second->AppendSerialized(bytes);
     }
     bytes->push_back(cbor::EncodeStop());
     encoder.EncodeStop(bytes);
@@ -656,12 +654,12 @@ void ListValue::writeJSON(StringBuilder* output) const
     StringUtil::builderAppend(*output, ']');
 }
 
-void ListValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void ListValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EnvelopeEncoder encoder;
     encoder.EncodeStart(bytes);
     bytes->push_back(cbor::EncodeIndefiniteLengthArrayStart());
     for (size_t i = 0; i < m_data.size(); ++i) {
-        m_data[i]->writeBinary(bytes);
+        m_data[i]->AppendSerialized(bytes);
     }
     bytes->push_back(cbor::EncodeStop());
     encoder.EncodeStop(bytes);
diff --git a/third_party/inspector_protocol/lib/Values_h.template b/third_party/inspector_protocol/lib/Values_h.template
@@ -54,10 +54,9 @@ public:
     virtual bool asBinary(Binary* output) const;
 
     virtual void writeJSON(StringBuilder* output) const;
-    virtual void writeBinary(std::vector<uint8_t>* bytes) const;
+    virtual void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     virtual std::unique_ptr<Value> clone() const;
     String toJSONString() const;
-    std::vector<uint8_t> serializeToBinary() override;
 
 protected:
     Value() : m_type(TypeNull) { }
@@ -91,7 +90,7 @@ public:
     bool asDouble(double* output) const override;
     bool asInteger(int* output) const override;
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -120,7 +119,7 @@ public:
 
     bool asString(String* output) const override;
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -139,7 +138,7 @@ public:
 
     bool asBinary(Binary* output) const override;
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -161,7 +160,8 @@ public:
     }
 
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    std::vector<uint8_t> TakeSerialized() && override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -194,7 +194,7 @@ public:
     }
 
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
     size_t size() const { return m_data.size(); }
@@ -263,7 +263,7 @@ public:
     ~ListValue() override;
 
     void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
     void pushValue(std::unique_ptr<Value>);
diff --git a/third_party/inspector_protocol/templates/Imported_h.template b/third_party/inspector_protocol/templates/Imported_h.template
@@ -34,7 +34,7 @@ public:
         String local_json = ({{config.imported.from_imported_string % "std::move(json)"}});
         StringUtil::builderAppend(*output, local_json);
     }
-    void writeBinary(std::vector<uint8_t>* output) const override {
+    void AppendSerialized(std::vector<uint8_t>* output) const override {
         m_exported->writeBinary(output);
     }
     std::unique_ptr<Value> clone() const override {
@@ -61,7 +61,7 @@ struct ValueConversions<{{"::".join(config.imported.namespace)}}::{{domain.domai
         }
 
         std::vector<uint8_t> binary;
-        value->writeBinary(&binary);
+        value->AppendSerialized(&binary);
         auto result = {{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}::fromBinary(binary.data(), binary.size());
         if (!result)
             errors->addError("cannot parse");
diff --git a/third_party/inspector_protocol/templates/TypeBuilder_cpp.template b/third_party/inspector_protocol/templates/TypeBuilder_cpp.template
@@ -107,7 +107,7 @@ std::unique_ptr<{{type.id}}> {{type.id}}::clone() const
 
 void {{type.id}}::writeBinary(std::vector<uint8_t>* out) const
 {
-    toValue()->writeBinary(out);
+    toValue()->AppendSerialized(out);
 }
 
 // static
diff --git a/third_party/inspector_protocol/templates/TypeBuilder_h.template b/third_party/inspector_protocol/templates/TypeBuilder_h.template
@@ -100,7 +100,9 @@ public:
     {% endfor %}
 
     std::unique_ptr<protocol::DictionaryValue> toValue() const;
-    std::vector<uint8_t> serializeToBinary() override { return toValue()->serializeToBinary(); }
+    void AppendSerialized(std::vector<uint8_t>* out) const override {
+        toValue()->AppendSerialized(out);
+    }
     String toJSON() const { return toValue()->toJSONString(); }
     std::unique_ptr<{{type.id}}> clone() const;
     {% if protocol.is_exported(domain.domain, type.id) %}

Original file line number	Diff line number	Diff line change
`@@ -142,9 +142,9 @@ public:`
`142`	`142`	`return std::unique_ptr<ProtocolError>(new ProtocolError(code, errorMessage));`
`143`	`143`	`}`
`144`	`144`
`145`		`- std::vector<uint8_t> serializeToBinary() override`
	`145`	`+ void AppendSerialized(std::vector<uint8_t>* out) const override`
`146`	`146`	`{`
`147`		`- return serialize()->serializeToBinary();`
	`147`	`+ toDictionary()->AppendSerialized(out);`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`~ProtocolError() override {}`
`@@ -156,7 +156,7 @@ private:`
`156`	`156`	`{`
`157`	`157`	`}`
`158`	`158`
`159`		`- std::unique_ptr<DictionaryValue> serialize() {`
	`159`	`+ std::unique_ptr<DictionaryValue> toDictionary() const {`
`160`	`160`	`std::unique_ptr<protocol::DictionaryValue> error = DictionaryValue::create();`
`161`	`161`	`error->setInteger("code", m_code);`
`162`	`162`	`error->setString("message", m_errorMessage);`
`@@ -299,13 +299,13 @@ UberDispatcher::~UberDispatcher() = default;`
`299`	`299`	`// static`
`300`	`300`	`std::unique_ptr<Serializable> InternalResponse::createResponse(int callId, std::unique_ptr<Serializable> params)`
`301`	`301`	`{`
`302`		`- return std::unique_ptr<Serializable>(new InternalResponse(callId, String(), std::move(params)));`
	`302`	`+ return std::unique_ptr<Serializable>(new InternalResponse(callId, nullptr, std::move(params)));`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`// static`
`306`		`-std::unique_ptr<Serializable> InternalResponse::createNotification(const String& notification, std::unique_ptr<Serializable> params)`
	`306`	`+std::unique_ptr<Serializable> InternalResponse::createNotification(const char* method, std::unique_ptr<Serializable> params)`
`307`	`307`	`{`
`308`		`- return std::unique_ptr<Serializable>(new InternalResponse(0, notification, std::move(params)));`
	`308`	`+ return std::unique_ptr<Serializable>(new InternalResponse(0, method, std::move(params)));`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`// static`
`@@ -314,23 +314,39 @@ std::unique_ptr<Serializable> InternalResponse::createErrorResponse(int callId,`
`314`	`314`	`return ProtocolError::createErrorResponse(callId, code, message, nullptr);`
`315`	`315`	`}`
`316`	`316`
`317`		`-std::vector<uint8_t> InternalResponse::serializeToBinary()`
	`317`	`+void InternalResponse::AppendSerialized(std::vector<uint8_t>* out) const`
`318`	`318`	`{`
`319`		`- std::unique_ptr<DictionaryValue> result = DictionaryValue::create();`
`320`		`- std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());`
`321`		`- if (m_notification.length()) {`
`322`		`- result->setString("method", m_notification);`
`323`		`- result->setValue("params", SerializedValue::fromBinary(params->serializeToBinary()));`
	`319`	`+ using {{config.encoding_lib.namespace}}::cbor::NewCBOREncoder;`
	`320`	`+ using {{config.encoding_lib.namespace}}::StreamingParserHandler;`
	`321`	`+ using {{config.encoding_lib.namespace}}::Status;`
	`322`	`+ using {{config.encoding_lib.namespace}}::SpanFrom;`
	`323`	`+`
	`324`	`+ Status status;`
	`325`	`+ std::unique_ptr<StreamingParserHandler> encoder =`
	`326`	`+ NewCBOREncoder(out, &status);`
	`327`	`+ encoder->HandleMapBegin();`
	`328`	`+ if (m_method) {`
	`329`	`+ encoder->HandleString8(SpanFrom("method"));`
	`330`	`+ encoder->HandleString8(SpanFrom(m_method));`
	`331`	`+ encoder->HandleString8(SpanFrom("params"));`
`324`	`332`	`} else {`
`325`		`- result->setInteger("id", m_callId);`
`326`		`- result->setValue("result", SerializedValue::fromBinary(params->serializeToBinary()));`
	`333`	`+ encoder->HandleString8(SpanFrom("id"));`
	`334`	`+ encoder->HandleInt32(m_callId);`
	`335`	`+ encoder->HandleString8(SpanFrom("result"));`
`327`	`336`	`}`
`328`		`- return result->serializeToBinary();`
	`337`	`+ if (m_params) {`
	`338`	`+ m_params->AppendSerialized(out);`
	`339`	`+ } else {`
	`340`	`+ encoder->HandleMapBegin();`
	`341`	`+ encoder->HandleMapEnd();`
	`342`	`+ }`
	`343`	`+ encoder->HandleMapEnd();`
	`344`	`+ DCHECK(status.ok());`
`329`	`345`	`}`
`330`	`346`
`331`		`-InternalResponse::InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params)`
	`347`	`+InternalResponse::InternalResponse(int callId, const char* method, std::unique_ptr<Serializable> params)`
`332`	`348`	`: m_callId(callId)`
`333`		`- , m_notification(notification)`
	`349`	`+ , m_method(method)`
`334`	`350`	`, m_params(params ? std::move(params) : nullptr)`
`335`	`351`	`{`
`336`	`352`	`}`
Original file line number	Diff line number	Diff line change
`@@ -281,7 +281,7 @@ void Value::writeJSON(StringBuilder* output) const`
`281`	`281`	`StringUtil::builderAppend(*output, nullValueString, 4);`
`282`	`282`	`}`
`283`	`283`
`284`		`-void Value::writeBinary(std::vector<uint8_t>* bytes) const {`
	`284`	`+void Value::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`285`	`285`	`DCHECK(m_type == TypeNull);`
`286`	`286`	`bytes->push_back(cbor::EncodeNull());`
`287`	`287`	`}`
`@@ -299,12 +299,6 @@ String Value::toJSONString() const`
`299`	`299`	`return StringUtil::builderToString(result);`
`300`	`300`	`}`
`301`	`301`
`302`		`-std::vector<uint8_t> Value::serializeToBinary() {`
`303`		`- std::vector<uint8_t> bytes;`
`304`		`- writeBinary(&bytes);`
`305`		`- return bytes;`
`306`		`-}`
`307`		`-`
`308`	`302`	`bool FundamentalValue::asBoolean(bool* output) const`
`309`	`303`	`{`
`310`	`304`	`if (type() != TypeBoolean)`
`@@ -353,7 +347,7 @@ void FundamentalValue::writeJSON(StringBuilder* output) const`
`353`	`347`	`}`
`354`	`348`	`}`
`355`	`349`
`356`		`-void FundamentalValue::writeBinary(std::vector<uint8_t>* bytes) const {`
	`350`	`+void FundamentalValue::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`357`	`351`	`switch (type()) {`
`358`	`352`	`case TypeDouble:`
`359`	`353`	`cbor::EncodeDouble(m_doubleValue, bytes);`
`@@ -422,7 +416,7 @@ void EncodeString(const String& s, std::vector<uint8_t>* out) {`
`422`	`416`	`}`
`423`	`417`	`} // namespace`
`424`	`418`
`425`		`-void StringValue::writeBinary(std::vector<uint8_t>* bytes) const {`
	`419`	`+void StringValue::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`426`	`420`	`EncodeString(m_stringValue, bytes);`
`427`	`421`	`}`
`428`	`422`
`@@ -443,7 +437,7 @@ void BinaryValue::writeJSON(StringBuilder* output) const`
`443`	`437`	`StringUtil::builderAppendQuotedString(*output, m_binaryValue.toBase64());`
`444`	`438`	`}`
`445`	`439`
`446`		`-void BinaryValue::writeBinary(std::vector<uint8_t>* bytes) const {`
	`440`	`+void BinaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`447`	`441`	`cbor::EncodeBinary(span<uint8_t>(m_binaryValue.data(),`
`448`	`442`	`m_binaryValue.size()), bytes);`
`449`	`443`	`}`
`@@ -459,7 +453,11 @@ void SerializedValue::writeJSON(StringBuilder* output) const`
`459`	`453`	`StringUtil::builderAppend(*output, m_serializedJSON);`
`460`	`454`	`}`
`461`	`455`
`462`		`-void SerializedValue::writeBinary(std::vector<uint8_t>* output) const`
	`456`	`+std::vector<uint8_t> SerializedValue::TakeSerialized() && {`
	`457`	`+ return std::move(m_serializedBinary);`
	`458`	`+}`
	`459`	`+`
	`460`	`+void SerializedValue::AppendSerialized(std::vector<uint8_t>* output) const`
`463`	`461`	`{`
`464`	`462`	`DCHECK(type() == TypeSerialized);`
`465`	`463`	`output->insert(output->end(), m_serializedBinary.begin(), m_serializedBinary.end());`
`@@ -607,7 +605,7 @@ void DictionaryValue::writeJSON(StringBuilder* output) const`
`607`	`605`	`StringUtil::builderAppend(*output, '}');`
`608`	`606`	`}`
`609`	`607`
`610`		`-void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {`
	`608`	`+void DictionaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`611`	`609`	`cbor::EnvelopeEncoder encoder;`
`612`	`610`	`encoder.EncodeStart(bytes);`
`613`	`611`	`bytes->push_back(cbor::EncodeIndefiniteLengthMapStart());`
`@@ -616,7 +614,7 @@ void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {`
`616`	`614`	`Dictionary::const_iterator value = m_data.find(key);`
`617`	`615`	`DCHECK(value != m_data.cend() && value->second);`
`618`	`616`	`EncodeString(key, bytes);`
`619`		`- value->second->writeBinary(bytes);`
	`617`	`+ value->second->AppendSerialized(bytes);`
`620`	`618`	`}`
`621`	`619`	`bytes->push_back(cbor::EncodeStop());`
`622`	`620`	`encoder.EncodeStop(bytes);`
`@@ -656,12 +654,12 @@ void ListValue::writeJSON(StringBuilder* output) const`
`656`	`654`	`StringUtil::builderAppend(*output, ']');`
`657`	`655`	`}`
`658`	`656`
`659`		`-void ListValue::writeBinary(std::vector<uint8_t>* bytes) const {`
	`657`	`+void ListValue::AppendSerialized(std::vector<uint8_t>* bytes) const {`
`660`	`658`	`cbor::EnvelopeEncoder encoder;`
`661`	`659`	`encoder.EncodeStart(bytes);`
`662`	`660`	`bytes->push_back(cbor::EncodeIndefiniteLengthArrayStart());`
`663`	`661`	`for (size_t i = 0; i < m_data.size(); ++i) {`
`664`		`- m_data[i]->writeBinary(bytes);`
	`662`	`+ m_data[i]->AppendSerialized(bytes);`
`665`	`663`	`}`
`666`	`664`	`bytes->push_back(cbor::EncodeStop());`
`667`	`665`	`encoder.EncodeStop(bytes);`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public:`
`34`	`34`	`String local_json = ({{config.imported.from_imported_string % "std::move(json)"}});`
`35`	`35`	`StringUtil::builderAppend(*output, local_json);`
`36`	`36`	`}`
`37`		`- void writeBinary(std::vector<uint8_t>* output) const override {`
	`37`	`+ void AppendSerialized(std::vector<uint8_t>* output) const override {`
`38`	`38`	`m_exported->writeBinary(output);`
`39`	`39`	`}`
`40`	`40`	`std::unique_ptr<Value> clone() const override {`
`@@ -61,7 +61,7 @@ struct ValueConversions<{{"::".join(config.imported.namespace)}}::{{domain.domai`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`std::vector<uint8_t> binary;`
`64`		`- value->writeBinary(&binary);`
	`64`	`+ value->AppendSerialized(&binary);`
`65`	`65`	`auto result = {{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}::fromBinary(binary.data(), binary.size());`
`66`	`66`	`if (!result)`
`67`	`67`	`errors->addError("cannot parse");`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ std::unique_ptr<{{type.id}}> {{type.id}}::clone() const`
`107`	`107`
`108`	`108`	`void {{type.id}}::writeBinary(std::vector<uint8_t>* out) const`
`109`	`109`	`{`
`110`		`- toValue()->writeBinary(out);`
	`110`	`+ toValue()->AppendSerialized(out);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`// static`