Merge pull request #11822 from vespa-engine/balder/reduce-bytebuffer-exposure

Balder/reduce bytebuffer exposure

13 files changed, 117 insertions, 225 deletions

diff --git a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization4_2.cpp b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization4_2.cpp
index b90153c9517..0cfd2160497 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization4_2.cpp
+++ b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization4_2.cpp
@@ -24,8 +24,7 @@ ProtocolSerialization4_2::ProtocolSerialization4_2(
 {
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::GetCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::GetCommand& msg) const
 {
     buf.putString(msg.getDocumentId().toString());
     putBucket(msg.getBucket(), buf);
@@ -41,14 +40,12 @@ ProtocolSerialization4_2::onDecodeGetCommand(BBuf& buf) const
     document::Bucket bucket = getBucket(buf);
     api::Timestamp beforeTimestamp(SH::getLong(buf));
     bool headerOnly(SH::getBoolean(buf));
-    api::GetCommand::UP msg(
-            new api::GetCommand(bucket, did, headerOnly ? "[header]" : "[all]", beforeTimestamp));
+    auto msg = std::make_unique<api::GetCommand>(bucket, did, headerOnly ? "[header]" : "[all]", beforeTimestamp);
     onDecodeCommand(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::RemoveCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::RemoveCommand& msg) const
 {
     buf.putString(msg.getDocumentId().toString());
     putBucket(msg.getBucket(), buf);
@@ -62,13 +59,12 @@ ProtocolSerialization4_2::onDecodeRemoveCommand(BBuf& buf) const
     document::DocumentId did(SH::getString(buf));
     document::Bucket bucket = getBucket(buf);
     api::Timestamp timestamp(SH::getLong(buf));
-    api::RemoveCommand::UP msg(new api::RemoveCommand(bucket, did, timestamp));
+    auto msg = std::make_unique<api::RemoveCommand>(bucket, did, timestamp);
     onDecodeBucketInfoCommand(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::RevertCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::RevertCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     buf.putInt(msg.getRevertTokens().size());
@@ -86,13 +82,12 @@ ProtocolSerialization4_2::onDecodeRevertCommand(BBuf& buf) const
     for (uint32_t i=0, n=tokens.size(); i<n; ++i) {
         tokens[i] = SH::getLong(buf);
     }
-    api::RevertCommand::UP msg(new api::RevertCommand(bucket, tokens));
+    auto msg = std::make_unique<api::RevertCommand>(bucket, tokens);
     onDecodeBucketInfoCommand(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::CreateBucketCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::CreateBucketCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     onEncodeBucketInfoCommand(buf, msg);
@@ -102,13 +97,12 @@ api::StorageCommand::UP
 ProtocolSerialization4_2::onDecodeCreateBucketCommand(BBuf& buf) const
 {
     document::Bucket bucket = getBucket(buf);
-    api::CreateBucketCommand::UP msg(new api::CreateBucketCommand(bucket));
+    auto msg = std::make_unique<api::CreateBucketCommand>(bucket);
     onDecodeBucketInfoCommand(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::MergeBucketCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::MergeBucketCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     const std::vector<api::MergeBucketCommand::Node>& nodes(msg.getNodes());
@@ -135,14 +129,12 @@ ProtocolSerialization4_2::onDecodeMergeBucketCommand(BBuf& buf) const
         nodes.push_back(Node(index, sourceOnly));
     }
     api::Timestamp timestamp(SH::getLong(buf));
-    api::MergeBucketCommand::UP msg(
-            new api::MergeBucketCommand(bucket, nodes, timestamp));
+    auto msg = std::make_unique<api::MergeBucketCommand>(bucket, nodes, timestamp);
     onDecodeCommand(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::GetBucketDiffCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::GetBucketDiffCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     const std::vector<api::MergeBucketCommand::Node>& nodes(msg.getNodes());
@@ -174,8 +166,7 @@ ProtocolSerialization4_2::onDecodeGetBucketDiffCommand(BBuf& buf) const
         nodes.push_back(Node(index, sourceOnly));
     }
     api::Timestamp timestamp = SH::getLong(buf);
-    api::GetBucketDiffCommand::UP msg(
-            new api::GetBucketDiffCommand(bucket, nodes, timestamp));
+    auto msg = std::make_unique<api::GetBucketDiffCommand>(bucket, nodes, timestamp);
     std::vector<api::GetBucketDiffCommand::Entry>& entries(msg->getDiff());
     uint32_t entryCount = SH::getInt(buf);
     if (entryCount > buf.getRemaining()) {
@@ -190,8 +181,7 @@ ProtocolSerialization4_2::onDecodeGetBucketDiffCommand(BBuf& buf) const
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::ApplyBucketDiffCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::ApplyBucketDiffCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     const std::vector<api::MergeBucketCommand::Node>& nodes(msg.getNodes());
@@ -201,18 +191,15 @@ void ProtocolSerialization4_2::onEncode(
         buf.putBoolean(nodes[i].sourceOnly);
     }
     buf.putInt(msg.getMaxBufferSize());
-    const std::vector<api::ApplyBucketDiffCommand::Entry>& entries(
-            msg.getDiff());
+    const std::vector<api::ApplyBucketDiffCommand::Entry>& entries(msg.getDiff());
     buf.putInt(entries.size());
     for (uint32_t i=0; i<entries.size(); ++i) {
         onEncodeDiffEntry(buf, entries[i]._entry);
         buf.putString(entries[i]._docName);
         buf.putInt(entries[i]._headerBlob.size());
-        buf.putBytes(&entries[i]._headerBlob[0],
-                     entries[i]._headerBlob.size());
+        buf.putBytes(&entries[i]._headerBlob[0], entries[i]._headerBlob.size());
         buf.putInt(entries[i]._bodyBlob.size());
-        buf.putBytes(&entries[i]._bodyBlob[0],
-                     entries[i]._bodyBlob.size());
+        buf.putBytes(&entries[i]._bodyBlob[0], entries[i]._bodyBlob.size());
     }
     onEncodeBucketInfoCommand(buf, msg);
 }
@@ -231,8 +218,7 @@ ProtocolSerialization4_2::onDecodeApplyBucketDiffCommand(BBuf& buf) const
         nodes.push_back(Node(index, sourceOnly));
     }
     uint32_t maxBufferSize(SH::getInt(buf));
-    api::ApplyBucketDiffCommand::UP msg(
-            new api::ApplyBucketDiffCommand(bucket, nodes, maxBufferSize));
+    auto msg = std::make_unique<api::ApplyBucketDiffCommand>(bucket, nodes, maxBufferSize);
     std::vector<api::ApplyBucketDiffCommand::Entry>& entries(msg->getDiff());
     uint32_t entryCount = SH::getInt(buf);
     if (entryCount > buf.getRemaining()) {
@@ -248,15 +234,13 @@ ProtocolSerialization4_2::onDecodeApplyBucketDiffCommand(BBuf& buf) const
             buf.incPos(headerSize);
         }
         entries[i]._headerBlob.resize(headerSize);
-        buf.getBytes(&entries[i]._headerBlob[0],
-                     entries[i]._headerBlob.size());
+        buf.getBytes(&entries[i]._headerBlob[0], entries[i]._headerBlob.size());
         uint32_t bodySize = SH::getInt(buf);
         if (bodySize > buf.getRemaining()) {
             buf.incPos(bodySize);
         }
         entries[i]._bodyBlob.resize(bodySize);
-        buf.getBytes(&entries[i]._bodyBlob[0],
-                     entries[i]._bodyBlob.size());
+        buf.getBytes(&entries[i]._bodyBlob[0], entries[i]._bodyBlob.size());
     }
     onDecodeBucketInfoCommand(buf, *msg);
     return msg;
@@ -274,11 +258,9 @@ ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::RequestBucketInfoReply
 }
 
 api::StorageReply::UP
-ProtocolSerialization4_2::onDecodeRequestBucketInfoReply(const SCmd& cmd,
-                                                         BBuf& buf) const
+ProtocolSerialization4_2::onDecodeRequestBucketInfoReply(const SCmd& cmd, BBuf& buf) const
 {
-    api::RequestBucketInfoReply::UP msg(new api::RequestBucketInfoReply(
-                static_cast<const api::RequestBucketInfoCommand&>(cmd)));
+    auto msg  = std::make_unique<api::RequestBucketInfoReply>(static_cast<const api::RequestBucketInfoCommand&>(cmd));
     api::RequestBucketInfoReply::EntryVector & entries(msg->getBucketInfo());
     uint32_t entryCount = SH::getInt(buf);
     if (entryCount > buf.getRemaining()) {
@@ -294,8 +276,7 @@ ProtocolSerialization4_2::onDecodeRequestBucketInfoReply(const SCmd& cmd,
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::NotifyBucketChangeCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::NotifyBucketChangeCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     putBucketInfo(msg.getBucketInfo(), buf);
@@ -307,30 +288,25 @@ ProtocolSerialization4_2::onDecodeNotifyBucketChangeCommand(BBuf& buf) const
 {
     document::Bucket bucket = getBucket(buf);
     api::BucketInfo info(getBucketInfo(buf));
-    api::NotifyBucketChangeCommand::UP msg(
-            new api::NotifyBucketChangeCommand(bucket, info));
+    auto msg = std::make_unique<api::NotifyBucketChangeCommand>(bucket, info);
     onDecodeCommand(buf, *msg);
-    return api::StorageCommand::UP(msg.release());
+    return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::NotifyBucketChangeReply& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::NotifyBucketChangeReply& msg) const
 {
     onEncodeReply(buf, msg);
 }
 
 api::StorageReply::UP
-ProtocolSerialization4_2::onDecodeNotifyBucketChangeReply(const SCmd& cmd,
-                                                          BBuf& buf) const
+ProtocolSerialization4_2::onDecodeNotifyBucketChangeReply(const SCmd& cmd,BBuf& buf) const
 {
-    api::NotifyBucketChangeReply::UP msg(new api::NotifyBucketChangeReply(
-                static_cast<const api::NotifyBucketChangeCommand&>(cmd)));
+    auto msg = std::make_unique<api::NotifyBucketChangeReply>(static_cast<const api::NotifyBucketChangeCommand&>(cmd));
     onDecodeReply(buf, *msg);
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::SplitBucketCommand& msg) const
+void ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::SplitBucketCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     buf.putByte(msg.getMinSplitBits());
@@ -344,7 +320,7 @@ api::StorageCommand::UP
 ProtocolSerialization4_2::onDecodeSplitBucketCommand(BBuf& buf) const
 {
     document::Bucket bucket = getBucket(buf);
-    api::SplitBucketCommand::UP msg(new api::SplitBucketCommand(bucket));
+    auto msg = std::make_unique<api::SplitBucketCommand>(bucket);
     msg->setMinSplitBits(SH::getByte(buf));
     msg->setMaxSplitBits(SH::getByte(buf));
     msg->setMinByteSize(SH::getInt(buf));
@@ -353,30 +329,24 @@ ProtocolSerialization4_2::onDecodeSplitBucketCommand(BBuf& buf) const
     return msg;
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf&, const api::SetBucketStateCommand&) const
+void ProtocolSerialization4_2::onEncode(GBBuf&, const api::SetBucketStateCommand&) const
 {
-    throw vespalib::IllegalStateException("Unsupported serialization",
-                                          VESPA_STRLOC);
+    throw vespalib::IllegalStateException("Unsupported serialization", VESPA_STRLOC);
 }
 
 api::StorageCommand::UP
 ProtocolSerialization4_2::onDecodeSetBucketStateCommand(BBuf&) const
 {
-    throw vespalib::IllegalStateException("Unsupported deserialization",
-                                          VESPA_STRLOC);
+    throw vespalib::IllegalStateException("Unsupported deserialization", VESPA_STRLOC);
 }
 
-void ProtocolSerialization4_2::onEncode(
-        GBBuf&, const api::SetBucketStateReply&) const
+void ProtocolSerialization4_2::onEncode(GBBuf&, const api::SetBucketStateReply&) const
 {
-    throw vespalib::IllegalStateException("Unsupported serialization",
-                                          VESPA_STRLOC);
+    throw vespalib::IllegalStateException("Unsupported serialization", VESPA_STRLOC);
 }
 
 api::StorageReply::UP
-ProtocolSerialization4_2::onDecodeSetBucketStateReply(const SCmd&,
-                                                      BBuf&) const
+ProtocolSerialization4_2::onDecodeSetBucketStateReply(const SCmd&, BBuf&) const
 {
     throw vespalib::IllegalStateException("Unsupported deserialization", VESPA_STRLOC);
 }
@@ -404,11 +374,7 @@ ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::CreateVisitorCommand&
     buf.putBoolean(msg.getFieldSet() == "[header]");
     buf.putBoolean(msg.visitInconsistentBuckets());
     buf.putInt(vespalib::count_ms(msg.getQueueTimeout()));
-
-    uint32_t size = msg.getParameters().getSerializedSize();
-    char* docBuffer = buf.allocate(size);
-    document::ByteBuffer bbuf(docBuffer, size);
-    msg.getParameters().serialize(bbuf);
+    msg.getParameters().serialize(buf);
 
     onEncodeCommand(buf, msg);
 }
@@ -420,8 +386,7 @@ ProtocolSerialization4_2::onDecodeCreateVisitorCommand(BBuf& buf) const
     vespalib::stringref libraryName = SH::getString(buf);
     vespalib::stringref instanceId = SH::getString(buf);
     vespalib::stringref selection = SH::getString(buf);
-    api::CreateVisitorCommand::UP msg(
-            new api::CreateVisitorCommand(bucketSpace, libraryName, instanceId, selection));
+    auto msg = std::make_unique<api::CreateVisitorCommand>(bucketSpace, libraryName, instanceId, selection);
     msg->setVisitorCmdId(SH::getInt(buf));
     msg->setControlDestination(SH::getString(buf));
     msg->setDataDestination(SH::getString(buf));
@@ -450,7 +415,7 @@ ProtocolSerialization4_2::onDecodeCreateVisitorCommand(BBuf& buf) const
         msg->setVisitInconsistentBuckets();
     }
     msg->setQueueTimeout(std::chrono::milliseconds(SH::getInt(buf)));
-    msg->getParameters().deserialize(getTypeRepo(), buf);
+    msg->getParameters().deserialize(buf);
 
     onDecodeCommand(buf, *msg);
     msg->setVisitorDispatcherVersion(42);
@@ -458,8 +423,7 @@ ProtocolSerialization4_2::onDecodeCreateVisitorCommand(BBuf& buf) const
 }
 
 void
-ProtocolSerialization4_2::onEncode(
-        GBBuf& buf, const api::DestroyVisitorCommand& msg) const
+ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::DestroyVisitorCommand& msg) const
 {
     buf.putString(msg.getInstanceId());
     onEncodeCommand(buf, msg);
@@ -469,7 +433,7 @@ api::StorageCommand::UP
 ProtocolSerialization4_2::onDecodeDestroyVisitorCommand(BBuf& buf) const
 {
     vespalib::stringref instanceId = SH::getString(buf);
-    api::DestroyVisitorCommand::UP msg(new api::DestroyVisitorCommand(instanceId));
+    auto msg = std::make_unique<api::DestroyVisitorCommand>(instanceId);
     onDecodeCommand(buf, *msg);
     return msg;
 }
@@ -483,7 +447,7 @@ ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::DestroyVisitorReply& m
 api::StorageReply::UP
 ProtocolSerialization4_2::onDecodeDestroyVisitorReply(const SCmd& cmd, BBuf& buf) const
 {
-    api::DestroyVisitorReply::UP msg(new api::DestroyVisitorReply(static_cast<const api::DestroyVisitorCommand&>(cmd)));
+    auto msg = std::make_unique<api::DestroyVisitorReply>(static_cast<const api::DestroyVisitorCommand&>(cmd));
     onDecodeReply(buf, *msg);
     return msg;
 }
@@ -502,8 +466,7 @@ ProtocolSerialization4_2::onDecodeRemoveLocationCommand(BBuf& buf) const
     vespalib::stringref documentSelection = SH::getString(buf);
     document::Bucket bucket = getBucket(buf);
 
-    api::RemoveLocationCommand::UP msg;
-    msg.reset(new api::RemoveLocationCommand(documentSelection, bucket));
+    auto msg = std::make_unique<api::RemoveLocationCommand>(documentSelection, bucket);
     onDecodeCommand(buf, *msg);
     return msg;
 }
@@ -517,7 +480,7 @@ ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::RemoveLocationReply& m
 api::StorageReply::UP
 ProtocolSerialization4_2::onDecodeRemoveLocationReply(const SCmd& cmd, BBuf& buf) const
 {
-    api::RemoveLocationReply::UP msg(new api::RemoveLocationReply(static_cast<const api::RemoveLocationCommand&>(cmd)));
+    auto msg = std::make_unique<api::RemoveLocationReply>(static_cast<const api::RemoveLocationCommand&>(cmd));
     onDecodeBucketInfoReply(buf, *msg);
     return msg;
 }
@@ -525,15 +488,13 @@ ProtocolSerialization4_2::onDecodeRemoveLocationReply(const SCmd& cmd, BBuf& buf
 // Utility functions for serialization
 
 void
-ProtocolSerialization4_2::onEncodeBucketInfoCommand(
-            GBBuf& buf, const api::BucketInfoCommand& msg) const
+ProtocolSerialization4_2::onEncodeBucketInfoCommand(GBBuf& buf, const api::BucketInfoCommand& msg) const
 {
     onEncodeCommand(buf, msg);
 }
 
 void
-ProtocolSerialization4_2::onDecodeBucketInfoCommand(
-            BBuf& buf, api::BucketInfoCommand& msg) const
+ProtocolSerialization4_2::onDecodeBucketInfoCommand(BBuf& buf, api::BucketInfoCommand& msg) const
 {
     onDecodeCommand(buf, msg);
 }
@@ -547,8 +508,7 @@ ProtocolSerialization4_2::onEncode(GBBuf& buf, const api::ReturnCode& rc) const
 }
 
 void
-ProtocolSerialization4_2::onEncodeDiffEntry(
-        GBBuf& buf, const api::GetBucketDiffCommand::Entry& entry) const
+ProtocolSerialization4_2::onEncodeDiffEntry(GBBuf& buf, const api::GetBucketDiffCommand::Entry& entry) const
 {
     buf.putLong(entry._timestamp);
     SH::putGlobalId(entry._gid, buf);
@@ -559,8 +519,7 @@ ProtocolSerialization4_2::onEncodeDiffEntry(
 }
 
 void
-ProtocolSerialization4_2::onDecodeDiffEntry(
-        BBuf& buf, api::GetBucketDiffCommand::Entry& entry) const
+ProtocolSerialization4_2::onDecodeDiffEntry(BBuf& buf, api::GetBucketDiffCommand::Entry& entry) const
 {
     entry._timestamp = SH::getLong(buf);
     entry._gid = SH::getGlobalId(buf);
diff --git a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization5_1.cpp b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization5_1.cpp
index b0a1685ed8c..0b1f66127ba 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization5_1.cpp
+++ b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization5_1.cpp
@@ -62,32 +62,26 @@ ProtocolSerialization5_1::onDecodeSetBucketStateCommand(BBuf& buf) const
 {
     document::Bucket bucket = getBucket(buf);
     api::SetBucketStateCommand::BUCKET_STATE state(
-            static_cast<api::SetBucketStateCommand::BUCKET_STATE>(
-                    SH::getByte(buf)));
-    api::SetBucketStateCommand::UP msg(
-            new api::SetBucketStateCommand(bucket, state));
+            static_cast<api::SetBucketStateCommand::BUCKET_STATE>(SH::getByte(buf)));
+    auto msg = std::make_unique<api::SetBucketStateCommand>(bucket, state);
     onDecodeCommand(buf, *msg);
-    return api::StorageCommand::UP(msg.release());
+    return msg;
 }
 
-void ProtocolSerialization5_1::onEncode(
-        GBBuf& buf, const api::SetBucketStateReply& msg) const
+void ProtocolSerialization5_1::onEncode(GBBuf& buf, const api::SetBucketStateReply& msg) const
 {
     onEncodeBucketReply(buf, msg);
 }
 
 api::StorageReply::UP
-ProtocolSerialization5_1::onDecodeSetBucketStateReply(const SCmd& cmd,
-                                                      BBuf& buf) const
+ProtocolSerialization5_1::onDecodeSetBucketStateReply(const SCmd& cmd, BBuf& buf) const
 {
-    api::SetBucketStateReply::UP msg(new api::SetBucketStateReply(
-                static_cast<const api::SetBucketStateCommand&>(cmd)));
+    auto msg = std::make_unique<api::SetBucketStateReply>(static_cast<const api::SetBucketStateCommand&>(cmd));
     onDecodeBucketReply(buf, *msg);
-    return api::StorageReply::UP(msg.release());
+    return msg;
 }
 
-void ProtocolSerialization5_1::onEncode(
-        GBBuf& buf, const api::GetCommand& msg) const
+void ProtocolSerialization5_1::onEncode(GBBuf& buf, const api::GetCommand& msg) const
 {
     buf.putString(msg.getDocumentId().toString());
     putBucket(msg.getBucket(), buf);
@@ -103,15 +97,13 @@ ProtocolSerialization5_1::onDecodeGetCommand(BBuf& buf) const
     document::Bucket bucket = getBucket(buf);
     api::Timestamp beforeTimestamp(SH::getLong(buf));
     std::string fieldSet(SH::getString(buf));
-    api::GetCommand::UP msg(
-            new api::GetCommand(bucket, did, fieldSet, beforeTimestamp));
+    auto msg = std::make_unique<api::GetCommand>(bucket, did, fieldSet, beforeTimestamp);
     onDecodeCommand(buf, *msg);
-    return api::StorageCommand::UP(msg.release());
+    return msg;
 }
 
 void
-ProtocolSerialization5_1::onEncode(
-        GBBuf& buf, const api::CreateVisitorCommand& msg) const
+ProtocolSerialization5_1::onEncode(GBBuf& buf, const api::CreateVisitorCommand& msg) const
 {
     putBucketSpace(msg.getBucketSpace(), buf);
     buf.putString(msg.getLibraryName());
@@ -133,11 +125,7 @@ ProtocolSerialization5_1::onEncode(
     buf.putString(msg.getFieldSet());
     buf.putBoolean(msg.visitInconsistentBuckets());
     buf.putInt(vespalib::count_ms(msg.getQueueTimeout()));
-
-    uint32_t size = msg.getParameters().getSerializedSize();
-    char* docBuffer = buf.allocate(size);
-    document::ByteBuffer bbuf(docBuffer, size);
-    msg.getParameters().serialize(bbuf);
+    msg.getParameters().serialize(buf);
 
     onEncodeCommand(buf, msg);
 
@@ -152,8 +140,7 @@ ProtocolSerialization5_1::onDecodeCreateVisitorCommand(BBuf& buf) const
     vespalib::stringref libraryName = SH::getString(buf);
     vespalib::stringref instanceId = SH::getString(buf);
     vespalib::stringref selection = SH::getString(buf);
-    api::CreateVisitorCommand::UP msg(
-            new api::CreateVisitorCommand(bucketSpace, libraryName, instanceId, selection));
+    auto msg = std::make_unique<api::CreateVisitorCommand>(bucketSpace, libraryName, instanceId, selection);
     msg->setVisitorCmdId(SH::getInt(buf));
     msg->setControlDestination(SH::getString(buf));
     msg->setDataDestination(SH::getString(buf));
@@ -182,17 +169,16 @@ ProtocolSerialization5_1::onDecodeCreateVisitorCommand(BBuf& buf) const
         msg->setVisitInconsistentBuckets();
     }
     msg->setQueueTimeout(std::chrono::milliseconds(SH::getInt(buf)));
-    msg->getParameters().deserialize(getTypeRepo(), buf);
+    msg->getParameters().deserialize(buf);
 
     onDecodeCommand(buf, *msg);
     SH::getInt(buf); // Unused
     msg->setMaxBucketsPerVisitor(SH::getInt(buf));
     msg->setVisitorDispatcherVersion(50);
-    return api::StorageCommand::UP(msg.release());
+    return msg;
 }
 
-void ProtocolSerialization5_1::onEncode(
-        GBBuf& buf, const api::CreateBucketCommand& msg) const
+void ProtocolSerialization5_1::onEncode(GBBuf& buf, const api::CreateBucketCommand& msg) const
 {
     putBucket(msg.getBucket(), buf);
     buf.putBoolean(msg.getActive());
@@ -204,10 +190,10 @@ ProtocolSerialization5_1::onDecodeCreateBucketCommand(BBuf& buf) const
 {
     document::Bucket bucket = getBucket(buf);
     bool setActive = SH::getBoolean(buf);
-    api::CreateBucketCommand::UP msg(new api::CreateBucketCommand(bucket));
+    auto msg = std::make_unique<api::CreateBucketCommand>(bucket);
     msg->setActive(setActive);
     onDecodeBucketInfoCommand(buf, *msg);
-    return api::StorageCommand::UP(msg.release());
+    return msg;
 }
 
 }
diff --git a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization7.cpp b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization7.cpp
index ea002ab98ed..9751fd1be98 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/protocolserialization7.cpp
+++ b/storageapi/src/vespa/storageapi/mbusprot/protocolserialization7.cpp
@@ -85,7 +85,7 @@ std::shared_ptr<document::Document> get_document(const protobuf::Document& src_d
                                                  const document::DocumentTypeRepo& type_repo)
 {
     if (!src_doc.payload().empty()) {
-        document::ByteBuffer doc_buf(src_doc.payload().data(), src_doc.payload().size());
+        vespalib::nbostream doc_buf(src_doc.payload().data(), src_doc.payload().size());
         return std::make_shared<document::Document>(type_repo, doc_buf);
     }
     return std::shared_ptr<document::Document>();
diff --git a/storageapi/src/vespa/storageapi/mbusprot/serializationhelper.h b/storageapi/src/vespa/storageapi/mbusprot/serializationhelper.h
index 08cec601cce..24cc3e4371d 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/serializationhelper.h
+++ b/storageapi/src/vespa/storageapi/mbusprot/serializationhelper.h
@@ -87,9 +87,9 @@ public:
         if (size == 0) {
             return document::Document::UP();
         } else {
-            document::ByteBuffer bbuf(buf.getBufferAtPos(), size);
+            vespalib::nbostream stream(buf.getBufferAtPos(), size);
             buf.incPos(size);
-            return document::Document::UP(new document::Document(repo, bbuf));
+            return std::make_unique<document::Document>(repo, stream);
         }
     }
 
diff --git a/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp b/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
index 469c6a41bc7..596af6a79d4 100644
--- a/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
+++ b/storageapi/src/vespa/storageapi/mbusprot/storagereply.cpp
@@ -3,6 +3,8 @@
 #include "storagereply.h"
 #include "storagecommand.h"
 #include <vespa/vespalib/util/exceptions.h>
+#include <vespa/vespalib/objects/nbostream.h>
+
 
 using vespalib::alloc::Alloc;
 using vespalib::IllegalStateException;
@@ -17,8 +19,8 @@ StorageReply::StorageReply(mbus::BlobRef data, const ProtocolSerialization& seri
       _reply()
 {
     memcpy(_buffer.get(), data.data(), _sz);
-    document::ByteBuffer buf(data.data(), _sz);
-    buf.getIntNetwork(reinterpret_cast<int32_t&>(_mbusType));
+    vespalib::nbostream nbo(data.data(), _sz);
+    nbo >> _mbusType;
 }
 
 StorageReply::StorageReply(api::StorageReply::SP reply)
diff --git a/storageapi/src/vespa/storageapi/message/bucket.cpp b/storageapi/src/vespa/storageapi/message/bucket.cpp
index ee8aff31914..de47a52ca9d 100644
--- a/storageapi/src/vespa/storageapi/message/bucket.cpp
+++ b/storageapi/src/vespa/storageapi/message/bucket.cpp
@@ -3,6 +3,7 @@
 #include "bucket.h"
 #include <vespa/document/fieldvalue/document.h>
 #include <vespa/vespalib/stllike/asciistream.h>
+#include <vespa/vespalib/objects/nbostream.h>
 #include <vespa/vespalib/util/array.hpp>
 #include <ostream>
 #include <iterator>
@@ -319,7 +320,7 @@ ApplyBucketDiffCommand::Entry::print(
         << "), headerBlob(" << _headerBlob.size()
         << "), bodyBlob(" << _bodyBlob.size() << ")";
     if (_headerBlob.size() > 0) {
-        document::ByteBuffer buf(&_headerBlob[0],
+        vespalib::nbostream buf(&_headerBlob[0],
                                  _headerBlob.size());
         if (_repo) {
             document::Document doc(*_repo, buf);
diff --git a/storageapi/src/vespa/storageapi/message/bucket.h b/storageapi/src/vespa/storageapi/message/bucket.h
index f6185d9f8e7..45af2296e8a 100644
--- a/storageapi/src/vespa/storageapi/message/bucket.h
+++ b/storageapi/src/vespa/storageapi/message/bucket.h
@@ -14,12 +14,12 @@
 #include <vespa/storageapi/messageapi/maintenancecommand.h>
 #include <vespa/document/base/globalid.h>
 #include <vespa/vdslib/state/clusterstate.h>
+#include <vespa/vespalib/util/array.h>
 #include <vespa/storageapi/defs.h>
 
 namespace document { class DocumentTypeRepo; }
 
-namespace storage {
-namespace api {
+namespace storage::api {
 
 /**
  * @class CreateBucketCommand
@@ -254,6 +254,8 @@ public:
         GetBucketDiffCommand::Entry _entry;
         vespalib::string _docName;
         std::vector<char> _headerBlob;
+        // TODO: In theory the body blob could be removed now as all is in one blob
+        // That will enable simplification of code in document.
         std::vector<char> _bodyBlob;
         const document::DocumentTypeRepo *_repo;
 
@@ -282,7 +284,7 @@ public:
     ApplyBucketDiffCommand(const document::Bucket &bucket,
                            const std::vector<Node>& nodes,
                            uint32_t maxBufferSize);
-    ~ApplyBucketDiffCommand();
+    ~ApplyBucketDiffCommand() override;
 
     const std::vector<Node>& getNodes() const { return _nodes; }
     const std::vector<Entry>& getDiff() const { return _diff; }
@@ -482,5 +484,4 @@ public:
     DECLARE_STORAGEREPLY(SetBucketStateReply, onSetBucketStateReply)
 };
 
-} // api
-} // storage
+}
diff --git a/storageapi/src/vespa/storageapi/message/persistence.cpp b/storageapi/src/vespa/storageapi/message/persistence.cpp
index 1463f42abeb..7fd789a8c81 100644
--- a/storageapi/src/vespa/storageapi/message/persistence.cpp
+++ b/storageapi/src/vespa/storageapi/message/persistence.cpp
@@ -60,7 +60,7 @@ PutCommand::print(std::ostream& out, bool verbose, const std::string& indent) co
 {
     out << "Put(" << getBucketId() << ", " << _doc->getId()
         << ", timestamp " << _timestamp << ", size "
-        << _doc->serialize()->getLength() << ")";
+        << _doc->serialize().size() << ")";
     if (verbose) {
         out << " {\n" << indent << "  ";
         _doc->print(out, verbose, indent + "  ");
diff --git a/storageapi/src/vespa/storageapi/message/visitor.cpp b/storageapi/src/vespa/storageapi/message/visitor.cpp
index aeb58f30fb4..e531e73fea5 100644
--- a/storageapi/src/vespa/storageapi/message/visitor.cpp
+++ b/storageapi/src/vespa/storageapi/message/visitor.cpp
@@ -65,7 +65,7 @@ CreateVisitorCommand::CreateVisitorCommand(const CreateVisitorCommand& o)
 {
 }
 
-CreateVisitorCommand::~CreateVisitorCommand() {}
+CreateVisitorCommand::~CreateVisitorCommand() = default;
 
 document::Bucket
 CreateVisitorCommand::getBucket() const
@@ -141,8 +141,7 @@ DestroyVisitorCommand::DestroyVisitorCommand(vespalib::stringref instanceId)
 }
 
 void
-DestroyVisitorCommand::print(std::ostream& out, bool verbose,
-                             const std::string& indent) const
+DestroyVisitorCommand::print(std::ostream& out, bool verbose, const std::string& indent) const
 {
     out << "DestroyVisitorCommand(" << _instanceId << ")";
     if (verbose) {
@@ -157,8 +156,7 @@ DestroyVisitorReply::DestroyVisitorReply(const DestroyVisitorCommand& cmd)
 }
 
 void
-DestroyVisitorReply::print(std::ostream& out, bool verbose,
-                           const std::string& indent) const
+DestroyVisitorReply::print(std::ostream& out, bool verbose, const std::string& indent) const
 {
     out << "DestroyVisitorReply()";
     if (verbose) {
@@ -175,12 +173,10 @@ VisitorInfoCommand::VisitorInfoCommand()
 {
 }
 
-VisitorInfoCommand::~VisitorInfoCommand() {
-}
+VisitorInfoCommand::~VisitorInfoCommand() = default;
 
 void
-VisitorInfoCommand::print(std::ostream& out, bool verbose,
-                          const std::string& indent) const
+VisitorInfoCommand::print(std::ostream& out, bool verbose, const std::string& indent) const
 {
     out << "VisitorInfoCommand(";
     if (_completed) { out << "completed"; }
@@ -205,8 +201,7 @@ VisitorInfoReply::VisitorInfoReply(const VisitorInfoCommand& cmd)
 }
 
 void
-VisitorInfoReply::print(std::ostream& out, bool verbose,
-                        const std::string& indent) const
+VisitorInfoReply::print(std::ostream& out, bool verbose, const std::string& indent) const
 {
     out << "VisitorInfoReply(";
     if (_completed) { out << "completed"; }
diff --git a/storageapi/src/vespa/storageapi/messageapi/returncode.cpp b/storageapi/src/vespa/storageapi/messageapi/returncode.cpp
index 68fbca75393..1868e53e4a5 100644
--- a/storageapi/src/vespa/storageapi/messageapi/returncode.cpp
+++ b/storageapi/src/vespa/storageapi/messageapi/returncode.cpp
@@ -3,8 +3,7 @@
 #include "returncode.h"
 #include <ostream>
 
-namespace storage {
-namespace api {
+namespace storage::api {
 
 ReturnCode::ReturnCode()
     : _result(OK),
@@ -14,58 +13,32 @@ ReturnCode::ReturnCode()
 ReturnCode::ReturnCode(const ReturnCode &) = default;
 ReturnCode & ReturnCode::operator = (const ReturnCode &) = default;
 ReturnCode & ReturnCode::operator = (ReturnCode &&) = default;
-ReturnCode::~ReturnCode() {}
+ReturnCode::~ReturnCode() = default;
 
 ReturnCode::ReturnCode(Result result, vespalib::stringref msg)
     : _result(result),
       _message(msg)
 {}
 
-ReturnCode::ReturnCode(const document::DocumentTypeRepo &repo,
-                       document::ByteBuffer& buffer)
-    : _result(OK),
-      _message()
-{
-    deserialize(repo, buffer);
-}
-
-void ReturnCode::
-onDeserialize(const document::DocumentTypeRepo &, document::ByteBuffer& buffer)
-{
-    int32_t result;
-    buffer.getInt(result);
-    _result = static_cast<Result>(result);
-    int32_t size;
-    buffer.getInt(size);
-    const char * p = buffer.getBufferAtPos();
-    buffer.incPos(size);
-    _message.assign(p, size);
-}
-
-void ReturnCode::onSerialize(document::ByteBuffer& buffer) const
-{
-    buffer.putInt(_result);
-    buffer.putInt(_message.size());
-    buffer.putBytes(_message.c_str(), _message.size());
-}
-
-size_t ReturnCode::getSerializedSize() const
-{
-    return 2 * sizeof(int32_t) + _message.size();
+vespalib::string ReturnCode::getResultString(Result result) {
+    return documentapi::DocumentProtocol::getErrorName(result);
 }
 
-void
-ReturnCode::print(std::ostream& out, bool verbose,
-                  const std::string& indent) const
-{
-    (void) verbose; (void) indent;
-    out << "ReturnCode(" << ReturnCode::getResultString(getResult());
-    if (getMessage().size() > 0) out << ", " << getMessage();
-    out << ")";
+vespalib::string
+ReturnCode::toString() const {
+    vespalib::string ret = "ReturnCode(";
+    ret += getResultString(_result);
+    if ( ! _message.empty()) {
+        ret += ", ";
+        ret += _message;
+    }
+    ret += ")";
+    return ret;
 }
 
-vespalib::string ReturnCode::getResultString(Result result) {
-    return documentapi::DocumentProtocol::getErrorName(result);
+std::ostream &
+operator << (std::ostream & os, const ReturnCode & returnCode) {
+    return os << returnCode.toString();
 }
 
 bool
@@ -173,5 +146,4 @@ ReturnCode::isBucketDisappearance() const
     }
 }
 
-} // api
-} // storage
+}
diff --git a/storageapi/src/vespa/storageapi/messageapi/returncode.h b/storageapi/src/vespa/storageapi/messageapi/returncode.h
index ccd95a81aa3..305a998918c 100644
--- a/storageapi/src/vespa/storageapi/messageapi/returncode.h
+++ b/storageapi/src/vespa/storageapi/messageapi/returncode.h
@@ -10,20 +10,12 @@
 
 #pragma once
 
-#include <vespa/vespalib/util/printable.h>
-#include <vespa/document/util/serializable.h>
 #include <vespa/documentapi/messagebus/documentprotocol.h>
-#include <iosfwd>
 
-namespace document {
-    class ByteBuffer;
-}
 
-namespace storage {
-namespace api {
+namespace storage::api {
 
-class ReturnCode : public document::Deserializable,
-                   public vespalib::Printable {
+class ReturnCode {
 public:
     typedef documentapi::DocumentProtocol Protocol;
 
@@ -68,31 +60,20 @@ public:
 private:
     Result _result;
     vespalib::string _message;
-    void onDeserialize(const document::DocumentTypeRepo &repo, document::ByteBuffer& buffer) override;
-    void onSerialize(document::ByteBuffer& buffer) const override;
-
 public:
     ReturnCode();
     explicit ReturnCode(Result result, vespalib::stringref msg = "");
-    ReturnCode(const document::DocumentTypeRepo &repo,
-               document::ByteBuffer& buffer);
     ReturnCode(const ReturnCode &);
     ReturnCode & operator = (const ReturnCode &);
     ReturnCode(ReturnCode &&) = default;
     ReturnCode & operator = (ReturnCode &&);
     ~ReturnCode();
 
-    ReturnCode* clone() const override { return new ReturnCode(*this); }
-
-    size_t getSerializedSize() const override;
-
     const vespalib::string& getMessage() const { return _message; }
     void setMessage(vespalib::stringref message) { _message = message; }
 
     Result getResult() const { return _result; }
 
-    void print(std::ostream& out, bool verbose, const std::string& indent) const override;
-
     /**
      * Translate from status code to human-readable string
      * @param result Status code returned from getResult()
@@ -121,8 +102,9 @@ public:
     bool isShutdownRelated() const;
     bool isBucketDisappearance() const;
     bool isNonCriticalForIntegrityChecker() const;
+    vespalib::string toString() const;
 };
 
+std::ostream & operator << (std::ostream & os, const ReturnCode & returnCode);
 
-} // api
-} // storage
+}
diff --git a/storageapi/src/vespa/storageapi/messageapi/storagereply.cpp b/storageapi/src/vespa/storageapi/messageapi/storagereply.cpp
index 86f7cb6e16d..81cdadb3623 100644
--- a/storageapi/src/vespa/storageapi/messageapi/storagereply.cpp
+++ b/storageapi/src/vespa/storageapi/messageapi/storagereply.cpp
@@ -4,8 +4,7 @@
 #include "storagecommand.h"
 #include <ostream>
 
-namespace storage {
-namespace api {
+namespace storage::api {
 
 StorageReply::StorageReply(const StorageCommand& cmd, ReturnCode code)
     : StorageMessage(cmd.getType().getReplyType(), cmd.getMsgId()),
@@ -19,16 +18,14 @@ StorageReply::StorageReply(const StorageCommand& cmd, ReturnCode code)
     setTransportContext(cmd.getTransportContext());
 }
 
-StorageReply::~StorageReply() { }
+StorageReply::~StorageReply() = default;
 
 void
 StorageReply::print(std::ostream& out, bool verbose,
                     const std::string& indent) const
 {
     (void) verbose; (void) indent;
-    out << "StorageReply(" << _type.getName() << ", "
-        << _result.toString() << ")";
+    out << "StorageReply(" << _type.getName() << ", " << _result << ")";
 }
 
-} // api
-} // storage
+}
diff --git a/storageapi/src/vespa/storageapi/messageapi/storagereply.h b/storageapi/src/vespa/storageapi/messageapi/storagereply.h
index 4219f3e28cd..1a3bbe35eb4 100644
--- a/storageapi/src/vespa/storageapi/messageapi/storagereply.h
+++ b/storageapi/src/vespa/storageapi/messageapi/storagereply.h
@@ -15,8 +15,7 @@
 #include "returncode.h"
 #include "storagemessage.h"
 
-namespace storage {
-namespace api {
+namespace storage::api {
 
 class StorageCommand;
 
@@ -28,7 +27,7 @@ protected:
                           ReturnCode code = ReturnCode(ReturnCode::OK));
 
 public:
-    ~StorageReply();
+    ~StorageReply() override;
     DECLARE_POINTER_TYPEDEFS(StorageReply);
 
     void setResult(const ReturnCode& r) { _result = r; }
@@ -37,6 +36,4 @@ public:
     void print(std::ostream& out, bool verbose, const std::string& indent) const override;
 };
 
-} // api
-} // storage
-
+}