Merge branch 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into master-integration

* 'master' of scm.dev.nokia.troll.no:qt/oslo-staging-1:
  don't crash in QProcessEnvironment::systemEnvironment()
  qmake: Introduce new template type
  no environment on WinCE
  fix Widestring vs. Ansi mixup
  fix potential crash in QProcessEnvironment::systemEnvironment() on windows
  Fix compilation with QT_NO_*
  fix build on symbian
  skip widget when its focusPolicy is Qt::ClickFocus in TabOrderEditor
  fix build on mac
  make QProcessEnvironment on Unix cache converted values
  make QProcessEnvironment::systemEnvironment() encoding-safe
  make QProcessEnvironment on Unix cache converted variable names
  move key/value converters to the private class
  make QProcessEnvironment on Windows preserve variable name case
  split QProcessEnvironmentPrivate::Unit into Key and Value
  remove unused functions
  minor optimization: use QList::reserve()
  use the Hash typedef
  Changelog: Qt Designer 4.8

7 files changed, 206 insertions, 90 deletions

diff --git a/src/corelib/io/qprocess.cpp b/src/corelib/io/qprocess.cpp
index a45225f..c2234e9 100644
--- a/src/corelib/io/qprocess.cpp
+++ b/src/corelib/io/qprocess.cpp
@@ -143,55 +143,13 @@ QT_BEGIN_NAMESPACE
 
     \sa QProcess, QProcess::systemEnvironment(), QProcess::setProcessEnvironment()
 */
-#ifdef Q_OS_WIN
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
-{ return name.toUpper(); }
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
-{ return QString::fromLocal8Bit(name).toUpper(); }
-static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
-{ return name; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
-{ return value; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
-{ return QString::fromLocal8Bit(value); }
-static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
-{ return value; }
-static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
-{ return value.toLocal8Bit(); }
-#else
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)
-{ return name; }
-static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)
-{ return name.toLocal8Bit(); }
-static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)
-{ return QString::fromLocal8Bit(name); }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)
-{ return value; }
-static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)
-{ return value.toLocal8Bit(); }
-static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)
-{ return QString::fromLocal8Bit(value); }
-static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)
-{ return value; }
-#endif
-
-template<> void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
-{
-    if (d && d->ref == 1)
-        return;
-    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
-                                     : new QProcessEnvironmentPrivate);
-    x->ref.ref();
-    if (d && !d->ref.deref())
-        delete d;
-    d = x;
-}
 
 QStringList QProcessEnvironmentPrivate::toList() const
 {
     QStringList result;
-    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
-                                    end = hash.constEnd();
+    result.reserve(hash.size());
+    Hash::ConstIterator it = hash.constBegin(),
+                       end = hash.constEnd();
     for ( ; it != end; ++it) {
         QString data = nameToString(it.key());
         QString value = valueToString(it.value());
@@ -224,19 +182,27 @@ QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list
 QStringList QProcessEnvironmentPrivate::keys() const
 {
     QStringList result;
-    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),
-                                    end = hash.constEnd();
+    result.reserve(hash.size());
+    Hash::ConstIterator it = hash.constBegin(),
+                       end = hash.constEnd();
     for ( ; it != end; ++it)
         result << nameToString(it.key());
     return result;
 }
 
-void QProcessEnvironmentPrivate::insert(const Hash &h)
+void QProcessEnvironmentPrivate::insert(const QProcessEnvironmentPrivate &other)
 {
-    QHash<Unit, Unit>::ConstIterator it = h.constBegin(),
-                                    end = h.constEnd();
+    Hash::ConstIterator it = other.hash.constBegin(),
+                       end = other.hash.constEnd();
     for ( ; it != end; ++it)
         hash.insert(it.key(), it.value());
+
+#ifdef Q_OS_UNIX
+    QHash<QString, Key>::ConstIterator nit = other.nameMap.constBegin(),
+                                      nend = other.nameMap.constEnd();
+    for ( ; nit != nend; ++nit)
+        nameMap.insert(nit.key(), nit.value());
+#endif
 }
 
 /*!
@@ -317,6 +283,8 @@ void QProcessEnvironment::clear()
 {
     if (d)
         d->hash.clear();
+    // Unix: Don't clear d->nameMap, as the environment is likely to be
+    // re-populated with the same keys again.
 }
 
 /*!
@@ -331,7 +299,7 @@ void QProcessEnvironment::clear()
 */
 bool QProcessEnvironment::contains(const QString &name) const
 {
-    return d ? d->hash.contains(prepareName(name)) : false;
+    return d ? d->hash.contains(d->prepareName(name)) : false;
 }
 
 /*!
@@ -353,7 +321,7 @@ bool QProcessEnvironment::contains(const QString &name) const
 void QProcessEnvironment::insert(const QString &name, const QString &value)
 {
     // d detaches from null
-    d->hash.insert(prepareName(name), prepareValue(value));
+    d->hash.insert(d->prepareName(name), d->prepareValue(value));
 }
 
 /*!
@@ -370,7 +338,7 @@ void QProcessEnvironment::insert(const QString &name, const QString &value)
 void QProcessEnvironment::remove(const QString &name)
 {
     if (d)
-        d->hash.remove(prepareName(name));
+        d->hash.remove(d->prepareName(name));
 }
 
 /*!
@@ -389,11 +357,11 @@ QString QProcessEnvironment::value(const QString &name, const QString &defaultVa
     if (!d)
         return defaultValue;
 
-    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(prepareName(name));
+    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(d->prepareName(name));
     if (it == d->hash.constEnd())
         return defaultValue;
 
-    return valueToString(it.value());
+    return d->valueToString(it.value());
 }
 
 /*!
@@ -438,7 +406,7 @@ void QProcessEnvironment::insert(const QProcessEnvironment &e)
         return;
 
     // d detaches from null
-    d->insert(e.d->hash);
+    d->insert(*e.d);
 }
 
 void QProcessPrivate::Channel::clear()
@@ -2321,6 +2289,8 @@ QStringList QProcess::systemEnvironment()
 }
 
 /*!
+    \fn QProcessEnvironment QProcessEnvironment::systemEnvironment()
+
     \since 4.6
 
     \brief The systemEnvironment function returns the environment of
@@ -2336,21 +2306,6 @@ QStringList QProcess::systemEnvironment()
 
     \sa QProcess::systemEnvironment()
 */
-QProcessEnvironment QProcessEnvironment::systemEnvironment()
-{
-    QProcessEnvironment env;
-    const char *entry;
-    for (int count = 0; (entry = environ[count]); ++count) {
-        const char *equal = strchr(entry, '=');
-        if (!equal)
-            continue;
-
-        QByteArray name(entry, equal - entry);
-        QByteArray value(equal + 1);
-        env.insert(QString::fromLocal8Bit(name), QString::fromLocal8Bit(value));
-    }
-    return env;
-}
 
 /*!
     \typedef Q_PID
diff --git a/src/corelib/io/qprocess_p.h b/src/corelib/io/qprocess_p.h
index 7bfcb31..54d4936 100644
--- a/src/corelib/io/qprocess_p.h
+++ b/src/corelib/io/qprocess_p.h
@@ -81,23 +81,119 @@ class QTimer;
 class RProcess;
 #endif
 
+#ifdef Q_OS_WIN
+class QProcEnvKey : public QString
+{
+public:
+    QProcEnvKey() {}
+    explicit QProcEnvKey(const QString &other) : QString(other) {}
+    QProcEnvKey(const QProcEnvKey &other) : QString(other) {}
+    bool operator==(const QProcEnvKey &other) const { return !compare(other, Qt::CaseInsensitive); }
+};
+inline uint qHash(const QProcEnvKey &key) { return qHash(key.toCaseFolded()); }
+
+typedef QString QProcEnvValue;
+#else
+class QProcEnvKey
+{
+public:
+    QProcEnvKey() : hash(0) {}
+    explicit QProcEnvKey(const QByteArray &other) : key(other), hash(qHash(key)) {}
+    QProcEnvKey(const QProcEnvKey &other) { *this = other; }
+    bool operator==(const QProcEnvKey &other) const { return key == other.key; }
+
+    QByteArray key;
+    uint hash;
+};
+inline uint qHash(const QProcEnvKey &key) { return key.hash; }
+
+class QProcEnvValue
+{
+public:
+    QProcEnvValue() {}
+    QProcEnvValue(const QProcEnvValue &other) { *this = other; }
+    explicit QProcEnvValue(const QString &value) : stringValue(value) {}
+    explicit QProcEnvValue(const QByteArray &value) : byteValue(value) {}
+    bool operator==(const QProcEnvValue &other) const
+    {
+        return byteValue.isEmpty() && other.byteValue.isEmpty()
+                ? stringValue == other.stringValue
+                : bytes() == other.bytes();
+    }
+    QByteArray bytes() const
+    {
+        if (byteValue.isEmpty() && !stringValue.isEmpty())
+            byteValue = stringValue.toLocal8Bit();
+        return byteValue;
+    }
+    QString string() const
+    {
+        if (stringValue.isEmpty() && !byteValue.isEmpty())
+            stringValue = QString::fromLocal8Bit(byteValue);
+        return stringValue;
+    }
+
+    mutable QByteArray byteValue;
+    mutable QString stringValue;
+};
+Q_DECLARE_TYPEINFO(QProcEnvValue, Q_MOVABLE_TYPE);
+#endif
+Q_DECLARE_TYPEINFO(QProcEnvKey, Q_MOVABLE_TYPE);
+
 class QProcessEnvironmentPrivate: public QSharedData
 {
 public:
+    typedef QProcEnvKey Key;
+    typedef QProcEnvValue Value;
 #ifdef Q_OS_WIN
-    typedef QString Unit;
+    inline Key prepareName(const QString &name) const { return Key(name); }
+    inline QString nameToString(const Key &name) const { return name; }
+    inline Value prepareValue(const QString &value) const { return value; }
+    inline QString valueToString(const Value &value) const { return value; }
 #else
-    typedef QByteArray Unit;
+    inline Key prepareName(const QString &name) const
+    {
+        Key &ent = nameMap[name];
+        if (ent.key.isEmpty())
+            ent = Key(name.toLocal8Bit());
+        return ent;
+    }
+    inline QString nameToString(const Key &name) const
+    {
+        const QString sname = QString::fromLocal8Bit(name.key);
+        nameMap[sname] = name;
+        return sname;
+    }
+    inline Value prepareValue(const QString &value) const { return Value(value); }
+    inline QString valueToString(const Value &value) const { return value.string(); }
 #endif
-    typedef QHash<Unit, Unit> Hash;
+
+    typedef QHash<Key, Value> Hash;
     Hash hash;
 
+#ifdef Q_OS_UNIX
+    typedef QHash<QString, Key> NameHash;
+    mutable NameHash nameMap;
+#endif
+
     static QProcessEnvironment fromList(const QStringList &list);
     QStringList toList() const;
     QStringList keys() const;
-    void insert(const Hash &hash);
+    void insert(const QProcessEnvironmentPrivate &other);
 };
 
+template<> Q_INLINE_TEMPLATE void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()
+{
+    if (d && d->ref == 1)
+        return;
+    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)
+                                     : new QProcessEnvironmentPrivate);
+    x->ref.ref();
+    if (d && !d->ref.deref())
+        delete d;
+    d = x;
+}
+
 class QProcessPrivate : public QIODevicePrivate
 {
 public:
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index 3af9b46..a3c589f 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -453,7 +453,36 @@ bool QProcessPrivate::createChannel(Channel &channel)
     }
 }
 
-static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment, int *envc)
+QT_BEGIN_INCLUDE_NAMESPACE
+#if defined(Q_OS_MAC) && !defined(QT_NO_CORESERVICES)
+# include <crt_externs.h>
+# define environ (*_NSGetEnviron())
+#elif defined(Q_OS_SYMBIAN) || (defined(Q_OS_MAC) && defined(QT_NO_CORESERVICES))
+  static char *qt_empty_environ[] = { 0 };
+#define environ qt_empty_environ
+#else
+  extern char **environ;
+#endif
+QT_END_INCLUDE_NAMESPACE
+
+QProcessEnvironment QProcessEnvironment::systemEnvironment()
+{
+    QProcessEnvironment env;
+    const char *entry;
+    for (int count = 0; (entry = environ[count]); ++count) {
+        const char *equal = strchr(entry, '=');
+        if (!equal)
+            continue;
+
+        QByteArray name(entry, equal - entry);
+        QByteArray value(equal + 1);
+        env.d->hash.insert(QProcessEnvironmentPrivate::Key(name),
+                           QProcessEnvironmentPrivate::Value(value));
+    }
+    return env;
+}
+
+static char **_q_dupEnvironment(const QProcessEnvironmentPrivate::Hash &environment, int *envc)
 {
     *envc = 0;
     if (environment.isEmpty())
@@ -469,17 +498,17 @@ static char **_q_dupEnvironment(const QHash<QByteArray, QByteArray> &environment
 #endif
     const QByteArray envLibraryPath = qgetenv(libraryPath);
     bool needToAddLibraryPath = !envLibraryPath.isEmpty() &&
-                                !environment.contains(libraryPath);
+                                !environment.contains(QProcessEnvironmentPrivate::Key(QByteArray(libraryPath)));
 
     char **envp = new char *[environment.count() + 2];
     envp[environment.count()] = 0;
     envp[environment.count() + 1] = 0;
 
-    QHash<QByteArray, QByteArray>::ConstIterator it = environment.constBegin();
-    const QHash<QByteArray, QByteArray>::ConstIterator end = environment.constEnd();
+    QProcessEnvironmentPrivate::Hash::ConstIterator it = environment.constBegin();
+    const QProcessEnvironmentPrivate::Hash::ConstIterator end = environment.constEnd();
     for ( ; it != end; ++it) {
-        QByteArray key = it.key();
-        QByteArray value = it.value();
+        QByteArray key = it.key().key;
+        QByteArray value = it.value().bytes();
         key.reserve(key.length() + 1 + value.length());
         key.append('=');
         key.append(value);
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
index 625ed98..bb23954 100644
--- a/src/corelib/io/qprocess_win.cpp
+++ b/src/corelib/io/qprocess_win.cpp
@@ -278,29 +278,55 @@ static QString qt_create_commandline(const QString &program, const QStringList &
     return args;
 }
 
-static QByteArray qt_create_environment(const QHash<QString, QString> &environment)
+QProcessEnvironment QProcessEnvironment::systemEnvironment()
+{
+    QProcessEnvironment env;
+#if !defined(Q_OS_WINCE)
+    // Calls to setenv() affect the low-level environment as well.
+    // This is not the case the other way round.
+    if (wchar_t *envStrings = GetEnvironmentStringsW()) {
+        for (const wchar_t *entry = envStrings; *entry; ) {
+            int entryLen = wcslen(entry);
+            if (const wchar_t *equal = wcschr(entry, L'=')) {
+                int nameLen = equal - entry;
+                QString name = QString::fromWCharArray(entry, nameLen);
+                QString value = QString::fromWCharArray(equal + 1, entryLen - nameLen - 1);
+                env.d->hash.insert(QProcessEnvironmentPrivate::Key(name), value);
+            }
+            entry += entryLen + 1;
+        }
+        FreeEnvironmentStringsW(envStrings);
+    }
+#endif
+    return env;
+}
+
+#if !defined(Q_OS_WINCE)
+static QByteArray qt_create_environment(const QProcessEnvironmentPrivate::Hash &environment)
 {
     QByteArray envlist;
     if (!environment.isEmpty()) {
-        QHash<QString, QString> copy = environment;
+        QProcessEnvironmentPrivate::Hash copy = environment;
 
         // add PATH if necessary (for DLL loading)
-        if (!copy.contains(QLatin1String("PATH"))) {
+        QProcessEnvironmentPrivate::Key pathKey(QLatin1String("PATH"));
+        if (!copy.contains(pathKey)) {
             QByteArray path = qgetenv("PATH");
             if (!path.isEmpty())
-                copy.insert(QLatin1String("PATH"), QString::fromLocal8Bit(path));
+                copy.insert(pathKey, QString::fromLocal8Bit(path));
         }
 
         // add systemroot if needed
-        if (!copy.contains(QLatin1String("SYSTEMROOT"))) {
-            QByteArray systemRoot = qgetenv("SYSTEMROOT");
+        QProcessEnvironmentPrivate::Key rootKey(QLatin1String("SystemRoot"));
+        if (!copy.contains(rootKey)) {
+            QByteArray systemRoot = qgetenv("SystemRoot");
             if (!systemRoot.isEmpty())
-                copy.insert(QLatin1String("SYSTEMROOT"), QString::fromLocal8Bit(systemRoot));
+                copy.insert(rootKey, QString::fromLocal8Bit(systemRoot));
         }
 
         int pos = 0;
-        QHash<QString, QString>::ConstIterator it = copy.constBegin(),
-                                              end = copy.constEnd();
+        QProcessEnvironmentPrivate::Hash::ConstIterator it = copy.constBegin(),
+                                                       end = copy.constEnd();
 
         static const wchar_t equal = L'=';
         static const wchar_t nul = L'\0';
@@ -335,6 +361,7 @@ static QByteArray qt_create_environment(const QHash<QString, QString> &environme
     }
     return envlist;
 }
+#endif
 
 void QProcessPrivate::startProcess()
 {
diff --git a/src/declarative/debugger/qdeclarativedebugserver.cpp b/src/declarative/debugger/qdeclarativedebugserver.cpp
index c7bdcb6..5112af0 100644
--- a/src/declarative/debugger/qdeclarativedebugserver.cpp
+++ b/src/declarative/debugger/qdeclarativedebugserver.cpp
@@ -116,6 +116,7 @@ void QDeclarativeDebugServerPrivate::advertisePlugins()
 QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectionPlugin(
     const QString &pluginName)
 {
+#ifndef QT_NO_LIBRARY
     QStringList pluginCandidates;
     const QStringList paths = QCoreApplication::libraryPaths();
     foreach (const QString &libPath, paths) {
@@ -142,6 +143,7 @@ QDeclarativeDebugServerConnection *QDeclarativeDebugServerPrivate::loadConnectio
             return connection;
         loader.unload();
     }
+#endif
     return 0;
 }
 
diff --git a/src/network/access/qhttpthreaddelegate.cpp b/src/network/access/qhttpthreaddelegate.cpp
index 99f9376..0364dac 100644
--- a/src/network/access/qhttpthreaddelegate.cpp
+++ b/src/network/access/qhttpthreaddelegate.cpp
@@ -51,6 +51,7 @@
 #include "private/qnetworkaccesscache_p.h"
 #include "private/qnoncontiguousbytedevice_p.h"
 
+#ifndef QT_NO_HTTP
 
 QT_BEGIN_NAMESPACE
 
@@ -576,4 +577,6 @@ void  QHttpThreadDelegate::synchronousProxyAuthenticationRequiredSlot(const QNet
 
 #endif
 
+#endif // QT_NO_HTTP
+
 QT_END_NAMESPACE
diff --git a/src/network/access/qhttpthreaddelegate_p.h b/src/network/access/qhttpthreaddelegate_p.h
index 752bc09..c0f2077 100644
--- a/src/network/access/qhttpthreaddelegate_p.h
+++ b/src/network/access/qhttpthreaddelegate_p.h
@@ -68,6 +68,8 @@
 #include "private/qnoncontiguousbytedevice_p.h"
 #include "qnetworkaccessauthenticationmanager_p.h"
 
+#ifndef QT_NO_HTTP
+
 QT_BEGIN_NAMESPACE
 
 class QAuthenticator;
@@ -285,4 +287,6 @@ signals:
 
 QT_END_NAMESPACE
 
+#endif // QT_NO_HTTP
+
 #endif // QHTTPTHREADDELEGATE_H