Changeset 769 for trunk/src/corelib/kernel

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/kernel/qabstractitemmodel.cpp (modified) (1 diff)
• src/corelib/kernel/qcore_symbian_p.cpp (modified) (2 diffs)
• src/corelib/kernel/qcore_symbian_p.h (modified) (1 diff)
• src/corelib/kernel/qcoreapplication.cpp (modified) (3 diffs)
• src/corelib/kernel/qeventdispatcher_symbian.cpp (modified) (14 diffs)
• src/corelib/kernel/qeventdispatcher_symbian_p.h (modified) (3 diffs)
• src/corelib/kernel/qeventdispatcher_win.cpp (modified) (3 diffs)
• src/corelib/kernel/qfunctions_wince.cpp (modified) (1 diff)
• src/corelib/kernel/qmetaobject.cpp (modified) (1 diff)
• src/corelib/kernel/qobject.cpp (modified) (3 diffs)
• src/corelib/kernel/qobjectdefs.h (modified) (2 diffs)
• src/corelib/kernel/qtranslator.cpp (modified) (1 diff)
• src/corelib/kernel/qvariant.cpp (modified) (1 diff)

trunk/src/corelib/kernel/qabstractitemmodel.cpp

@@ -1006 +1006 @@
     Returns the child of the model index that is stored in the given \a row and
     \a column.
+
+
+
 
     \sa parent(), sibling()

trunk/src/corelib/kernel/qcore_symbian_p.cpp

@@ -72 +72 @@
     return QString::fromLocal8Bit(aDescriptor.Ptr(), aDescriptor.Length());
 #else
-    return QString::fromUtf16(aDescriptor.Ptr(), aDescriptor.Length());
+    return QString), aDescriptor.Length());
 #endif
 }
@@ -133 +133 @@
     {
 #ifdef Q_WS_S60
-        _LIT(KLibName_3_1, "qts60plugin_3_1.dll");
-        _LIT(KLibName_3_2, "qts60plugin_3_2.dll");
-        _LIT(KLibName_5_0, "qts60plugin_5_0.dll");
+        _LIT(KLibName_3_1, "qts60plugin_3_1" QT_LIBINFIX_UNICODE L".dll");
+        _LIT(KLibName_3_2, "qts60plugin_3_2" QT_LIBINFIX_UNICODE L".dll");
+        _LIT(KLibName_5_0, "qts60plugin_5_0" QT_LIBINFIX_UNICODE L".dll");
+
         TPtrC libName;
         TInt uidValue;

trunk/src/corelib/kernel/qcore_symbian_p.h

@@ -60 +60 @@
 #include <qhash.h>
 #include <f32file.h>
+
+
+
+
+
+
+
+
+
 
 QT_BEGIN_HEADER

trunk/src/corelib/kernel/qcoreapplication.cpp

@@ -68 +68 @@
 #  include <exception>
 #  include <f32file.h>
+
 #  include "qeventdispatcher_symbian_p.h"
 #  include "private/qcore_symbian_p.h"
@@ -597 +598 @@
     extern void qt_core_eval_init(uint);
     qt_core_eval_init(d->application_type);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #endif
 
@@ -2250 +2272 @@
             TInt err = finder.FindByDir(tempPathPtr, tempPathPtr);
             while (err == KErrNone) {
-                QString foundDir = QString::fromUtf16(finder.File().Ptr(), finder.File().Length());
+                QString foundDir(reinterpret_cast<const QChar *>(finder.File().Ptr()),
+                                 finder.File().Length());
                 foundDir = QDir(foundDir).canonicalPath();
                 if (!app_libpaths->contains(foundDir))

trunk/src/corelib/kernel/qeventdispatcher_symbian.cpp

@@ -44 +44 @@
 #include <qcoreapplication.h>
 #include <private/qcoreapplication_p.h>
-#include <qdatetime.h>
 
 #include <unistd.h>
 #include <errno.h>
 
+
+
 QT_BEGIN_NAMESPACE
+
+
+
+
+
+
+
 
 #define WAKE_UP_PRIORITY CActive::EPriorityStandard
@@ -93 +101 @@
 {
 public:
-    QSelectMutexGrabber(int fd, QMutex *mutex)
-        : m_mutex(mutex)
+    QSelectMutexGrabber(int fd, QMutex *utex)
+        : m_)
     {
-        if (m_mutex->tryLock())
+        // see if selectThread is waiting m_waitCond
+        // if yes ... dont write to pipe
+        if (m_threadMutex->tryLock()) {
+            bHasThreadLock = true;
             return;
+
+
+
+
+
+
+
+
 
         char dummy = 0;
         qt_pipe_write(fd, &dummy, 1);
 
-        m_mutex->lock();
+        m_threadMutex->lock();
+        bHasThreadLock = true;
     }
 
     ~QSelectMutexGrabber()
     {
-        m_mutex->unlock();
+        if(bHasThreadLock)
+            m_threadMutex->unlock();
     }
 
 private:
-    QMutex *m_mutex;
+    QMutex *m_threadMutex;
+    QMutex *m_selectCallMutex;
+    bool bHasThreadLock;
 };
 
@@ -393 +416 @@
         int ret;
         int savedSelectErrno;
-        ret = qt_socket_select(maxfd, &readfds, &writefds, &exceptionfds, 0);
+        {
+            // helps fighting the race condition between
+            // selctthread and new socket requests (cancel, restart ...)
+            QMutexLocker locker(&m_selectCallMutex);
+            ret = qt_socket_select(maxfd, &readfds, &writefds, &exceptionfds, 0);
+        }
         savedSelectErrno = errno;
 
@@ -457 +485 @@
 
                 // traversed all, so update
+
                 updateActivatedNotifiers(QSocketNotifier::Read, &readfds);
                 updateActivatedNotifiers(QSocketNotifier::Write, &writefds);
-                updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
 
                 break;
@@ -469 +497 @@
             }
         } else {
+
             updateActivatedNotifiers(QSocketNotifier::Read, &readfds);
             updateActivatedNotifiers(QSocketNotifier::Write, &writefds);
-            updateActivatedNotifiers(QSocketNotifier::Exception, &exceptionfds);
         }
 
@@ -488 +516 @@
     }
 
-    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);
+    QMutexLocker locker(&m_grabberMutex);
+
+    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex, &m_selectCallMutex);
 
     Q_ASSERT(!m_AOStatuses.contains(notifier));
@@ -499 +529 @@
 void QSelectThread::cancelSocketEvents ( QSocketNotifier *notifier )
 {
-    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);
+    QMutexLocker locker(&m_grabberMutex);
+
+    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex, &m_selectCallMutex);
 
     m_AOStatuses.remove(notifier);
@@ -508 +540 @@
 void QSelectThread::restart()
 {
-    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex);
+    QMutexLocker locker(&m_grabberMutex);
+
+    QSelectMutexGrabber lock(m_pipeEnds[1], &m_mutex, &m_selectCallMutex);
 
     m_waitCond.wakeAll();
@@ -564 +598 @@
              * then signal RequestComplete for it
              */
-            qWarning("exception on %d", i.key()->socket());
+            qWarning("exception on %d [will do setdefaultif(0) - hack]", i.key()->socket());
+            // quick fix; there is a bug
+            // when doing read on socket
+            // errors not preoperly mapped
+            // after offline-ing the device
+            // on some devices we do get exception
+            // close all exiting sockets
+            // and reset default IAP
+            if(::setdefaultif(0) != KErrNone) // well we can't do much about it
+                qWarning("setdefaultif(0) failed");
+
             toRemove.append(i.key());
             TRequestStatus *status = i.value();
@@ -623 +667 @@
     }
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 QEventDispatcherSymbian::QEventDispatcherSymbian(QObject *parent)
@@ -634 +746 @@
       m_noSocketEvents(false)
 {
+
+
+
+
+
 }
 
 QEventDispatcherSymbian::~QEventDispatcherSymbian()
 {
-    m_processHandle.Close();
 }
 
@@ -698 +814 @@
         m_interrupt = false;
 
-        /*
-         * This QTime variable is used to measure the time it takes to finish
-         * the event loop. If we take too long in the loop, other processes
-         * may be starved and killed. After the first event has completed, we
-         * take the current time, and if the remaining events take longer than
-         * a preset time, we temporarily lower the priority to force a context
-         * switch. For applications that do not take unecessarily long in the
-         * event loop, the priority will not be altered.
-         */
-        QTime time;
-        enum {
-            FirstRun,
-            SubsequentRun,
-            TimeStarted
-        } timeState = FirstRun;
-
-        TProcessPriority priority;
+#ifdef QT_SYMBIAN_PRIORITY_DROP
+        QTime eventTimer;
+#endif
 
         while (1) {
@@ -728 +830 @@
             }
 
-            if (timeState == SubsequentRun) {
-                time.start();
-                timeState = TimeStarted;
+#ifdef QT_SYMBIAN_PRIORITY_DROP
+            if (idleDetectorThread()->hasRun()) {
+                if (m_delay > baseDelay)
+                    m_delay -= baseDelay;
+                m_lastIdleRequestTimer.start();
+                idleDetectorThread()->kick();
+            } else if (m_lastIdleRequestTimer.elapsed() > maxBusyTime) {
+                User::AfterHighRes(m_delay);
+                // allow delay to be up to 1/4 of execution time
+                if (!idleDetectorThread()->hasRun() && m_delay*3 < m_avgEventTime)
+                    m_delay += baseDelay;
             }
+
+
 
             TInt error;
-            handledSymbianEvent = CActiveScheduler::RunIfReady(error, CActive::EPriorityIdle);
+            handledSymbianEvent = CActiveScheduler::RunIfReady(error, );
             if (error) {
                 qWarning("CActiveScheduler::RunIfReady() returned error: %i\n", error);
                 CActiveScheduler::Current()->Error(error);
             }
+
+
+
+
+
+
 
             if (!handledSymbianEvent) {
@@ -748 +866 @@
             }
             block = false;
-            if (timeState == TimeStarted && time.elapsed() > 100) {
-                priority = m_processHandle.Priority();
-                m_processHandle.SetPriority(EPriorityBackground);
-                time.start();
-                // Slight chance of race condition in the next lines, but nothing fatal
-                // will happen, just wrong priority.
-                if (m_processHandle.Priority() == EPriorityBackground) {
-                    m_processHandle.SetPriority(priority);
-                }
-            }
-            if (timeState == FirstRun)
-                timeState = SubsequentRun;
         };
 

trunk/src/corelib/kernel/qeventdispatcher_symbian_p.h

@@ -63 +63 @@
 #include <qwaitcondition.h>
 #include <qsocketnotifier.h>
+
 
 #include <e32base.h>
@@ -211 +212 @@
     QWaitCondition m_waitCond;
     bool m_quit;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 };
 
@@ -280 +301 @@
     QList<QActiveObject *> m_deferredActiveObjects;
 
-    RProcess m_processHandle;
+    int m_delay;
+    int m_avgEventTime;
+    QTime m_lastIdleRequestTimer;
 };
 

trunk/src/corelib/kernel/qeventdispatcher_win.cpp

@@ -69 +69 @@
 #endif
 
+
+
+
+
+
+
+
+
 enum {
     WM_QT_SOCKETNOTIFIER = WM_USER,
@@ -503 +511 @@
                 if (localSerialNumber != d->lastSerialNumber
                     // if this message IS the one that triggers sendPostedEvents(), no need to post it again
-                    && msg->hwnd != d->internalHwnd
-                    && msg->message != WM_QT_SENDPOSTEDEVENTS) {
+                    && msg->hwnd != d->internalHwnd
+                    ) {
                     PostMessage(d->internalHwnd, WM_QT_SENDPOSTEDEVENTS, 0, 0);
                 }
@@ -715 +723 @@
                         || msg.message == WM_MOUSEWHEEL
                         || msg.message == WM_MOUSEHWHEEL
+
+
+
                         || msg.message == WM_CLOSE)) {
                     // queue user input events for later processing

trunk/src/corelib/kernel/qfunctions_wince.cpp

@@ -353 +353 @@
     size_t high = num - 1;
     while (low <= high) {
-        unsigned int mid = ((unsigned) (low + high)) >> 1;
+        ) >> 1;
         int c = compare(key, (char*)base + mid * size);
-        if (c < 0)
+        if (c < 0) {
+            if (!mid)
+                break;
             high = mid - 1;
-        else if (c > 0)
+        else if (c > 0)
             low = mid + 1;
         else
             return (char*) base + mid * size;
     }
-    return (NULL);
+    return ;
 }
 

trunk/src/corelib/kernel/qmetaobject.cpp

@@ -944 +944 @@
         return result;
 
-    QVarLengthArray<char> stackbuf(int(strlen(type)) + 1);
+    QVarLengthArray<char> stackbuf() + 1);
     qRemoveWhitespace(type, stackbuf.data());
     int templdepth = 0;

trunk/src/corelib/kernel/qobject.cpp

@@ -3265 +3265 @@
             const int method = c->method;
             QObjectPrivate::Sender currentSender;
-            currentSender.sender = sender;
-            currentSender.signal = signal_absolute_index;
-            currentSender.ref = 1;
+            const bool receiverInSameThread = currentThreadData == receiver->d_func()->threadData;
             QObjectPrivate::Sender *previousSender = 0;
-            if (currentThreadData == receiver->d_func()->threadData)
+            if (receiverInSameThread) {
+                currentSender.sender = sender;
+                currentSender.signal = signal_absolute_index;
+                currentSender.ref = 1;
                 previousSender = QObjectPrivate::setCurrentSender(receiver, &currentSender);
+
             locker.unlock();
 
@@ -3286 +3288 @@
             } QT_CATCH(...) {
                 locker.relock();
-
-                QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
+                if (receiverInSameThread)
+                QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 
                 --connectionLists->inUse;
@@ -3302 +3304 @@
             locker.relock();
 
-            QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
+            if (receiverInSameThread)
+                QObjectPrivate::resetCurrentSender(receiver, &currentSender, previousSender);
 
             if (connectionLists->orphaned)

trunk/src/corelib/kernel/qobjectdefs.h

@@ -79 +79 @@
 #define Q_INTERFACES(x)
 #define Q_PROPERTY(text)
+
 #define Q_OVERRIDE(text)
 #define Q_ENUMS(x)
@@ -179 +180 @@
 #define Q_INTERFACES(x) Q_INTERFACES(x)
 #define Q_PROPERTY(text) Q_PROPERTY(text)
+
 #define Q_OVERRIDE(text) Q_OVERRIDE(text)
 #define Q_ENUMS(x) Q_ENUMS(x)

trunk/src/corelib/kernel/qtranslator.cpp

@@ -634 +634 @@
     if (!tn)
         return QString();
-    QString str = QString::fromUtf16((const ushort *)tn, tn_length/2);
+    QString str = QString *)tn, tn_length/2);
     if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
         for (int i = 0; i < str.length(); ++i)

trunk/src/corelib/kernel/qvariant.cpp

@@ -467 +467 @@
      * user defined pointer types. */
     const char *const typeName = QMetaType::typeName(a->type);
-    if (typeName[qstrlen(typeName) - 1] == '*')
+    uint typeNameLen = qstrlen(typeName);
+    if (typeNameLen > 0 && typeName[typeNameLen - 1] == '*')
         return *static_cast<void *const *>(a_ptr) == *static_cast<void *const *>(b_ptr);
+
+
+
 
     return a_ptr == b_ptr;