Remove explicit ack and use feedtoken as a smartptr

7 files changed, 110 insertions, 171 deletions

diff --git a/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp b/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
index d4af7b214b6..a997b3cc3db 100644
--- a/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/combiningfeedview/combiningfeedview_test.cpp
@@ -72,22 +72,20 @@ struct MyFeedView : public test::DummyFeedView
         _metaStore.constructFreeList();
     }
 
-    // Implements IFeedView
-    virtual const DocumentMetaStore *getDocumentMetaStorePtr() const override { return &_metaStore; }
-    virtual void preparePut(PutOperation &) override { ++_preparePut; }
-    virtual void handlePut(FeedToken *, const PutOperation &) override { ++_handlePut; }
-    virtual void prepareUpdate(UpdateOperation &) override { ++_prepareUpdate; }
-    virtual void handleUpdate(FeedToken *, const UpdateOperation &) override { ++_handleUpdate; }
-    virtual void prepareRemove(RemoveOperation &) override { ++_prepareRemove; }
-    virtual void handleRemove(FeedToken *, const RemoveOperation &) override { ++_handleRemove; }
-    virtual void prepareDeleteBucket(DeleteBucketOperation &) override { ++_prepareDeleteBucket; }
-    virtual void handleDeleteBucket(const DeleteBucketOperation &) override
-    { ++_handleDeleteBucket; }
-    virtual void prepareMove(MoveOperation &) override { ++_prepareMove; }
-    virtual void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++_handleMove; }
-    virtual void heartBeat(SerialNum) override { ++_heartBeat; }
-    virtual void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++_handlePrune; }
-    virtual void handleCompactLidSpace(const CompactLidSpaceOperation &op) override {
+    const DocumentMetaStore *getDocumentMetaStorePtr() const override { return &_metaStore; }
+    void preparePut(PutOperation &) override { ++_preparePut; }
+    void handlePut(FeedToken, const PutOperation &) override { ++_handlePut; }
+    void prepareUpdate(UpdateOperation &) override { ++_prepareUpdate; }
+    void handleUpdate(FeedToken, const UpdateOperation &) override { ++_handleUpdate; }
+    void prepareRemove(RemoveOperation &) override { ++_prepareRemove; }
+    void handleRemove(FeedToken, const RemoveOperation &) override { ++_handleRemove; }
+    void prepareDeleteBucket(DeleteBucketOperation &) override { ++_prepareDeleteBucket; }
+    void handleDeleteBucket(const DeleteBucketOperation &) override { ++_handleDeleteBucket; }
+    void prepareMove(MoveOperation &) override { ++_prepareMove; }
+    void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++_handleMove; }
+    void heartBeat(SerialNum) override { ++_heartBeat; }
+    void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++_handlePrune; }
+    void handleCompactLidSpace(const CompactLidSpaceOperation &op) override {
         _wantedLidLimit = op.getLidLimit();
     }
 };
@@ -213,7 +211,7 @@ TEST_F("require that handlePut() sends to 1 feed view", Fixture)
 {
     PutOperation op = f.put(2);
     op.setDbDocumentId(DbDocumentId(READY, 2));
-    f._view.handlePut(NULL, op);
+    f._view.handlePut(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handlePut);
     EXPECT_EQUAL(0u, f._removed._view->_handlePut);
     EXPECT_EQUAL(0u, f._notReady._view->_handlePut);
@@ -225,7 +223,7 @@ TEST_F("require that handlePut() sends to 2 feed views", Fixture)
     PutOperation op = f.put(2);
     op.setDbDocumentId(DbDocumentId(NOT_READY, 2));
     op.setPrevDbDocumentId(DbDocumentId(REMOVED, 2));
-    f._view.handlePut(NULL, op);
+    f._view.handlePut(FeedToken(), op);
     EXPECT_EQUAL(0u, f._ready._view->_handlePut);
     EXPECT_EQUAL(1u, f._removed._view->_handlePut);
     EXPECT_EQUAL(1u, f._notReady._view->_handlePut);
@@ -259,7 +257,7 @@ TEST_F("require that handleRemove() sends op with valid dbdId to 1 feed view", F
 {
     RemoveOperation op = f.remove(1);
     op.setDbDocumentId(DbDocumentId(REMOVED, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(0u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(1u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -271,7 +269,7 @@ TEST_F("require that handleRemove() sends op with valid dbdId to 2 feed views",
     RemoveOperation op = f.remove(1);
     op.setDbDocumentId(DbDocumentId(REMOVED, 1));
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(1u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -283,7 +281,7 @@ TEST_F("require that handleRemove() sends op with invalid dbdId to prev view", F
     RemoveOperation op = f.remove(1);
     // can be used in the case where removed feed view does not remember removes.
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleRemove(NULL, op);
+    f._view.handleRemove(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleRemove);
     EXPECT_EQUAL(0u, f._removed._view->_handleRemove);
     EXPECT_EQUAL(0u, f._notReady._view->_handleRemove);
@@ -317,7 +315,7 @@ TEST_F("require that handleUpdate() sends op to correct view", Fixture)
     UpdateOperation op = f.update(1);
     op.setDbDocumentId(DbDocumentId(READY, 1));
     op.setPrevDbDocumentId(DbDocumentId(READY, 1));
-    f._view.handleUpdate(NULL, op);
+    f._view.handleUpdate(FeedToken(), op);
     EXPECT_EQUAL(1u, f._ready._view->_handleUpdate);
     EXPECT_EQUAL(0u, f._removed._view->_handleUpdate);
     EXPECT_EQUAL(0u, f._notReady._view->_handleUpdate);
diff --git a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
index 547e400cd76..8369ec0630d 100644
--- a/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/document_subdbs/document_subdbs_test.cpp
@@ -745,18 +745,15 @@ struct DocumentHandler
         op.setSerialNum(serialNum);
         return op;
     }
-    MoveOperation createMove(Document::UP doc, Timestamp timestamp,
-                             DbDocumentId sourceDbdId,
-                             uint32_t targetSubDbId,
-                             SerialNum serialNum)
+    MoveOperation createMove(Document::UP doc, Timestamp timestamp, DbDocumentId sourceDbdId,
+                             uint32_t targetSubDbId, SerialNum serialNum)
     {
         proton::test::Document testDoc(Document::SP(doc.release()), 0, timestamp);
         MoveOperation op(testDoc.getBucket(), testDoc.getTimestamp(), testDoc.getDoc(), sourceDbdId, targetSubDbId);
         op.setSerialNum(serialNum);
         return op;
     }
-    RemoveOperation createRemove(const DocumentId &docId, Timestamp timestamp,
-                                 SerialNum serialNum)
+    RemoveOperation createRemove(const DocumentId &docId, Timestamp timestamp, SerialNum serialNum)
     {
         const document::GlobalId &gid = docId.getGlobalId();
         BucketId bucket = gid.convertToBucketId();
@@ -769,7 +766,7 @@ struct DocumentHandler
     void putDoc(PutOperation &op) {
         IFeedView::SP feedView = _f._subDb.getFeedView();
         _f.runInMaster([&]() {    feedView->preparePut(op);
-                                  feedView->handlePut(NULL, op); } );
+                                  feedView->handlePut(FeedToken(), op); } );
     }
     void moveDoc(MoveOperation &op) {
         IFeedView::SP feedView = _f._subDb.getFeedView();
@@ -779,11 +776,10 @@ struct DocumentHandler
     {
         IFeedView::SP feedView = _f._subDb.getFeedView();
         _f.runInMaster([&]() {    feedView->prepareRemove(op);
-                                  feedView->handleRemove(NULL, op); } );
+                                  feedView->handleRemove(FeedToken(), op); } );
     }
     void putDocs() {
-        PutOperation putOp = createPut(std::move(createDoc(1, 22, 33)),
-                                       Timestamp(10), 10);
+        PutOperation putOp = createPut(std::move(createDoc(1, 22, 33)), Timestamp(10), 10);
         putDoc(putOp);
         putOp = createPut(std::move(createDoc(2, 44, 55)), Timestamp(20), 20);
         putDoc(putOp);
@@ -791,13 +787,8 @@ struct DocumentHandler
 };
 
 void
-assertAttribute(const AttributeGuard &attr,
-                const vespalib::string &name,
-                uint32_t numDocs,
-                int64_t doc1Value,
-                int64_t doc2Value,
-                SerialNum createSerialNum,
-                SerialNum lastSerialNum)
+assertAttribute(const AttributeGuard &attr, const vespalib::string &name, uint32_t numDocs,
+                int64_t doc1Value, int64_t doc2Value, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     EXPECT_EQUAL(name, attr->getName());
     EXPECT_EQUAL(numDocs, attr->getNumDocs());
@@ -808,17 +799,13 @@ assertAttribute(const AttributeGuard &attr,
 }
 
 void
-assertAttribute1(const AttributeGuard &attr,
-                           SerialNum createSerialNum,
-                           SerialNum lastSerialNum)
+assertAttribute1(const AttributeGuard &attr, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     assertAttribute(attr, "attr1", 3, 22, 44, createSerialNum, lastSerialNum);
 }
 
 void
-assertAttribute2(const AttributeGuard &attr,
-                           SerialNum createSerialNum,
-                           SerialNum lastSerialNum)
+assertAttribute2(const AttributeGuard &attr, SerialNum createSerialNum, SerialNum lastSerialNum)
 {
     assertAttribute(attr, "attr2", 3, 33, 55, createSerialNum, lastSerialNum);
 }
@@ -877,12 +864,10 @@ TEST_F("require that regular attributes are populated during reprocessing",
     requireThatAttributesArePopulatedDuringReprocessing<SearchableFixtureTwoField, ConfigDir2>(f);
 }
 
-namespace
-{
+namespace {
 
 bool
-assertOperation(DocumentOperation &op,
-                uint32_t expPrevSubDbId, uint32_t expPrevLid,
+assertOperation(DocumentOperation &op, uint32_t expPrevSubDbId, uint32_t expPrevLid,
                 uint32_t expSubDbId, uint32_t expLid)
 {
     if (!EXPECT_EQUAL(expPrevSubDbId, op.getPrevSubDbId())) {
diff --git a/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp b/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
index b0b06a238c9..e70e83fd61e 100644
--- a/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/feedhandler/feedhandler_test.cpp
@@ -140,12 +140,6 @@ struct MyReplayConfig : public IReplayConfig {
     virtual void replayConfig(SerialNum) override {}
 };
 
-void ackToken(FeedToken *token) {
-    if (token != NULL) {
-        token->ack();
-    }
-}
-
 struct MyDocumentMetaStore {
     struct Entry {
         DbDocumentId _id;
@@ -195,9 +189,9 @@ struct MyFeedView : public test::DummyFeedView {
     int update_count;
     SerialNum update_serial;
     MyFeedView(const DocumentTypeRepo::SP &dtr);
-    ~MyFeedView();
+    ~MyFeedView() override;
     void resetPutLatch(uint32_t count) { putLatch.reset(new vespalib::CountDownLatch(count)); }
-    virtual void preparePut(PutOperation &op) override {
+    void preparePut(PutOperation &op) override {
         prepareDocumentOperation(op, op.getDocument()->getId().getGlobalId());
     }
     void prepareDocumentOperation(DocumentOperation &op, const GlobalId &gid) {
@@ -208,7 +202,8 @@ struct MyFeedView : public test::DummyFeedView {
             op.setPrevTimestamp(entry->_prevTimestamp);
         }
     }
-    virtual void handlePut(FeedToken *token, const PutOperation &putOp) override {
+    void handlePut(FeedToken token, const PutOperation &putOp) override {
+        (void) token;
         LOG(info, "MyFeedView::handlePut(): docId(%s), putCount(%u), putLatchCount(%u)",
             putOp.getDocument()->getId().toString().c_str(), put_count,
             (putLatch.get() != NULL ? putLatch->getCount() : 0u));
@@ -221,23 +216,24 @@ struct MyFeedView : public test::DummyFeedView {
         if (putLatch.get() != NULL) {
             putLatch->countDown();
         }
-        ackToken(token);
     }
-    virtual void prepareUpdate(UpdateOperation &op) override {
+    void prepareUpdate(UpdateOperation &op) override {
         prepareDocumentOperation(op, op.getUpdate()->getId().getGlobalId());
     }
-    virtual void handleUpdate(FeedToken *token, const UpdateOperation &op) override {
+    void handleUpdate(FeedToken token, const UpdateOperation &op) override {
+        (void) token;
+
         ++update_count;
         update_serial = op.getSerialNum();
-        ackToken(token);
     }
-    virtual void handleRemove(FeedToken *token, const RemoveOperation &) override
-    { ++remove_count; ackToken(token); }
-    virtual void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++move_count; }
-    virtual void heartBeat(SerialNum) override { ++heartbeat_count; }
-    virtual void handlePruneRemovedDocuments(
-            const PruneRemovedDocumentsOperation &) override { ++prune_removed_count; }
-    virtual const ISimpleDocumentMetaStore *getDocumentMetaStorePtr() const override {
+    void handleRemove(FeedToken token, const RemoveOperation &) override {
+        (void) token;
+        ++remove_count;
+    }
+    void handleMove(const MoveOperation &, IDestructorCallback::SP) override { ++move_count; }
+    void heartBeat(SerialNum) override { ++heartbeat_count; }
+    void handlePruneRemovedDocuments(const PruneRemovedDocumentsOperation &) override { ++prune_removed_count; }
+    const ISimpleDocumentMetaStore *getDocumentMetaStorePtr() const override {
         return NULL;
     }
 };
@@ -317,8 +313,7 @@ MyTransport::~MyTransport() {}
 
 struct FeedTokenContext {
     MyTransport transport;
-    FeedToken::UP token_ap;
-    FeedToken &token;
+    FeedToken token;
 
     FeedTokenContext();
     ~FeedTokenContext();
@@ -333,10 +328,8 @@ struct FeedTokenContext {
 
 FeedTokenContext::FeedTokenContext()
     : transport(),
-      token_ap(new FeedToken(transport)),
-      token(*token_ap)
-{
-}
+      token(transport)
+{}
 
 FeedTokenContext::~FeedTokenContext() = default;
 
@@ -432,8 +425,7 @@ struct FeedHandlerFixture
         handler.init(1);
     }
 
-    ~FeedHandlerFixture()
-    {
+    ~FeedHandlerFixture() {
         writeService.sync();
     }
     template <class FunctionType>
@@ -484,7 +476,7 @@ TEST_F("require that outdated remove is ignored", FeedHandlerFixture)
     static_cast<DocumentOperation &>(*op).setPrevDbDocumentId(DbDocumentId(4));
     static_cast<DocumentOperation &>(*op).setPrevTimestamp(Timestamp(10000));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.remove_count);
     EXPECT_EQUAL(0, f.tls_writer.store_count);
 }
@@ -496,7 +488,7 @@ TEST_F("require that outdated put is ignored", FeedHandlerFixture)
                                           Timestamp(10), doc_context.doc));
     static_cast<DocumentOperation &>(*op).setPrevTimestamp(Timestamp(10000));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.put_count);
     EXPECT_EQUAL(0, f.tls_writer.store_count);
 }
@@ -575,7 +567,7 @@ TEST_F("require that remove of unknown document with known data type stores remo
     DocumentContext doc_context("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op(new RemoveOperation(doc_context.bucketId, Timestamp(10), doc_context.doc->getId()));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     EXPECT_EQUAL(1, f.feedView.remove_count);
     EXPECT_EQUAL(1, f.tls_writer.store_count);
 }
@@ -585,7 +577,7 @@ TEST_F("require that partial update for non-existing document is tagged as such"
     UpdateContext upCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op(new UpdateOperation(upCtx.bucketId, Timestamp(10), upCtx.update));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     const UpdateResult *result = static_cast<const UpdateResult *>(token_context.getResult());
 
     EXPECT_FALSE(token_context.transport.documentWasFound);
@@ -603,7 +595,7 @@ TEST_F("require that partial update for non-existing document is created if spec
     f.feedView.metaStore.insert(upCtx.update->getId().getGlobalId(), MyDocumentMetaStore::Entry(5, 5, Timestamp(10)));
     FeedOperation::UP op(new UpdateOperation(upCtx.bucketId, Timestamp(10), upCtx.update));
     FeedTokenContext token_context;
-    f.handler.performOperation(std::move(token_context.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token_context.token), std::move(op));
     const UpdateResult *result = static_cast<const UpdateResult *>(token_context.getResult());
 
     EXPECT_TRUE(token_context.transport.documentWasFound);
@@ -624,7 +616,7 @@ TEST_F("require that put is rejected if resource limit is reached", FeedHandlerF
     DocumentContext docCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<PutOperation>(docCtx.bucketId, Timestamp(10), docCtx.doc);
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.put_count);
     EXPECT_EQUAL(Result::RESOURCE_EXHAUSTED, token.getResult()->getErrorCode());
     EXPECT_EQUAL("Put operation rejected for document 'id:test:searchdocument::foo' of type 'searchdocument': 'Attribute resource limit reached'",
@@ -639,7 +631,7 @@ TEST_F("require that update is rejected if resource limit is reached", FeedHandl
     UpdateContext updCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<UpdateOperation>(updCtx.bucketId, Timestamp(10), updCtx.update);
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(0, f.feedView.update_count);
     EXPECT_TRUE(dynamic_cast<const UpdateResult *>(token.getResult()));
     EXPECT_EQUAL(Result::RESOURCE_EXHAUSTED, token.getResult()->getErrorCode());
@@ -655,7 +647,7 @@ TEST_F("require that remove is NOT rejected if resource limit is reached", FeedH
     DocumentContext docCtx("id:test:searchdocument::foo", *f.schema.builder);
     FeedOperation::UP op = std::make_unique<RemoveOperation>(docCtx.bucketId, Timestamp(10), docCtx.doc->getId());
     FeedTokenContext token;
-    f.handler.performOperation(std::move(token.token_ap), std::move(op));
+    f.handler.performOperation(std::move(token.token), std::move(op));
     EXPECT_EQUAL(1, f.feedView.remove_count);
     EXPECT_EQUAL(Result::NONE, token.getResult()->getErrorCode());
     EXPECT_EQUAL("", token.getResult()->getErrorMessage());
diff --git a/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp b/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
index 4eefbed0a53..548ce8ba20d 100644
--- a/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
+++ b/searchcore/src/tests/proton/documentdb/feedview/feedview_test.cpp
@@ -571,7 +571,7 @@ struct FixtureBase
         return doc("doc:test:1", timestamp);
     }
 
-    void performPut(FeedToken *token, PutOperation &op) {
+    void performPut(FeedToken token, PutOperation &op) {
         getFeedView().preparePut(op);
         op.setSerialNum(++serial);
         getFeedView().handlePut(token, op);
@@ -586,10 +586,10 @@ struct FixtureBase
     void putAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         PutOperation op(docCtx.bid, docCtx.ts, docCtx.doc);
-        runInMaster([&] () { performPut(&token.ft, op); });
+        runInMaster([&] () { performPut(token.ft, op); });
     }
 
-    void performUpdate(FeedToken *token, UpdateOperation &op) {
+    void performUpdate(FeedToken token, UpdateOperation &op) {
         getFeedView().prepareUpdate(op);
         op.setSerialNum(++serial);
         getFeedView().handleUpdate(token, op);
@@ -598,25 +598,21 @@ struct FixtureBase
     void updateAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         UpdateOperation op(docCtx.bid, docCtx.ts, docCtx.upd);
-        runInMaster([&] () { performUpdate(&token.ft, op); });
+        runInMaster([&] () { performUpdate(token.ft, op); });
     }
 
-    void performRemove(FeedToken *token, RemoveOperation &op) {
+    void performRemove(FeedToken token, RemoveOperation &op) {
         getFeedView().prepareRemove(op);
         if (op.getValidNewOrPrevDbdId()) {
             op.setSerialNum(++serial);
-            getFeedView().handleRemove(token, op);
-        } else {
-            if (token != NULL) {
-                token->ack();
-            }
+            getFeedView().handleRemove(std::move(token), op);
         }
     }
 
     void removeAndWait(const DocumentContext &docCtx) {
         FeedTokenContext token(_tracer);
         RemoveOperation op(docCtx.bid, docCtx.ts, docCtx.doc->getId());
-        runInMaster([&] () { performRemove(&token.ft, op); });
+        runInMaster([&] () { performRemove(token.ft, op); });
     }
 
     void removeAndWait(const DocumentContext::List &docs) {
diff --git a/searchcore/src/tests/proton/feedtoken/feedtoken.cpp b/searchcore/src/tests/proton/feedtoken/feedtoken.cpp
index 530c9ebef39..0fea9501d93 100644
--- a/searchcore/src/tests/proton/feedtoken/feedtoken.cpp
+++ b/searchcore/src/tests/proton/feedtoken/feedtoken.cpp
@@ -45,8 +45,9 @@ void
 Test::testAck()
 {
     LocalTransport transport;
-    FeedToken token(transport);
-    token.ack();
+    {
+        FeedToken token(transport);
+    }
     EXPECT_EQUAL(1u, transport.getReceivedCount());
 }
 
@@ -70,9 +71,10 @@ Test::testHandover()
 
     LocalTransport transport;
 
-    FeedToken token(transport);
-    token = MyHandover::handover(token);
-    token.ack();
+    {
+        FeedToken token(transport);
+        token = MyHandover::handover(token);
+    }
     EXPECT_EQUAL(1u, transport.getReceivedCount());
 }
 
diff --git a/searchcore/src/tests/proton/persistenceengine/persistenceengine_test.cpp b/searchcore/src/tests/proton/persistenceengine/persistenceengine_test.cpp
index f8c0e0ac2f6..38d4d809d60 100644
--- a/searchcore/src/tests/proton/persistenceengine/persistenceengine_test.cpp
+++ b/searchcore/src/tests/proton/persistenceengine/persistenceengine_test.cpp
@@ -127,33 +127,29 @@ struct MyDocumentRetriever : DocumentRetrieverBaseForTest {
 
     MyDocumentRetriever(const Document *d, Timestamp ts, DocumentId &last_id)
         : repo(), document(d), timestamp(ts), last_doc_id(last_id) {}
-    virtual const document::DocumentTypeRepo &getDocumentTypeRepo() const override {
+    const document::DocumentTypeRepo &getDocumentTypeRepo() const override {
         return repo;
     }
-    virtual void getBucketMetaData(const storage::spi::Bucket &,
-                                   search::DocumentMetaData::Vector &v) const override {
+    void getBucketMetaData(const storage::spi::Bucket &, search::DocumentMetaData::Vector &v) const override {
         if (document != 0) {
             v.push_back(getDocumentMetaData(document->getId()));
         }
     }
-    virtual DocumentMetaData getDocumentMetaData(const DocumentId &id) const override {
+    DocumentMetaData getDocumentMetaData(const DocumentId &id) const override {
         last_doc_id = id;
         if (document != 0) {
-            return DocumentMetaData(1, timestamp, document::BucketId(1),
-                                    document->getId().getGlobalId());
+            return DocumentMetaData(1, timestamp, document::BucketId(1), document->getId().getGlobalId());
         }
         return DocumentMetaData();
     }
-    virtual document::Document::UP getDocument(search::DocumentIdT) const override {
+    document::Document::UP getDocument(search::DocumentIdT) const override {
         if (document != 0) {
             return Document::UP(document->clone());
         }
         return Document::UP();
     }
 
-    virtual CachedSelect::SP
-    parseSelect(const vespalib::string &) const override
-    {
+    CachedSelect::SP parseSelect(const vespalib::string &) const override {
         return CachedSelect::SP();
     }
 };
@@ -208,134 +204,110 @@ struct MyHandler : public IPersistenceHandler, IBucketFreezer {
         setExistingTimestamp(ts);
     }
     void handle(FeedToken token, const Bucket &bucket, Timestamp timestamp, const DocumentId &docId) {
+        (void) token;
         lastBucket = bucket;
         lastTimestamp = timestamp;
         lastDocId = docId;
-        token.ack();
     }
 
-    virtual void initialize() override { initialized = true; }
+    void initialize() override { initialized = true; }
 
-    virtual void handlePut(FeedToken token, const Bucket& bucket,
-                           Timestamp timestamp, const document::Document::SP& doc) override {
+    void handlePut(FeedToken token, const Bucket& bucket,
+                   Timestamp timestamp, const document::Document::SP& doc) override {
         token.setResult(ResultUP(new storage::spi::Result()), false);
         handle(token, bucket, timestamp, doc->getId());
     }
 
-    virtual void handleUpdate(FeedToken token, const Bucket& bucket,
-                              Timestamp timestamp, const document::DocumentUpdate::SP& upd) override {
+    void handleUpdate(FeedToken token, const Bucket& bucket,
+                      Timestamp timestamp, const document::DocumentUpdate::SP& upd) override {
         token.setResult(ResultUP(new storage::spi::UpdateResult(existingTimestamp)),
                         existingTimestamp > 0);
         handle(token, bucket, timestamp, upd->getId());
     }
 
-    virtual void handleRemove(FeedToken token, const Bucket& bucket,
-                              Timestamp timestamp, const DocumentId& id) override {
+    void handleRemove(FeedToken token, const Bucket& bucket,
+                      Timestamp timestamp, const DocumentId& id) override {
         bool wasFound = existingTimestamp > 0;
         token.setResult(ResultUP(new storage::spi::RemoveResult(wasFound)), wasFound);
         handle(token, bucket, timestamp, id);
     }
 
-    virtual void handleListBuckets(IBucketIdListResultHandler &resultHandler) override {
+    void handleListBuckets(IBucketIdListResultHandler &resultHandler) override {
         resultHandler.handle(BucketIdListResult(bucketList));
     }
 
-    virtual void handleSetClusterState(const ClusterState &calc,
-                                       IGenericResultHandler &resultHandler) override {
+    void handleSetClusterState(const ClusterState &calc, IGenericResultHandler &resultHandler) override {
         lastCalc = &calc;
         resultHandler.handle(Result());
     }
 
-    virtual void handleSetActiveState(const Bucket &bucket,
-                                       storage::spi::BucketInfo::ActiveState newState,
-                                       IGenericResultHandler &resultHandler) override {
+    void handleSetActiveState(const Bucket &bucket, storage::spi::BucketInfo::ActiveState newState,
+                              IGenericResultHandler &resultHandler) override {
         lastBucket = bucket;
         lastBucketState = newState;
         resultHandler.handle(bucketStateResult);
     }
 
-    virtual void handleGetBucketInfo(const Bucket &,
-                                     IBucketInfoResultHandler &resultHandler) override {
+    void handleGetBucketInfo(const Bucket &, IBucketInfoResultHandler &resultHandler) override {
         resultHandler.handle(BucketInfoResult(bucketInfo));
     }
 
-    virtual void
-    handleCreateBucket(FeedToken token,
-                       const storage::spi::Bucket &) override
-    {
+    void handleCreateBucket(FeedToken token, const storage::spi::Bucket &) override {
         token.setResult(ResultUP(new Result(_createBucketResult)), true);
-        token.ack();
     }
 
-    virtual void handleDeleteBucket(FeedToken token,
-                                    const storage::spi::Bucket &) override {
+    void handleDeleteBucket(FeedToken token, const storage::spi::Bucket &) override {
         token.setResult(ResultUP(new Result(deleteBucketResult)), true);
-        token.ack();
     }
 
-    virtual void handleGetModifiedBuckets(IBucketIdListResultHandler &resultHandler) override {
+    void handleGetModifiedBuckets(IBucketIdListResultHandler &resultHandler) override {
         resultHandler.handle(BucketIdListResult(modBucketList));
     }
 
-    virtual void
-    handleSplit(FeedToken token,
-                const storage::spi::Bucket &source,
-                const storage::spi::Bucket &target1,
-                const storage::spi::Bucket &target2) override
+    void handleSplit(FeedToken token, const storage::spi::Bucket &source, const storage::spi::Bucket &target1,
+                     const storage::spi::Bucket &target2) override
     {
         (void) source;
         (void) target1;
         (void) target2;
         token.setResult(ResultUP(new Result(_splitResult)), true);
-        token.ack();
     }
 
-    virtual void
-    handleJoin(FeedToken token,
-               const storage::spi::Bucket &source1,
-               const storage::spi::Bucket &source2,
+    void handleJoin(FeedToken token, const storage::spi::Bucket &source1, const storage::spi::Bucket &source2,
                const storage::spi::Bucket &target) override
     {
         (void) source1;
         (void) source2;
         (void) target;
         token.setResult(ResultUP(new Result(_joinResult)), true);
-        token.ack();
     }
 
-    virtual RetrieversSP getDocumentRetrievers(storage::spi::ReadConsistency) override {
+    RetrieversSP getDocumentRetrievers(storage::spi::ReadConsistency) override {
         RetrieversSP ret(new std::vector<IDocumentRetriever::SP>);
-        ret->push_back(IDocumentRetriever::SP(new MyDocumentRetriever(
-                                0, Timestamp(), lastDocId)));
-        ret->push_back(IDocumentRetriever::SP(new MyDocumentRetriever(
-                                document, existingTimestamp, lastDocId)));
+        ret->push_back(IDocumentRetriever::SP(new MyDocumentRetriever(0, Timestamp(), lastDocId)));
+        ret->push_back(IDocumentRetriever::SP(new MyDocumentRetriever(document, existingTimestamp, lastDocId)));
         return ret;
     }
 
-    virtual BucketGuard::UP lockBucket(const storage::spi::Bucket &b) override {
+    BucketGuard::UP lockBucket(const storage::spi::Bucket &b) override {
         return BucketGuard::UP(new BucketGuard(b.getBucketId(), *this));
     }
 
-    virtual void
-    handleListActiveBuckets(IBucketIdListResultHandler &resultHandler) override
-    {
+    void handleListActiveBuckets(IBucketIdListResultHandler &resultHandler) override {
         BucketIdListResult::List list;
         resultHandler.handle(BucketIdListResult(list));
     }
 
-    virtual void
-    handlePopulateActiveBuckets(document::BucketId::List &buckets,
-                                IGenericResultHandler &resultHandler) override
-    {
+    void handlePopulateActiveBuckets(document::BucketId::List &buckets, IGenericResultHandler &resultHandler) override {
         (void) buckets;
         resultHandler.handle(Result());
     }
 
-    virtual void freezeBucket(BucketId bucket) override {
+    void freezeBucket(BucketId bucket) override {
         frozen.insert(bucket.getId());
         was_frozen.insert(bucket.getId());
     }
-    virtual void thawBucket(BucketId bucket) override {
+    void thawBucket(BucketId bucket) override {
         std::multiset<uint64_t>::iterator it = frozen.find(bucket.getId());
         ASSERT_TRUE(it != frozen.end());
         frozen.erase(it);
@@ -425,11 +397,7 @@ HandlerSet::prepareGetModifiedBuckets()
 
 class SimplePersistenceEngineOwner : public IPersistenceEngineOwner
 {
-    virtual void
-    setClusterState(const storage::spi::ClusterState &calc) override
-    {
-        (void) calc;
-    }
+    void setClusterState(const storage::spi::ClusterState &calc) override { (void) calc; }
 };
 
 struct SimpleResourceWriteFilter : public IResourceWriteFilter
diff --git a/searchcore/src/tests/proton/server/feedstates_test.cpp b/searchcore/src/tests/proton/server/feedstates_test.cpp
index 15c2fbe5a84..a6f3496e1ed 100644
--- a/searchcore/src/tests/proton/server/feedstates_test.cpp
+++ b/searchcore/src/tests/proton/server/feedstates_test.cpp
@@ -40,10 +40,8 @@ struct MyFeedView : public test::DummyFeedView {
     MyFeedView();
     ~MyFeedView();
 
-    virtual const DocumentTypeRepo::SP &getDocumentTypeRepo() const override
-    { return repo_sp; }
-    virtual void handleRemove(FeedToken *, const RemoveOperation &) override
-    { ++remove_handled; }
+    const DocumentTypeRepo::SP &getDocumentTypeRepo() const override { return repo_sp; }
+    void handleRemove(FeedToken , const RemoveOperation &) override { ++remove_handled; }
 };
 
 MyFeedView::MyFeedView() : repo_sp(repo.getTypeRepoSp()), remove_handled(0) {}