iOS: Implement socket notifiers.

Create the QCFSocketNotifier class in platform support
which contains shared socket notifier support for
the Cocoa and iOS plugins. Remove the old code from
the Cocoa plugin.

The Cocoa code had one QCocoaEventDispatcher-specific
call: maybeCancelWaitForMoreEvents. Create a forwarding
function that is passed to QCFSocketNotifier.

Change-Id: Ibf9bd4745ba4f577a55f13d0cc00f5ae04447405
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@digia.com>
Reviewed-by: Richard Moe Gustavsen <richard.gustavsen@digia.com>

3 files changed, 349 insertions, 0 deletions

diff --git a/src/platformsupport/cfsocketnotifier/cfsocketnotifier.pri b/src/platformsupport/cfsocketnotifier/cfsocketnotifier.pri
new file mode 100644
index 0000000000..9a19d3c278
--- /dev/null
+++ b/src/platformsupport/cfsocketnotifier/cfsocketnotifier.pri
@@ -0,0 +1,4 @@
+mac {
+    HEADERS += $$PWD/qcfsocketnotifier_p.h
+    SOURCES += $$PWD/qcfsocketnotifier.cpp
+}
diff --git a/src/platformsupport/cfsocketnotifier/qcfsocketnotifier.cpp b/src/platformsupport/cfsocketnotifier/qcfsocketnotifier.cpp
new file mode 100644
index 0000000000..5dcd6a4ffd
--- /dev/null
+++ b/src/platformsupport/cfsocketnotifier/qcfsocketnotifier.cpp
@@ -0,0 +1,255 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcfsocketnotifier_p.h"
+#include <QtGui/qguiapplication.h>
+#include <QtCore/qsocketnotifier.h>
+#include <QtCore/qthread.h>
+
+
+/**************************************************************************
+    Socket Notifiers
+ *************************************************************************/
+void qt_mac_socket_callback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef,
+                            const void *, void *info)
+{
+
+    QCFSocketNotifier *cfSocketNotifier = static_cast<QCFSocketNotifier *>(info);
+    int nativeSocket = CFSocketGetNative(s);
+    MacSocketInfo *socketInfo = cfSocketNotifier->macSockets.value(nativeSocket);
+    QEvent notifierEvent(QEvent::SockAct);
+
+    // There is a race condition that happen where we disable the notifier and
+    // the kernel still has a notification to pass on. We then get this
+    // notification after we've successfully disabled the CFSocket, but our Qt
+    // notifier is now gone. The upshot is we have to check the notifier
+    // every time.
+    if (callbackType == kCFSocketReadCallBack) {
+        if (socketInfo->readNotifier)
+            QGuiApplication::sendEvent(socketInfo->readNotifier, &notifierEvent);
+    } else if (callbackType == kCFSocketWriteCallBack) {
+        if (socketInfo->writeNotifier)
+            QGuiApplication::sendEvent(socketInfo->writeNotifier, &notifierEvent);
+    }
+
+    if (cfSocketNotifier->maybeCancelWaitForMoreEvents)
+        cfSocketNotifier->maybeCancelWaitForMoreEvents(cfSocketNotifier->eventDispatcher);
+}
+
+/*
+    Adds a loop source for the given socket to the current run loop.
+*/
+CFRunLoopSourceRef qt_mac_add_socket_to_runloop(const CFSocketRef socket)
+{
+    CFRunLoopSourceRef loopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0);
+    if (!loopSource)
+        return 0;
+
+    CFRunLoopAddSource(CFRunLoopGetMain(), loopSource, kCFRunLoopCommonModes);
+    return loopSource;
+}
+
+/*
+    Removes the loop source for the given socket from the current run loop.
+*/
+void qt_mac_remove_socket_from_runloop(const CFSocketRef socket, CFRunLoopSourceRef runloop)
+{
+    Q_ASSERT(runloop);
+    CFRunLoopRemoveSource(CFRunLoopGetMain(), runloop, kCFRunLoopCommonModes);
+    CFSocketDisableCallBacks(socket, kCFSocketReadCallBack);
+    CFSocketDisableCallBacks(socket, kCFSocketWriteCallBack);
+    CFRunLoopSourceInvalidate(runloop);
+}
+
+QCFSocketNotifier::QCFSocketNotifier()
+:eventDispatcher(0)
+{
+
+}
+
+QCFSocketNotifier::~QCFSocketNotifier()
+{
+
+}
+
+void QCFSocketNotifier::setHostEventDispatcher(QAbstractEventDispatcher *hostEventDispacher)
+{
+    eventDispatcher = hostEventDispacher;
+}
+
+void QCFSocketNotifier::setMaybeCancelWaitForMoreEventsCallback(MaybeCancelWaitForMoreEventsFn callBack)
+{
+    maybeCancelWaitForMoreEvents = callBack;
+}
+
+void QCFSocketNotifier::registerSocketNotifier(QSocketNotifier *notifier)
+{
+    Q_ASSERT(notifier);
+    int nativeSocket = notifier->socket();
+    int type = notifier->type();
+#ifndef QT_NO_DEBUG
+    if (nativeSocket < 0 || nativeSocket > FD_SETSIZE) {
+        qWarning("QSocketNotifier: Internal error");
+        return;
+    } else if (notifier->thread() != eventDispatcher->thread()
+               || eventDispatcher->thread() != QThread::currentThread()) {
+        qWarning("QSocketNotifier: socket notifiers cannot be enabled from another thread");
+        return;
+    }
+#endif
+
+    if (type == QSocketNotifier::Exception) {
+        qWarning("QSocketNotifier::Exception is not supported on iOS");
+        return;
+    }
+
+    // Check if we have a CFSocket for the native socket, create one if not.
+    MacSocketInfo *socketInfo = macSockets.value(nativeSocket);
+    if (!socketInfo) {
+        socketInfo = new MacSocketInfo();
+
+        // Create CFSocket, specify that we want both read and write callbacks (the callbacks
+        // are enabled/disabled later on).
+        const int callbackTypes = kCFSocketReadCallBack | kCFSocketWriteCallBack;
+        CFSocketContext context = {0, this, 0, 0, 0};
+        socketInfo->socket = CFSocketCreateWithNative(kCFAllocatorDefault, nativeSocket, callbackTypes, qt_mac_socket_callback, &context);
+        if (CFSocketIsValid(socketInfo->socket) == false) {
+            qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to create CFSocket");
+            return;
+        }
+
+        CFOptionFlags flags = CFSocketGetSocketFlags(socketInfo->socket);
+        flags |= kCFSocketAutomaticallyReenableWriteCallBack; //QSocketNotifier stays enabled after a write
+        flags &= ~kCFSocketCloseOnInvalidate; //QSocketNotifier doesn't close the socket upon destruction/invalidation
+        CFSocketSetSocketFlags(socketInfo->socket, flags);
+
+        // Add CFSocket to runloop.
+        if (!(socketInfo->runloop = qt_mac_add_socket_to_runloop(socketInfo->socket))) {
+            qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to add CFSocket to runloop");
+            CFSocketInvalidate(socketInfo->socket);
+            CFRelease(socketInfo->socket);
+            return;
+        }
+
+        // Disable both callback types by default. This must be done after
+        // we add the CFSocket to the runloop, or else these calls will have
+        // no effect.
+        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketReadCallBack);
+        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);
+
+        macSockets.insert(nativeSocket, socketInfo);
+    }
+
+    // Increment read/write counters and select enable callbacks if necessary.
+    if (type == QSocketNotifier::Read) {
+        Q_ASSERT(socketInfo->readNotifier == 0);
+        socketInfo->readNotifier = notifier;
+        CFSocketEnableCallBacks(socketInfo->socket, kCFSocketReadCallBack);
+    } else if (type == QSocketNotifier::Write) {
+        Q_ASSERT(socketInfo->writeNotifier == 0);
+        socketInfo->writeNotifier = notifier;
+        CFSocketEnableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);
+    }
+}
+
+void QCFSocketNotifier::unregisterSocketNotifier(QSocketNotifier *notifier)
+{
+    Q_ASSERT(notifier);
+    int nativeSocket = notifier->socket();
+    int type = notifier->type();
+#ifndef QT_NO_DEBUG
+    if (nativeSocket < 0 || nativeSocket > FD_SETSIZE) {
+        qWarning("QSocketNotifier: Internal error");
+        return;
+    } else if (notifier->thread() != eventDispatcher->thread() || eventDispatcher->thread() != QThread::currentThread()) {
+        qWarning("QSocketNotifier: socket notifiers cannot be disabled from another thread");
+        return;
+    }
+#endif
+
+    if (type == QSocketNotifier::Exception) {
+        qWarning("QSocketNotifier::Exception is not supported on iOS");
+        return;
+    }
+    MacSocketInfo *socketInfo = macSockets.value(nativeSocket);
+    if (!socketInfo) {
+        qWarning("QEventDispatcherMac::unregisterSocketNotifier: Tried to unregister a not registered notifier");
+        return;
+    }
+
+    // Decrement read/write counters and disable callbacks if necessary.
+    if (type == QSocketNotifier::Read) {
+        Q_ASSERT(notifier == socketInfo->readNotifier);
+        socketInfo->readNotifier = 0;
+        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketReadCallBack);
+    } else if (type == QSocketNotifier::Write) {
+        Q_ASSERT(notifier == socketInfo->writeNotifier);
+        socketInfo->writeNotifier = 0;
+        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);
+    }
+
+    // Remove CFSocket from runloop if this was the last QSocketNotifier.
+    if (socketInfo->readNotifier == 0 && socketInfo->writeNotifier == 0) {
+        if (CFSocketIsValid(socketInfo->socket))
+            qt_mac_remove_socket_from_runloop(socketInfo->socket, socketInfo->runloop);
+        CFRunLoopSourceInvalidate(socketInfo->runloop);
+        CFRelease(socketInfo->runloop);
+        CFSocketInvalidate(socketInfo->socket);
+        CFRelease(socketInfo->socket);
+        delete socketInfo;
+        macSockets.remove(nativeSocket);
+    }
+}
+
+void QCFSocketNotifier::removeSocketNotifiers()
+{
+    // Remove CFSockets from the runloop.
+    for (MacSocketHash::ConstIterator it = macSockets.constBegin(); it != macSockets.constEnd(); ++it) {
+        MacSocketInfo *socketInfo = (*it);
+        if (CFSocketIsValid(socketInfo->socket)) {
+            qt_mac_remove_socket_from_runloop(socketInfo->socket, socketInfo->runloop);
+            CFRunLoopSourceInvalidate(socketInfo->runloop);
+            CFRelease(socketInfo->runloop);
+            CFSocketInvalidate(socketInfo->socket);
+            CFRelease(socketInfo->socket);
+        }
+    }
+}
diff --git a/src/platformsupport/cfsocketnotifier/qcfsocketnotifier_p.h b/src/platformsupport/cfsocketnotifier/qcfsocketnotifier_p.h
new file mode 100644
index 0000000000..cd1eb8e4ca
--- /dev/null
+++ b/src/platformsupport/cfsocketnotifier/qcfsocketnotifier_p.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCFSOCKETNOTIFIER_P_H
+#define QCFSOCKETNOTIFIER_P_H
+
+#include <QtCore/qabstracteventdispatcher.h>
+#include <QtCore/qhash.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+QT_BEGIN_NAMESPACE
+
+struct MacSocketInfo {
+    MacSocketInfo() : socket(0), runloop(0), readNotifier(0), writeNotifier(0) {}
+    CFSocketRef socket;
+    CFRunLoopSourceRef runloop;
+    QObject *readNotifier;
+    QObject *writeNotifier;
+};
+typedef QHash<int, MacSocketInfo *> MacSocketHash;
+
+typedef void (*MaybeCancelWaitForMoreEventsFn)(QAbstractEventDispatcher *hostEventDispacher);
+
+// The CoreFoundationSocketNotifier class implements socket notifiers support using
+// CFSocket for event dispatchers running on top of the Core Foundation run loop system.
+// (currently Mac and iOS)
+//
+// The principal functions are registerSocketNotifier() and unregisterSocketNotifier().
+//
+// setHostEventDispatcher() should be called at startup.
+// removeSocketNotifiers() should be called at shutdown.
+//
+class QCFSocketNotifier
+{
+public:
+    QCFSocketNotifier();
+    ~QCFSocketNotifier();
+    void setHostEventDispatcher(QAbstractEventDispatcher *hostEventDispacher);
+    void setMaybeCancelWaitForMoreEventsCallback(MaybeCancelWaitForMoreEventsFn callBack);
+    void registerSocketNotifier(QSocketNotifier *notifier);
+    void unregisterSocketNotifier(QSocketNotifier *notifier);
+    void removeSocketNotifiers();
+
+    MacSocketHash macSockets;
+    QAbstractEventDispatcher *eventDispatcher;
+    MaybeCancelWaitForMoreEventsFn maybeCancelWaitForMoreEvents;
+};
+
+QT_END_NAMESPACE
+
+#endif