Implement QEventLoop::ExcludeSocketNotifiers for symbian socket engine

As the symbian socket engine is driven by an active object in the
QtNetwork dll, this needs to hook into the event dispatcher in the
QtCore dll.
The QActiveObject base class is now a private export from QtCore
The method of deferring socket events now works with any kind of
QActiveObject, and not only the QSocketActiveObject (which handles
"open C" sockets)
The base class has a new function, to check if socket events are blocked.
If so, it adds the active object to the deferred queue.
The derived class should return from it's RunL in this case, which will
be called again later. (same usage as the maybeQueueForLater function)

reactivateAndComplete function in the event dispatcher is changed to
complete the active object again with the same status code as originally.
Previously it always used KErrNone, which is not ok for QAsyncSelect as
it needs to check the error code from the asynchronous call.

Reviewed-by: Markus Goetz
Reviewed-by: mread

2 files changed, 57 insertions, 35 deletions

diff --git a/src/corelib/kernel/qeventdispatcher_symbian.cpp b/src/corelib/kernel/qeventdispatcher_symbian.cpp
index b074ab4..a95e7d5 100644
--- a/src/corelib/kernel/qeventdispatcher_symbian.cpp
+++ b/src/corelib/kernel/qeventdispatcher_symbian.cpp
@@ -134,7 +134,7 @@ private:
  * The QCompleteDeferredAOs class is a special object that runs after all others, which will
  * reactivate the objects that were previously not run.
  */
-inline QActiveObject::QActiveObject(TInt priority, QEventDispatcherSymbian *dispatcher)
+QActiveObject::QActiveObject(TInt priority, QEventDispatcherSymbian *dispatcher)
     : CActive(priority),
       m_dispatcher(dispatcher),
       m_hasAlreadyRun(false),
@@ -166,12 +166,25 @@ bool QActiveObject::maybeQueueForLater()
     }
 }
 
+bool QActiveObject::maybeDeferSocketEvent()
+{
+    Q_ASSERT(!m_hasRunAgain);
+    Q_ASSERT(m_dispatcher);
+    if (!m_dispatcher->areSocketEventsBlocked()) {
+        return false;
+    }
+    m_hasRunAgain = true;
+    m_dispatcher->addDeferredSocketActiveObject(this);
+    return true;
+}
+
 void QActiveObject::reactivateAndComplete()
 {
+    TInt error = iStatus.Int();
     iStatus = KRequestPending;
     SetActive();
     TRequestStatus *status = &iStatus;
-    QEventDispatcherSymbian::RequestComplete(status, KErrNone);
+    QEventDispatcherSymbian::RequestComplete(status, error);
 
     m_hasRunAgain = false;
     m_hasAlreadyRun = false;
@@ -634,10 +647,28 @@ void QSocketActiveObject::DoCancel()
 
 void QSocketActiveObject::RunL()
 {
+    if (maybeDeferSocketEvent())
+        return;
     if (maybeQueueForLater())
         return;
 
-    QT_TRYCATCH_LEAVING(m_dispatcher->socketFired(this));
+    QT_TRYCATCH_LEAVING(run());
+}
+
+void QSocketActiveObject::run()
+{
+    QEvent e(QEvent::SockAct);
+    m_inSocketEvent = true;
+    QCoreApplication::sendEvent(m_notifier, &e);
+    m_inSocketEvent = false;
+
+    if (m_deleteLater) {
+        delete this;
+    } else {
+        iStatus = KRequestPending;
+        SetActive();
+        m_dispatcher->reactivateSocketNotifier(m_notifier);
+    }
 }
 
 void QSocketActiveObject::deleteLater()
@@ -912,27 +943,6 @@ void QEventDispatcherSymbian::timerFired(int timerId)
     return;
 }
 
-void QEventDispatcherSymbian::socketFired(QSocketActiveObject *socketAO)
-{
-    if (m_noSocketEvents) {
-        m_deferredSocketEvents.append(socketAO);
-        return;
-    }
-
-    QEvent e(QEvent::SockAct);
-    socketAO->m_inSocketEvent = true;
-    QCoreApplication::sendEvent(socketAO->m_notifier, &e);
-    socketAO->m_inSocketEvent = false;
-
-    if (socketAO->m_deleteLater) {
-        delete socketAO;
-    } else {
-        socketAO->iStatus = KRequestPending;
-        socketAO->SetActive();
-        reactivateSocketNotifier(socketAO->m_notifier);
-    }
-}
-
 void QEventDispatcherSymbian::wakeUpWasCalled()
 {
     // The reactivation should happen in RunL, right before the call to this function.
@@ -993,6 +1003,12 @@ inline void QEventDispatcherSymbian::addDeferredActiveObject(QActiveObject *obje
 inline void QEventDispatcherSymbian::removeDeferredActiveObject(QActiveObject *object)
 {
     m_deferredActiveObjects.removeAll(object);
+    m_deferredSocketEvents.removeAll(object);
+}
+
+inline void QEventDispatcherSymbian::addDeferredSocketActiveObject(QActiveObject *object)
+{
+    m_deferredSocketEvents.append(object);
 }
 
 void QEventDispatcherSymbian::queueDeferredActiveObjectsCompletion()
@@ -1018,7 +1034,8 @@ bool QEventDispatcherSymbian::sendDeferredSocketEvents()
     bool sentAnyEvents = false;
     while (!m_deferredSocketEvents.isEmpty()) {
         sentAnyEvents = true;
-        socketFired(m_deferredSocketEvents.takeFirst());
+        QActiveObject *object = m_deferredSocketEvents.takeFirst();
+        object->reactivateAndComplete();
     }
 
     return sentAnyEvents;
@@ -1037,17 +1054,18 @@ bool QEventDispatcherSymbian::hasPendingEvents()
 
 void QEventDispatcherSymbian::registerSocketNotifier ( QSocketNotifier * notifier )
 {
-    //TODO: just need to be able to do something when event loop has sockets disabled
-/*    QSocketActiveObject *socketAO = new QSocketActiveObject(this, notifier);
+    //note - this is only for "open C" file descriptors
+    //for native sockets, an active object in the symbian socket engine handles this
+    QSocketActiveObject *socketAO = new QSocketActiveObject(this, notifier);
     Q_CHECK_PTR(socketAO);
     m_notifiers.insert(notifier, socketAO);
-    selectThread().requestSocketEvents(notifier, &socketAO->iStatus);*/
+    selectThread().requestSocketEvents(notifier, &socketAO->iStatus);
 }
 
 void QEventDispatcherSymbian::unregisterSocketNotifier ( QSocketNotifier * notifier )
 {
-    //TODO: just need to be able to do something when event loop has sockets disabled
-    /*
+    //note - this is only for "open C" file descriptors
+    //for native sockets, an active object in the symbian socket engine handles this
     if (m_selectThread)
         m_selectThread->cancelSocketEvents(notifier);
     if (m_notifiers.contains(notifier)) {
@@ -1056,7 +1074,6 @@ void QEventDispatcherSymbian::unregisterSocketNotifier ( QSocketNotifier * notif
         sockObj->deleteLater();
         m_notifiers.remove(notifier);
     }
-    */
 }
 
 void QEventDispatcherSymbian::reactivateSocketNotifier(QSocketNotifier *notifier)
diff --git a/src/corelib/kernel/qeventdispatcher_symbian_p.h b/src/corelib/kernel/qeventdispatcher_symbian_p.h
index bf28144..e07d475 100644
--- a/src/corelib/kernel/qeventdispatcher_symbian_p.h
+++ b/src/corelib/kernel/qeventdispatcher_symbian_p.h
@@ -77,13 +77,14 @@ QT_BEGIN_NAMESPACE
 class QEventDispatcherSymbian;
 class QTimerActiveObject;
 
-class Q_AUTOTEST_EXPORT QActiveObject : public CActive
+class Q_CORE_EXPORT QActiveObject : public CActive
 {
 public:
     QActiveObject(TInt priority, QEventDispatcherSymbian *dispatcher);
     ~QActiveObject();
 
     bool maybeQueueForLater();
+    bool maybeDeferSocketEvent();
 
     void reactivateAndComplete();
 
@@ -176,6 +177,7 @@ public:
 protected:
     void DoCancel();
     void RunL();
+    void run();
 
 private:
     QSocketNotifier *m_notifier;
@@ -244,7 +246,6 @@ public:
     void closingDown();
 
     void timerFired(int timerId);
-    void socketFired(QSocketActiveObject *socketAO);
     void wakeUpWasCalled();
     void reactivateSocketNotifier(QSocketNotifier *notifier);
 
@@ -256,6 +257,9 @@ public:
 
     inline int iterationCount() const { return m_iterationCount; }
 
+    void addDeferredSocketActiveObject(QActiveObject *object);
+    inline bool areSocketEventsBlocked() const { return m_noSocketEvents; }
+
     static void RequestComplete(TRequestStatus *&status, TInt reason);
     static void RequestComplete(RThread &threadHandle, TRequestStatus *&status, TInt reason);
 
@@ -281,8 +285,9 @@ private:
     unsigned char m_iterationCount;
     bool m_insideTimerEvent;
     bool m_noSocketEvents;
-    QList<QSocketActiveObject *> m_deferredSocketEvents;
-
+    //deferred until socket events are enabled
+    QList<QActiveObject *> m_deferredSocketEvents;
+    //deferred until idle
     QList<QActiveObject *> m_deferredActiveObjects;
 
     int m_delay;