QPID-3858: WIP: Moved QueueAsycnContext from namespace tests::storePerftools::asyncPerf to qpid::broker

git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/asyncstore@1363776 13f79535-47bb-0310-9956-ffa450edef68

7 files changed, 152 insertions, 149 deletions

diff --git a/cpp/src/asyncstore.cmake b/cpp/src/asyncstore.cmake
index af9a358d1e..5656bc8cc4 100644
--- a/cpp/src/asyncstore.cmake
+++ b/cpp/src/asyncstore.cmake
@@ -62,6 +62,7 @@ set (asyncStore_SOURCES
 	qpid/broker/EnqueueHandle.cpp
 	qpid/broker/EventHandle.cpp
 	qpid/broker/MessageHandle.cpp
+	qpid/broker/QueueAsyncContext.cpp
 	qpid/broker/QueueHandle.cpp
     qpid/broker/TxnAsyncContext.cpp
     qpid/broker/TxnBuffer.cpp
diff --git a/cpp/src/tests/storePerftools/asyncPerf/QueueAsyncContext.cpp b/cpp/src/qpid/broker/QueueAsyncContext.cpp
index 0312f61d3c..54a10c9c0e 100644
--- a/cpp/src/tests/storePerftools/asyncPerf/QueueAsyncContext.cpp
+++ b/cpp/src/qpid/broker/QueueAsyncContext.cpp
@@ -18,23 +18,22 @@
  */
 
 /**
- * \file QueueContext.cpp
+ * \file QueueAsyncContext.cpp
  */
 
 #include "QueueAsyncContext.h"
 
-#include "SimpleMessage.h"
+#include "qpid/broker/PersistableMessage.h"
 
 #include <cassert>
 
-namespace tests {
-namespace storePerftools {
-namespace asyncPerf {
+namespace qpid {
+namespace broker {
 
-QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
-                                     qpid::broker::TxnHandle& th,
-                                     qpid::broker::AsyncResultCallback rcb,
-                                     qpid::broker::AsyncResultQueue* const arq) :
+QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<PersistableQueue> q,
+                                     TxnHandle& th,
+                                     AsyncResultCallback rcb,
+                                     AsyncResultQueue* const arq) :
         m_q(q),
         m_th(th),
         m_rcb(rcb),
@@ -43,11 +42,11 @@ QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
     assert(m_q.get() != 0);
 }
 
-QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
-                                     boost::intrusive_ptr<SimpleMessage> msg,
-                                     qpid::broker::TxnHandle& th,
-                                     qpid::broker::AsyncResultCallback rcb,
-                                     qpid::broker::AsyncResultQueue* const arq) :
+QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<PersistableQueue> q,
+                                     boost::intrusive_ptr<PersistableMessage> msg,
+                                     TxnHandle& th,
+                                     AsyncResultCallback rcb,
+                                     AsyncResultQueue* const arq) :
         m_q(q),
         m_msg(msg),
         m_th(th),
@@ -61,38 +60,38 @@ QueueAsyncContext::QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
 QueueAsyncContext::~QueueAsyncContext()
 {}
 
-boost::shared_ptr<SimpleQueue>
+boost::shared_ptr<PersistableQueue>
 QueueAsyncContext::getQueue() const
 {
     return m_q;
 }
 
-boost::intrusive_ptr<SimpleMessage>
+boost::intrusive_ptr<PersistableMessage>
 QueueAsyncContext::getMessage() const
 {
     return m_msg;
 }
 
-qpid::broker::TxnHandle
+TxnHandle
 QueueAsyncContext::getTxnHandle() const
 {
     return m_th;
 }
 
-qpid::broker::AsyncResultQueue*
+AsyncResultQueue*
 QueueAsyncContext::getAsyncResultQueue() const
 {
     return m_arq;
 }
 
-qpid::broker::AsyncResultCallback
+AsyncResultCallback
 QueueAsyncContext::getAsyncResultCallback() const
 {
     return m_rcb;
 }
 
 void
-QueueAsyncContext::invokeCallback(const qpid::broker::AsyncResultHandle* const arh) const
+QueueAsyncContext::invokeCallback(const AsyncResultHandle* const arh) const
 {
     if (m_rcb) {
         m_rcb(arh);
@@ -105,4 +104,4 @@ QueueAsyncContext::destroy()
     delete this;
 }
 
-}}} // namespace tests::storePerftools::asyncPerf
+}} // namespace qpid::broker
diff --git a/cpp/src/qpid/broker/QueueAsyncContext.h b/cpp/src/qpid/broker/QueueAsyncContext.h
new file mode 100644
index 0000000000..34fd63fd06
--- /dev/null
+++ b/cpp/src/qpid/broker/QueueAsyncContext.h
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * \file QueueAsyncContext.h
+ */
+
+#ifndef qpid_broker_QueueAsyncContext_h_
+#define qpid_broker_QueueAsyncContext_h_
+
+#include "AsyncResultHandle.h"
+#include "AsyncStore.h"
+#include "TxnHandle.h"
+
+#include "qpid/asyncStore/AsyncOperation.h"
+
+#include <boost/intrusive_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+
+namespace qpid {
+namespace broker {
+
+class PersistableMessage;
+class PersistableQueue;
+
+typedef void (*AsyncResultCallback)(const AsyncResultHandle* const);
+
+class QueueAsyncContext: public BrokerAsyncContext
+{
+public:
+    QueueAsyncContext(boost::shared_ptr<PersistableQueue> q,
+                      TxnHandle& th,
+                      AsyncResultCallback rcb,
+                      AsyncResultQueue* const arq);
+    QueueAsyncContext(boost::shared_ptr<PersistableQueue> q,
+                      boost::intrusive_ptr<PersistableMessage> msg,
+                      TxnHandle& th,
+                      AsyncResultCallback rcb,
+                      AsyncResultQueue* const arq);
+    virtual ~QueueAsyncContext();
+    boost::shared_ptr<PersistableQueue> getQueue() const;
+    boost::intrusive_ptr<PersistableMessage> getMessage() const;
+    TxnHandle getTxnHandle() const;
+    AsyncResultQueue* getAsyncResultQueue() const;
+    AsyncResultCallback getAsyncResultCallback() const;
+    void invokeCallback(const AsyncResultHandle* const arh) const;
+    void destroy();
+
+private:
+    boost::shared_ptr<PersistableQueue> m_q;
+    boost::intrusive_ptr<PersistableMessage> m_msg;
+    TxnHandle m_th; // TODO: get rid of this when tests::storePerftools::asyncPerf::SimpleQueue has solved its TxnHandle issues.
+    AsyncResultCallback m_rcb;
+    AsyncResultQueue* const m_arq;
+};
+
+}} // namespace qpid::broker
+
+#endif // qpid_broker_QueueAsyncContext_h_
diff --git a/cpp/src/tests/asyncstore.cmake b/cpp/src/tests/asyncstore.cmake
index cd20394908..2e3081bbc1 100644
--- a/cpp/src/tests/asyncstore.cmake
+++ b/cpp/src/tests/asyncstore.cmake
@@ -59,7 +59,7 @@ set (asyncStorePerf_SOURCES
     storePerftools/asyncPerf/MessageProducer.cpp
 	storePerftools/asyncPerf/PerfTest.cpp
 	storePerftools/asyncPerf/PersistableQueuedMessage.cpp
-	storePerftools/asyncPerf/QueueAsyncContext.cpp
+#	storePerftools/asyncPerf/QueueAsyncContext.cpp
 	storePerftools/asyncPerf/QueuedMessage.cpp
 	storePerftools/asyncPerf/SimpleMessage.cpp
 	storePerftools/asyncPerf/SimpleQueue.cpp
diff --git a/cpp/src/tests/storePerftools/asyncPerf/QueueAsyncContext.h b/cpp/src/tests/storePerftools/asyncPerf/QueueAsyncContext.h
deleted file mode 100644
index 4e3d9fe2db..0000000000
--- a/cpp/src/tests/storePerftools/asyncPerf/QueueAsyncContext.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-/**
- * \file QueueContext.h
- */
-
-#ifndef tests_storePerftools_asyncPerf_QueueContext_h_
-#define tests_storePerftools_asyncPerf_QueueContext_h_
-
-#include "qpid/asyncStore/AsyncOperation.h"
-#include "qpid/broker/AsyncResultHandle.h"
-#include "qpid/broker/AsyncStore.h"
-#include "qpid/broker/TxnHandle.h"
-
-#include <boost/intrusive_ptr.hpp>
-#include <boost/shared_ptr.hpp>
-
-namespace qpid {
-namespace broker {
-typedef void (*AsyncResultCallback)(const AsyncResultHandle* const);
-}}
-
-namespace tests {
-namespace storePerftools {
-namespace asyncPerf {
-
-class SimpleMessage;
-class SimpleQueue;
-
-class QueueAsyncContext: public qpid::broker::BrokerAsyncContext
-{
-public:
-    QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
-                      qpid::broker::TxnHandle& th,
-                      qpid::broker::AsyncResultCallback rcb,
-                      qpid::broker::AsyncResultQueue* const arq);
-    QueueAsyncContext(boost::shared_ptr<SimpleQueue> q,
-                      boost::intrusive_ptr<SimpleMessage> msg,
-                      qpid::broker::TxnHandle& th,
-                      qpid::broker::AsyncResultCallback rcb,
-                      qpid::broker::AsyncResultQueue* const arq);
-    virtual ~QueueAsyncContext();
-    boost::shared_ptr<SimpleQueue> getQueue() const;
-    boost::intrusive_ptr<SimpleMessage> getMessage() const;
-    qpid::broker::TxnHandle getTxnHandle() const;
-    qpid::broker::AsyncResultQueue* getAsyncResultQueue() const;
-    qpid::broker::AsyncResultCallback getAsyncResultCallback() const;
-    void invokeCallback(const qpid::broker::AsyncResultHandle* const arh) const;
-    void destroy();
-
-private:
-    boost::shared_ptr<SimpleQueue> m_q;
-    boost::intrusive_ptr<SimpleMessage> m_msg;
-    qpid::broker::TxnHandle m_th; // TODO: get rid of this
-    qpid::broker::AsyncResultCallback m_rcb;
-    qpid::broker::AsyncResultQueue* const m_arq;
-};
-
-}}} // namespace tests::storePerftools::asyncPerf
-
-#endif // tests_storePerftools_asyncPerf_QueueContext_h_
diff --git a/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.cpp b/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.cpp
index 79b8b46919..292fc35925 100644
--- a/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.cpp
+++ b/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.cpp
@@ -27,10 +27,10 @@
 #include "MessageConsumer.h"
 #include "MessageDeque.h"
 #include "PersistableQueuedMessage.h"
-#include "QueueAsyncContext.h"
 #include "SimpleMessage.h"
 
 #include "qpid/broker/AsyncResultHandle.h"
+#include "qpid/broker/QueueAsyncContext.h"
 #include "qpid/broker/TxnHandle.h"
 
 #include <string.h> // memcpy()
@@ -90,10 +90,10 @@ void
 SimpleQueue::asyncCreate()
 {
     if (m_store) {
-        boost::shared_ptr<QueueAsyncContext> qac(new QueueAsyncContext(shared_from_this(),
-                                                                       s_nullTxnHandle,
-                                                                       &handleAsyncCreateResult,
-                                                                       &m_resultQueue));
+        boost::shared_ptr<qpid::broker::QueueAsyncContext> qac(new qpid::broker::QueueAsyncContext(shared_from_this(),
+                                                                                                   s_nullTxnHandle,
+                                                                                                   &handleAsyncCreateResult,
+                                                                                                   &m_resultQueue));
         m_store->submitCreate(m_queueHandle, this, qac);
         ++m_asyncOpCounter;
     }
@@ -103,13 +103,15 @@ SimpleQueue::asyncCreate()
 void
 SimpleQueue::handleAsyncCreateResult(const qpid::broker::AsyncResultHandle* const arh) {
     if (arh) {
-        boost::shared_ptr<QueueAsyncContext> qc = boost::dynamic_pointer_cast<QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<qpid::broker::QueueAsyncContext> qc =
+                boost::dynamic_pointer_cast<qpid::broker::QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<SimpleQueue> sq = boost::dynamic_pointer_cast<SimpleQueue>(qc->getQueue());
         if (arh->getErrNo()) {
             // TODO: Handle async failure here (other than by simply printing a message)
-            std::cerr << "Queue name=\"" << qc->getQueue()->m_name << "\": Operation " << qc->getOpStr() << ": failure "
+            std::cerr << "Queue name=\"" << sq->m_name << "\": Operation " << qc->getOpStr() << ": failure "
                       << arh->getErrNo() << " (" << arh->getErrMsg() << ")" << std::endl;
         } else {
-            qc->getQueue()->createComplete(qc);
+            sq->createComplete(qc);
         }
     }
 }
@@ -120,10 +122,10 @@ SimpleQueue::asyncDestroy(const bool deleteQueue)
     m_destroyPending = true;
     if (m_store) {
         if (deleteQueue) {
-            boost::shared_ptr<QueueAsyncContext> qac(new QueueAsyncContext(shared_from_this(),
-                                                                           s_nullTxnHandle,
-                                                                           &handleAsyncDestroyResult,
-                                                                           &m_resultQueue));
+            boost::shared_ptr<qpid::broker::QueueAsyncContext> qac(new qpid::broker::QueueAsyncContext(shared_from_this(),
+                                                                                                       s_nullTxnHandle,
+                                                                                                       &handleAsyncDestroyResult,
+                                                                                                       &m_resultQueue));
             m_store->submitDestroy(m_queueHandle, qac);
             ++m_asyncOpCounter;
         }
@@ -135,13 +137,15 @@ SimpleQueue::asyncDestroy(const bool deleteQueue)
 void
 SimpleQueue::handleAsyncDestroyResult(const qpid::broker::AsyncResultHandle* const arh) {
     if (arh) {
-        boost::shared_ptr<QueueAsyncContext> qc = boost::dynamic_pointer_cast<QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<qpid::broker::QueueAsyncContext> qc =
+                boost::dynamic_pointer_cast<qpid::broker::QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<SimpleQueue> sq = boost::dynamic_pointer_cast<SimpleQueue>(qc->getQueue());
         if (arh->getErrNo()) {
             // TODO: Handle async failure here (other than by simply printing a message)
-            std::cerr << "Queue name=\"" << qc->getQueue()->m_name << "\": Operation " << qc->getOpStr() << ": failure "
+            std::cerr << "Queue name=\"" << sq->m_name << "\": Operation " << qc->getOpStr() << ": failure "
                       << arh->getErrNo() << " (" << arh->getErrMsg() << ")" << std::endl;
         } else {
-            qc->getQueue()->destroyComplete(qc);
+            sq->destroyComplete(qc);
         }
     }
 }
@@ -356,18 +360,16 @@ SimpleQueue::asyncEnqueue(qpid::broker::TxnHandle& th,
 {
     assert(pqm.get());
 //    qm.payload()->setPersistenceId(m_store->getNextRid()); // TODO: rid is set by store itself - find way to do this
-    boost::shared_ptr<QueueAsyncContext> qac(new QueueAsyncContext(shared_from_this(),
-                                                                   pqm->payload(),
-                                                                   th,
-                                                                   &handleAsyncEnqueueResult,
-                                                                   &m_resultQueue));
-    // TODO : This must be done from inside store, not here
+    boost::shared_ptr<qpid::broker::QueueAsyncContext> qac(new qpid::broker::QueueAsyncContext(shared_from_this(),
+                                                                                               pqm->payload(),
+                                                                                               th,
+                                                                                               &handleAsyncEnqueueResult,
+                                                                                               &m_resultQueue));
+    // TODO : This must be done from inside store, not here (the txn handle is opaque outside the store)
     if (th.isValid()) {
         th.incrOpCnt();
     }
-    m_store->submitEnqueue(pqm->enqHandle(),
-                           th,
-                           qac);
+    m_store->submitEnqueue(pqm->enqHandle(), th, qac);
     ++m_asyncOpCounter;
     return true;
 }
@@ -376,13 +378,15 @@ SimpleQueue::asyncEnqueue(qpid::broker::TxnHandle& th,
 void
 SimpleQueue::handleAsyncEnqueueResult(const qpid::broker::AsyncResultHandle* const arh) {
     if (arh) {
-        boost::shared_ptr<QueueAsyncContext> qc = boost::dynamic_pointer_cast<QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<qpid::broker::QueueAsyncContext> qc =
+                boost::dynamic_pointer_cast<qpid::broker::QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<SimpleQueue> sq = boost::dynamic_pointer_cast<SimpleQueue>(qc->getQueue());
         if (arh->getErrNo()) {
             // TODO: Handle async failure here (other than by simply printing a message)
-            std::cerr << "Queue name=\"" << qc->getQueue()->m_name << "\": Operation " << qc->getOpStr() << ": failure "
+            std::cerr << "Queue name=\"" << sq->m_name << "\": Operation " << qc->getOpStr() << ": failure "
                       << arh->getErrNo() << " (" << arh->getErrMsg() << ")" << std::endl;
         } else {
-            qc->getQueue()->enqueueComplete(qc);
+            sq->enqueueComplete(qc);
         }
     }
 }
@@ -393,12 +397,12 @@ SimpleQueue::asyncDequeue(qpid::broker::TxnHandle& th,
                           boost::shared_ptr<PersistableQueuedMessage> pqm)
 {
     assert(pqm.get());
-    boost::shared_ptr<QueueAsyncContext> qac(new QueueAsyncContext(shared_from_this(),
-                                                                   pqm->payload(),
-                                                                   th,
-                                                                   &handleAsyncDequeueResult,
-                                                                   &m_resultQueue));
-    // TODO : This must be done from inside store, not here
+    boost::shared_ptr<qpid::broker::QueueAsyncContext> qac(new qpid::broker::QueueAsyncContext(shared_from_this(),
+                                                                                               pqm->payload(),
+                                                                                               th,
+                                                                                               &handleAsyncDequeueResult,
+                                                                                               &m_resultQueue));
+    // TODO : This must be done from inside store, not here (the txn handle is opaque outside the store)
     if (th.isValid()) {
         th.incrOpCnt();
     }
@@ -412,13 +416,15 @@ SimpleQueue::asyncDequeue(qpid::broker::TxnHandle& th,
 void
 SimpleQueue::handleAsyncDequeueResult(const qpid::broker::AsyncResultHandle* const arh) {
     if (arh) {
-        boost::shared_ptr<QueueAsyncContext> qc = boost::dynamic_pointer_cast<QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<qpid::broker::QueueAsyncContext> qc =
+                boost::dynamic_pointer_cast<qpid::broker::QueueAsyncContext>(arh->getBrokerAsyncContext());
+        boost::shared_ptr<SimpleQueue> sq = boost::dynamic_pointer_cast<SimpleQueue>(qc->getQueue());
         if (arh->getErrNo()) {
             // TODO: Handle async failure here (other than by simply printing a message)
-            std::cerr << "Queue name=\"" << qc->getQueue()->m_name << "\": Operation " << qc->getOpStr() << ": failure "
+            std::cerr << "Queue name=\"" << sq->m_name << "\": Operation " << qc->getOpStr() << ": failure "
                       << arh->getErrNo() << " (" << arh->getErrMsg() << ")" << std::endl;
         } else {
-            qc->getQueue()->dequeueComplete(qc);
+            sq->dequeueComplete(qc);
         }
     }
 }
@@ -436,7 +442,7 @@ SimpleQueue::destroyCheck(const std::string& opDescr) const
 
 // private
 void
-SimpleQueue::createComplete(const boost::shared_ptr<QueueAsyncContext> qc)
+SimpleQueue::createComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc)
 {
     assert(qc->getQueue().get() == this);
     --m_asyncOpCounter;
@@ -444,7 +450,7 @@ SimpleQueue::createComplete(const boost::shared_ptr<QueueAsyncContext> qc)
 
 // private
 void
-SimpleQueue::flushComplete(const boost::shared_ptr<QueueAsyncContext> qc)
+SimpleQueue::flushComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc)
 {
     assert(qc->getQueue().get() == this);
     --m_asyncOpCounter;
@@ -452,7 +458,7 @@ SimpleQueue::flushComplete(const boost::shared_ptr<QueueAsyncContext> qc)
 
 // private
 void
-SimpleQueue::destroyComplete(const boost::shared_ptr<QueueAsyncContext> qc)
+SimpleQueue::destroyComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc)
 {
     assert(qc->getQueue().get() == this);
     --m_asyncOpCounter;
@@ -461,12 +467,12 @@ SimpleQueue::destroyComplete(const boost::shared_ptr<QueueAsyncContext> qc)
 
 // private
 void
-SimpleQueue::enqueueComplete(const boost::shared_ptr<QueueAsyncContext> qc)
+SimpleQueue::enqueueComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc)
 {
     assert(qc->getQueue().get() == this);
     --m_asyncOpCounter;
 
-    // TODO : This must be done from inside store, not here
+    // TODO : This must be done from inside store, not here (the txn handle is opaque outside the store)
     qpid::broker::TxnHandle th = qc->getTxnHandle();
     if (th.isValid()) { // transactional enqueue
         th.decrOpCnt();
@@ -475,12 +481,12 @@ SimpleQueue::enqueueComplete(const boost::shared_ptr<QueueAsyncContext> qc)
 
 // private
 void
-SimpleQueue::dequeueComplete(const boost::shared_ptr<QueueAsyncContext> qc)
+SimpleQueue::dequeueComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc)
 {
     assert(qc->getQueue().get() == this);
     --m_asyncOpCounter;
 
-    // TODO : This must be done from inside store, not here
+    // TODO : This must be done from inside store, not here (the txn handle is opaque outside the store)
     qpid::broker::TxnHandle th = qc->getTxnHandle();
     if (th.isValid()) { // transactional enqueue
         th.decrOpCnt();
diff --git a/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.h b/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.h
index f13febbafa..1126d67775 100644
--- a/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.h
+++ b/cpp/src/tests/storePerftools/asyncPerf/SimpleQueue.h
@@ -37,6 +37,7 @@
 namespace qpid {
 namespace broker {
 class AsyncResultQueue;
+class QueueAsyncContext;
 }
 namespace framing {
 class FieldTable;
@@ -49,7 +50,6 @@ namespace asyncPerf {
 class MessageConsumer;
 class Messages;
 class PersistableQueuedMessage;
-class QueueAsyncContext;
 class QueuedMessage;
 class SimpleMessage;
 
@@ -146,11 +146,11 @@ private:
     void destroyCheck(const std::string& opDescr) const;
 
     // --- Async op completions (called through handleAsyncResult) ---
-    void createComplete(const boost::shared_ptr<QueueAsyncContext> qc);
-    void flushComplete(const boost::shared_ptr<QueueAsyncContext> qc);
-    void destroyComplete(const boost::shared_ptr<QueueAsyncContext> qc);
-    void enqueueComplete(const boost::shared_ptr<QueueAsyncContext> qc);
-    void dequeueComplete(const boost::shared_ptr<QueueAsyncContext> qc);
+    void createComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc);
+    void flushComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc);
+    void destroyComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc);
+    void enqueueComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc);
+    void dequeueComplete(const boost::shared_ptr<qpid::broker::QueueAsyncContext> qc);
 };
 
 }}} // namespace tests::storePerftools::asyncPerf