Split out AsynchConnecter::start from constructor (like other AsynchIO classes)

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

5 files changed, 36 insertions, 24 deletions

diff --git a/cpp/src/qpid/client/TCPConnector.cpp b/cpp/src/qpid/client/TCPConnector.cpp
index 1a6e51d54d..9369dd2ef4 100644
--- a/cpp/src/qpid/client/TCPConnector.cpp
+++ b/cpp/src/qpid/client/TCPConnector.cpp
@@ -91,14 +91,15 @@ void TCPConnector::connect(const std::string& host, int port) {
     assert(closed);
     assert(joined);
     poller = Poller::shared_ptr(new Poller);
+    AsynchConnector* c =
     AsynchConnector::create(socket,
-                            poller,
                             host, port,
                             boost::bind(&TCPConnector::connected, this, _1),
                             boost::bind(&TCPConnector::connectFailed, this, _3));
     closed = false;
     joined = false;
     receiver = Thread(this);
+    c->start(poller);
 }
 
 void TCPConnector::connected(const Socket&) {
diff --git a/cpp/src/qpid/sys/AsynchIO.h b/cpp/src/qpid/sys/AsynchIO.h
index 2a41f0a7d1..e635827d3f 100644
--- a/cpp/src/qpid/sys/AsynchIO.h
+++ b/cpp/src/qpid/sys/AsynchIO.h
@@ -61,11 +61,11 @@ public:
     // deletes. To correctly manage heaps when needed, the allocate and
     // delete should both be done from the same class/library.
     QPID_COMMON_EXTERN static AsynchConnector* create(const Socket& s,
-                                   boost::shared_ptr<Poller> poller,
                                    std::string hostname,
                                    uint16_t port,
                                    ConnectedCallback connCb,
                                    FailedCallback failCb);
+    virtual void start(boost::shared_ptr<Poller> poller) = 0;
 
 protected:
     AsynchConnector() {}
diff --git a/cpp/src/qpid/sys/TCPIOPlugin.cpp b/cpp/src/qpid/sys/TCPIOPlugin.cpp
index 39ae12c189..d0c7fe4caa 100644
--- a/cpp/src/qpid/sys/TCPIOPlugin.cpp
+++ b/cpp/src/qpid/sys/TCPIOPlugin.cpp
@@ -141,14 +141,15 @@ void AsynchIOProtocolFactory::connect(
     // is no longer needed.
 
     Socket* socket = new Socket();
-    AsynchConnector::create(*socket,
-                            poller,
-                            host,
-                            port,
-                            boost::bind(&AsynchIOProtocolFactory::established,
-                                        this, poller, _1, fact, true),
-                            boost::bind(&AsynchIOProtocolFactory::connectFailed,
-                                        this, _1, _2, _3, failed));
+    AsynchConnector* c = AsynchConnector::create(
+        *socket,
+        host,
+        port,
+        boost::bind(&AsynchIOProtocolFactory::established,
+                    this, poller, _1, fact, true),
+        boost::bind(&AsynchIOProtocolFactory::connectFailed,
+                    this, _1, _2, _3, failed));
+    c->start(poller);
 }
 
 }} // namespace qpid::sys
diff --git a/cpp/src/qpid/sys/posix/AsynchIO.cpp b/cpp/src/qpid/sys/posix/AsynchIO.cpp
index 61f10726f0..5ffe9b2b11 100644
--- a/cpp/src/qpid/sys/posix/AsynchIO.cpp
+++ b/cpp/src/qpid/sys/posix/AsynchIO.cpp
@@ -154,15 +154,14 @@ private:
 
 public:
     AsynchConnector(const Socket& socket,
-                    Poller::shared_ptr poller,
                     std::string hostname,
                     uint16_t port,
                     ConnectedCallback connCb,
                     FailedCallback failCb);
+    void start(Poller::shared_ptr poller);
 };
 
 AsynchConnector::AsynchConnector(const Socket& s,
-                                 Poller::shared_ptr poller,
                                  std::string hostname,
                                  uint16_t port,
                                  ConnectedCallback connCb,
@@ -180,13 +179,18 @@ AsynchConnector::AsynchConnector(const Socket& s,
     try {
         socket.connect(sa);
     } catch(std::exception& e) {
-        // Defer reporting failure
-        startWatch(poller);
+        // Defer reporting failure till we start polling
         errMsg = e.what();
-        DispatchHandle::call(boost::bind(&AsynchConnector::failure, this, -1, errMsg));
-        return;
     }
+}
+
+void AsynchConnector::start(Poller::shared_ptr poller)
+{
     startWatch(poller);
+    // If we previously detected an error insert failure callback now
+    if ( !errMsg.empty() ) {
+        DispatchHandle::call(boost::bind(&AsynchConnector::failure, this, -1, errMsg));
+    }
 }
 
 void AsynchConnector::connComplete(DispatchHandle& h)
@@ -600,13 +604,12 @@ AsynchAcceptor* AsynchAcceptor::create(const Socket& s,
 }
 
 AsynchConnector* AsynchConnector::create(const Socket& s,
-                                         Poller::shared_ptr poller,
                                          std::string hostname,
                                          uint16_t port,
                                          ConnectedCallback connCb,
                                          FailedCallback failCb)
 {
-    return new posix::AsynchConnector(s, poller, hostname, port, connCb, failCb);
+    return new posix::AsynchConnector(s, hostname, port, connCb, failCb);
 }
 
 AsynchIO* AsynchIO::create(const Socket& s,
diff --git a/cpp/src/qpid/sys/windows/AsynchIO.cpp b/cpp/src/qpid/sys/windows/AsynchIO.cpp
index e4174ee445..745ff187c8 100644
--- a/cpp/src/qpid/sys/windows/AsynchIO.cpp
+++ b/cpp/src/qpid/sys/windows/AsynchIO.cpp
@@ -172,23 +172,30 @@ private:
     ConnectedCallback connCallback;
     FailedCallback failCallback;
     const Socket& socket;
+    const std::string hostname;
+    const uint16_t port;
 
 public:
     AsynchConnector(const Socket& socket,
-                    Poller::shared_ptr poller,
                     std::string hostname,
                     uint16_t port,
                     ConnectedCallback connCb,
                     FailedCallback failCb = 0);
+    void start(Poller::shared_ptr poller);
 };
 
 AsynchConnector::AsynchConnector(const Socket& sock,
-                                 Poller::shared_ptr poller,
-                                 std::string hostname,
-                                 uint16_t port,
+                                 std::string hname,
+                                 uint16_t p,
                                  ConnectedCallback connCb,
-                                 FailedCallback failCb)
-  : connCallback(connCb), failCallback(failCb), socket(sock) {
+                                 FailedCallback failCb) :
+    connCallback(connCb), failCallback(failCb), socket(sock),
+    hostname(hname), port(p)
+{
+}
+
+AsynchConnector::start(Poller::shared_ptr)
+{
     try {
         socket.connect(hostname, port);
         socket.setNonblocking();