Move rootPath, homePath, tempPath, currentPath and setCurrentPath

Moved these functions inside the QFilesystemEngine and redirected the
QFSFileEngine copies.

Reviewed-By: joao

9 files changed, 225 insertions, 151 deletions

diff --git a/src/corelib/io/qdir.cpp b/src/corelib/io/qdir.cpp
index a45c104..e65dc11 100644
--- a/src/corelib/io/qdir.cpp
+++ b/src/corelib/io/qdir.cpp
@@ -1779,12 +1779,7 @@ QChar QDir::separator()
 */
 bool QDir::setCurrent(const QString &path)
 {
-#ifdef QT_NO_FSFILEENGINE
-    Q_UNUSED(path);
-    return false;
-#else
-    return QFSFileEngine::setCurrentPath(path);
-#endif
+    return QFileSystemEngine::setCurrentPath(QFileSystemEntry(fromNativeSeparators(path)));
 }
 
 /*!
@@ -1805,11 +1800,7 @@ bool QDir::setCurrent(const QString &path)
 */
 QString QDir::currentPath()
 {
-#ifdef QT_NO_FSFILEENGINE
-    return QString();
-#else
-    return QFSFileEngine::currentPath();
-#endif
+    return QFileSystemEngine::currentPath().filePath();
 }
 
 /*!
@@ -1867,11 +1858,7 @@ QString QDir::currentPath()
 */
 QString QDir::homePath()
 {
-#ifdef QT_NO_FSFILEENGINE
-    return QString();
-#else
-    return cleanPath(QFSFileEngine::homePath());
-#endif
+    return QFileSystemEngine::homePath();
 }
 
 /*!
@@ -1910,11 +1897,7 @@ QString QDir::homePath()
 */
 QString QDir::tempPath()
 {
-#ifdef QT_NO_FSFILEENGINE
-    return QString();
-#else
-    return cleanPath(QFSFileEngine::tempPath());
-#endif
+    return QFileSystemEngine::tempPath();
 }
 
 /*!
@@ -1941,11 +1924,7 @@ QString QDir::tempPath()
 */
 QString QDir::rootPath()
 {
-#ifdef QT_NO_FSFILEENGINE
-    return QString();
-#else
-    return QFSFileEngine::rootPath();
-#endif
+    return QFileSystemEngine::rootPath();
 }
 
 /*!
diff --git a/src/corelib/io/qfilesystemengine_p.h b/src/corelib/io/qfilesystemengine_p.h
index b3bbd65..20b664d 100644
--- a/src/corelib/io/qfilesystemengine_p.h
+++ b/src/corelib/io/qfilesystemengine_p.h
@@ -88,11 +88,13 @@ public:
                              QFileSystemMetaData::MetaDataFlags what);
     static bool fillPermissions(const QFileSystemEntry &entry, QFileSystemMetaData &data,
                                 QFileSystemMetaData::MetaDataFlags what);
-    static QString homePath();
-    static QString rootPath();
     static QString owner(const QFileSystemEntry &entry, QAbstractFileEngine::FileOwner own);
     static QString nativeAbsoluteFilePath(const QString &path);
 #endif
+    //homePath, rootPath and tempPath shall return clean paths
+    static QString homePath();
+    static QString rootPath();
+    static QString tempPath();
 
     static bool createDirectory(const QFileSystemEntry &entry, bool createParents);
     static bool removeDirectory(const QFileSystemEntry &entry, bool removeEmptyParents);
@@ -106,6 +108,9 @@ public:
     static bool setPermissions(const QFileSystemEntry &entry, QFile::Permissions permissions,
                                QFileSystemMetaData *data = 0);
 
+    static bool setCurrentPath(const QFileSystemEntry &entry);
+    static QFileSystemEntry currentPath();
+
     static QAbstractFileEngine *resolveEntryAndCreateLegacyEngine(QFileSystemEntry &entry,
                                                                   QFileSystemMetaData &data);
 private:
diff --git a/src/corelib/io/qfilesystemengine_symbian.cpp b/src/corelib/io/qfilesystemengine_symbian.cpp
index b4f0f88..ce2166d 100644
--- a/src/corelib/io/qfilesystemengine_symbian.cpp
+++ b/src/corelib/io/qfilesystemengine_symbian.cpp
@@ -42,8 +42,11 @@
 #include "qfilesystemengine_p.h"
 #include "qfsfileengine.h"
 #include <QtCore/private/qcore_symbian_p.h>
+#include <QtCore/qcoreapplication.h>
 
 #include <f32file.h>
+#include <pathinfo.h>
+#include <wchar.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -121,7 +124,7 @@ QFileSystemEntry QFileSystemEngine::absoluteName(const QFileSystemEntry &entry)
 
     QString result;
     if (needsDrive || isDriveLetter || isDriveRelative || !isAbsolute || orig.isEmpty()) {
-        QFileSystemEntry cur(QFSFileEngine::currentPath());
+        QFileSystemEntry cur(currentPath());
         if(needsDrive)
             result = cur.filePath().left(2);
         else if(isDriveRelative && cur.filePath().at(0) != orig.at(0))
@@ -339,4 +342,66 @@ bool QFileSystemEngine::setPermissions(const QFileSystemEntry &entry, QFile::Per
     return err == KErrNone; // TODO error reporting
 }
 
+QString QFileSystemEngine::homePath()
+{
+    QString home = QDir::fromNativeSeparators(qt_TDesC2QString(PathInfo::PhoneMemoryRootPath()));
+    if(home.endsWith(QLatin1Char('/')))
+        home.chop(1);
+    return home;
+}
+
+QString QFileSystemEngine::rootPath()
+{
+    TChar drive;
+    TInt err = RFs::DriveToChar(RFs::GetSystemDrive(), drive); //RFs::GetSystemDriveChar not supported on S60 3.1
+    Q_ASSERT(err == KErrNone); //RFs::GetSystemDrive() shall always return a convertible drive number on a valid OS configuration
+    return QString(QChar(drive)).append(QLatin1String(":/"));
+}
+
+QString QFileSystemEngine::tempPath()
+{
+    return rootPath().append(QLatin1String("system/temp"));
+}
+
+//static
+bool QFileSystemEngine::setCurrentPath(const QFileSystemEntry &entry)
+{
+    QFileSystemMetaData meta;
+    QFileSystemEntry absname = absoluteName(entry);
+    fillMetaData(absname, meta, QFileSystemMetaData::ExistsAttribute | QFileSystemMetaData::DirectoryType);
+    if(!(meta.exists() && meta.isDirectory()))
+        return false;
+
+    RFs& fs = qt_s60GetRFs();
+    QString abspath = absname.nativeFilePath();
+    if(!abspath.endsWith(QLatin1Char('\\')))
+        abspath.append(QLatin1Char('\\'));
+    TInt r = fs.SetSessionPath(qt_QString2TPtrC(abspath));
+    //SetSessionPath succeeds for non existant directory, which is why it's checked above
+    if (r == KErrNone) {
+        __ASSERT_COMPILE(sizeof(wchar_t) == sizeof(unsigned short));
+        //attempt to set open C to the same path
+        r = ::wchdir(reinterpret_cast<const wchar_t *>(absname.filePath().utf16()));
+        if (r < 0)
+            qWarning("failed to sync path to open C");
+        return true;
+    }
+    return false;
+}
+
+//static
+QFileSystemEntry QFileSystemEngine::currentPath()
+{
+    TFileName fn;
+    QFileSystemEntry ret;
+    TInt r = qt_s60GetRFs().SessionPath(fn);
+    if(r == KErrNone) {
+        //remove terminating slash from non root paths (session path is clean, absolute and always ends in a \)
+        if(fn.Length() > 3 && fn[fn.Length() - 1] == '\\')
+            fn.SetLength(fn.Length() - 1);
+        ret = QFileSystemEntry(qt_TDesC2QString(fn), QFileSystemEntry::FromNativePath());
+    }
+    return ret;
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qfilesystemengine_unix.cpp b/src/corelib/io/qfilesystemengine_unix.cpp
index 6290d68..8724b15 100644
--- a/src/corelib/io/qfilesystemengine_unix.cpp
+++ b/src/corelib/io/qfilesystemengine_unix.cpp
@@ -246,7 +246,7 @@ QFileSystemEntry QFileSystemEngine::absoluteName(const QFileSystemEntry &entry)
     QByteArray orig = entry.nativeFilePath();
     QByteArray result;
     if (orig.isEmpty() || !orig.startsWith('/')) {
-        QFileSystemEntry cur(QFSFileEngine::currentPath());
+        QFileSystemEntry cur(currentPath());
         result = cur.nativeFilePath();
     }
     if (!orig.isEmpty() && !(orig.length() == 1 && orig[0] == '.')) {
@@ -548,4 +548,59 @@ bool QFileSystemEngine::setPermissions(const QFileSystemEntry &entry, QFile::Per
     return false; // TODO implement;
 }
 
+QString QFileSystemEngine::homePath()
+{
+    QString home = QFile::decodeName(qgetenv("HOME"));
+    if (home.isNull())
+        home = rootPath();
+    return QDir::cleanPath(home);
+}
+
+QString QFileSystemEngine::rootPath()
+{
+    return QLatin1String("/");
+}
+
+QString QFileSystemEngine::tempPath()
+{
+    QString temp = QFile::decodeName(qgetenv("TMPDIR"));
+    if (temp.isEmpty())
+        temp = QLatin1String("/tmp/");
+    return QDir::cleanPath(temp);
+}
+
+bool QFileSystemEngine::setCurrentPath(const QFileSystemEntry &path)
+{
+    int r;
+    r = QT_CHDIR(path.nativeFilePath());
+    return r >= 0;
+}
+
+QFileSystemEntry QFileSystemEngine::currentPath()
+{
+    QFileSystemEntry result;
+    QT_STATBUF st;
+    if (QT_STAT(".", &st) == 0) {
+#if defined(__GLIBC__) && !defined(PATH_MAX)
+        char *currentName = ::get_current_dir_name();
+        if (currentName) {
+            result = QFile::decodeName(QByteArray(currentName));
+            ::free(currentName);
+        }
+#else
+        char currentName[PATH_MAX+1];
+        if (::getcwd(currentName, PATH_MAX))
+            result = QFileSystemEntry(QByteArray(currentName), QFileSystemEntry::FromNativePath());
+# if defined(QT_DEBUG)
+        if (result.isEmpty())
+            qWarning("QFSFileEngine::currentPath: getcwd() failed");
+# endif
+#endif
+    } else {
+# if defined(QT_DEBUG)
+        qWarning("QFSFileEngine::currentPath: stat(\".\") failed");
+# endif
+    }
+    return result;
+}
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qfilesystemengine_win.cpp b/src/corelib/io/qfilesystemengine_win.cpp
index 20b9b4d..cef7236 100644
--- a/src/corelib/io/qfilesystemengine_win.cpp
+++ b/src/corelib/io/qfilesystemengine_win.cpp
@@ -1098,6 +1098,73 @@ QString QFileSystemEngine::homePath()
     return QDir::fromNativeSeparators(ret);
 }
 
+QString QFileSystemEngine::tempPath()
+{
+    QString ret;
+    wchar_t tempPath[MAX_PATH];
+    DWORD len = GetTempPath(MAX_PATH, tempPath);
+    if (len)
+        ret = QString::fromWCharArray(tempPath, len);
+    if (!ret.isEmpty()) {
+        while (ret.endsWith(QLatin1Char('\\')))
+            ret.chop(1);
+        ret = QDir::fromNativeSeparators(ret);
+    }
+    if (ret.isEmpty()) {
+#if !defined(Q_OS_WINCE)
+        ret = QLatin1String("c:/tmp");
+#else
+        ret = QLatin1String("/Temp");
+#endif
+    }
+    return ret;
+}
+
+bool QFileSystemEngine::setCurrentPath(const QFileSystemEntry &entry)
+{
+    QFileSystemMetaData meta;
+    fillMetaData(entry, meta, QFileSystemMetaData::ExistsAttribute | QFileSystemMetaData::DirectoryType);
+    if(!(meta.exists() && meta.isDirectory()))
+        return false;
+
+#if !defined(Q_OS_WINCE)
+    //TODO: this should really be using nativeFilePath(), but that returns a path in long format \\?\c:\foo
+    //which causes many problems later on when it's returned through currentPath()
+    return ::SetCurrentDirectory(reinterpret_cast<const wchar_t*>(QDir::toNativeSeparators(entry.filePath()).utf16())) != 0;
+#else
+    qfsPrivateCurrentDir = entry.filePath();
+    return true;
+#endif
+}
+
+QFileSystemEntry QFileSystemEngine::currentPath()
+{
+    QString ret;
+#if !defined(Q_OS_WINCE)
+    DWORD size = 0;
+    wchar_t currentName[PATH_MAX];
+    size = ::GetCurrentDirectory(PATH_MAX, currentName);
+    if (size != 0) {
+        if (size > PATH_MAX) {
+            wchar_t *newCurrentName = new wchar_t[size];
+            if (::GetCurrentDirectory(PATH_MAX, newCurrentName) != 0)
+                ret = QString::fromWCharArray(newCurrentName, size);
+            delete [] newCurrentName;
+        } else {
+            ret = QString::fromWCharArray(currentName, size);
+        }
+    }
+#else
+    Q_UNUSED(fileName);
+    //TODO - a race condition exists when using currentPath / setCurrentPath from multiple threads
+    if (qfsPrivateCurrentDir.isEmpty())
+        qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();
+
+    ret = qfsPrivateCurrentDir;
+#endif
+    return QFileSystemEntry(ret, QFileSystemEntry::FromNativePath());
+}
+
 //static
 bool QFileSystemEngine::createLink(const QFileSystemEntry &source, const QFileSystemEntry &target)
 {
diff --git a/src/corelib/io/qfilesystementry.cpp b/src/corelib/io/qfilesystementry.cpp
index 10b59fd..12de135 100644
--- a/src/corelib/io/qfilesystementry.cpp
+++ b/src/corelib/io/qfilesystementry.cpp
@@ -121,8 +121,14 @@ QFileSystemEntry::NativePath QFileSystemEntry::nativeFilePath() const
 void QFileSystemEntry::resolveFilePath() const
 {
     if (m_filePath.isEmpty() && !m_nativeFilePath.isEmpty()) {
-#ifdef QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16
+#if defined(QFILESYSTEMENTRY_NATIVE_PATH_IS_UTF16)
         m_filePath = QDir::fromNativeSeparators(m_nativeFilePath);
+#ifdef Q_OS_WIN
+        if (m_filePath.startsWith(QLatin1String("//?/UNC/")))
+            m_filePath = m_filePath.remove(2,6);
+        if (m_filePath.startsWith(QLatin1String("//?/")))
+            m_filePath = m_filePath.remove(0,4);
+#endif
 #else
         m_filePath = QDir::fromNativeSeparators(QFile::decodeName(m_nativeFilePath));
 #endif
diff --git a/src/corelib/io/qfsfileengine_unix.cpp b/src/corelib/io/qfsfileengine_unix.cpp
index 2e9d10c..84054d8 100644
--- a/src/corelib/io/qfsfileengine_unix.cpp
+++ b/src/corelib/io/qfsfileengine_unix.cpp
@@ -691,96 +691,27 @@ bool QFSFileEngine::caseSensitive() const
 
 bool QFSFileEngine::setCurrentPath(const QString &path)
 {
-    int r;
-    r = QT_CHDIR(QFile::encodeName(path));
-    return r >= 0;
+    return QFileSystemEngine::setCurrentPath(QFileSystemEntry(QDir::fromNativeSeparators(path)));
 }
 
 QString QFSFileEngine::currentPath(const QString &)
 {
-    QString result;
-    QT_STATBUF st;
-#if defined(Q_OS_SYMBIAN)
-    char nativeCurrentName[PATH_MAX+1];
-    if (::getcwd(nativeCurrentName, PATH_MAX))
-        result = QDir::fromNativeSeparators(QFile::decodeName(QByteArray(nativeCurrentName)));
-    if (result.isEmpty()) {
-# if defined(QT_DEBUG)
-        qWarning("QFSFileEngine::currentPath: getcwd() failed");
-# endif
-    } else
-#endif
-    if (QT_STAT(".", &st) == 0) {
-#if defined(__GLIBC__) && !defined(PATH_MAX)
-        char *currentName = ::get_current_dir_name();
-        if (currentName) {
-            result = QFile::decodeName(QByteArray(currentName));
-            ::free(currentName);
-        }
-#elif !defined(Q_OS_SYMBIAN)
-        char currentName[PATH_MAX+1];
-        if (::getcwd(currentName, PATH_MAX))
-            result = QFile::decodeName(QByteArray(currentName));
-# if defined(QT_DEBUG)
-        if (result.isNull())
-            qWarning("QFSFileEngine::currentPath: getcwd() failed");
-# endif
-#endif
-    } else {
-#if defined(Q_OS_SYMBIAN)
-        // If current dir returned by Open C doesn't exist,
-        // try to create it (can happen with application private dirs)
-        // Ignore mkdir failures; we want to be consistent with Open C
-        // current path regardless.
-        QT_MKDIR(QFile::encodeName(QLatin1String(nativeCurrentName)), 0777);
-#else
-# if defined(QT_DEBUG)
-        qWarning("QFSFileEngine::currentPath: stat(\".\") failed");
-# endif
-#endif
-    }
-    return result;
+    return QFileSystemEngine::currentPath().filePath();
 }
 
 QString QFSFileEngine::homePath()
 {
-#if defined(Q_OS_SYMBIAN)
-    QString home = QDir::cleanPath(QDir::fromNativeSeparators(qt_TDesC2QString(PathInfo::PhoneMemoryRootPath())));
-#else
-    QString home = QFile::decodeName(qgetenv("HOME"));
-    if (home.isNull())
-        home = rootPath();
-#endif
-    return home;
+    return QFileSystemEngine::homePath();
 }
 
 QString QFSFileEngine::rootPath()
 {
-#if defined(Q_OS_SYMBIAN)
-    TChar drive;
-    TInt err = RFs::DriveToChar(RFs::GetSystemDrive(), drive); //RFs::GetSystemDriveChar not supported on S60 3.1
-    Q_ASSERT(err == KErrNone); //RFs::GetSystemDrive() shall always return a convertible drive number on a valid OS configuration
-    return QString(QChar(drive)).append(QLatin1String(":/"));
-#else
-    return QLatin1String("/");
-#endif
+    return QFileSystemEngine::rootPath();
 }
 
 QString QFSFileEngine::tempPath()
 {
-#if defined(Q_OS_SYMBIAN)
-    TFileName symbianPath = PathInfo::PhoneMemoryRootPath();
-    QString temp = QDir::fromNativeSeparators(qt_TDesC2QString(symbianPath));
-    temp += QLatin1String( "temp/");
-
-    // Just to verify that folder really exist on hardware
-    QT_MKDIR(QFile::encodeName(temp), 0777);
-#else
-    QString temp = QFile::decodeName(qgetenv("TMPDIR"));
-    if (temp.isEmpty())
-        temp = QLatin1String("/tmp/");
-#endif
-    return temp;
+    return QFileSystemEngine::tempPath();
 }
 
 QFileInfoList QFSFileEngine::drives()
diff --git a/src/corelib/io/qfsfileengine_win.cpp b/src/corelib/io/qfsfileengine_win.cpp
index dde499a..b2009c3 100644
--- a/src/corelib/io/qfsfileengine_win.cpp
+++ b/src/corelib/io/qfsfileengine_win.cpp
@@ -544,15 +544,7 @@ bool QFSFileEngine::caseSensitive() const
 
 bool QFSFileEngine::setCurrentPath(const QString &path)
 {
-    if (!QDir(path).exists())
-        return false;
-
-#if !defined(Q_OS_WINCE)
-    return ::SetCurrentDirectory((wchar_t*)path.utf16()) != 0;
-#else
-    qfsPrivateCurrentDir = QFSFileEnginePrivate::longFileName(path);
-    return true;
-#endif
+    return QFileSystemEngine::setCurrentPath(QFileSystemEntry(path));
 }
 
 QString QFSFileEngine::currentPath(const QString &fileName)
@@ -571,29 +563,14 @@ QString QFSFileEngine::currentPath(const QString &fileName)
     }
     if (ret.isEmpty()) {
         //just the pwd
-        DWORD size = 0;
-        wchar_t currentName[PATH_MAX];
-        size = ::GetCurrentDirectory(PATH_MAX, currentName);
-        if (size != 0) {
-            if (size > PATH_MAX) {
-                wchar_t *newCurrentName = new wchar_t[size];
-                if (::GetCurrentDirectory(PATH_MAX, newCurrentName) != 0)
-                    ret = QString::fromWCharArray(newCurrentName);
-                delete [] newCurrentName;
-            } else {
-                ret = QString::fromWCharArray(currentName);
-            }
-        }
+        ret = QFileSystemEngine::currentPath().filePath();
     }
     if (ret.length() >= 2 && ret[1] == QLatin1Char(':'))
         ret[0] = ret.at(0).toUpper(); // Force uppercase drive letters.
-    return QDir::fromNativeSeparators(ret);
+    return ret;
 #else
     Q_UNUSED(fileName);
-    if (qfsPrivateCurrentDir.isEmpty())
-        qfsPrivateCurrentDir = QCoreApplication::applicationDirPath();
-
-    return QDir::fromNativeSeparators(qfsPrivateCurrentDir);
+    return QFileSystemEngine::currentPath();
 #endif
 }
 
@@ -609,25 +586,7 @@ QString QFSFileEngine::rootPath()
 
 QString QFSFileEngine::tempPath()
 {
-    QString ret;
-    {
-        wchar_t tempPath[MAX_PATH];
-        if (GetTempPath(MAX_PATH, tempPath))
-            ret = QString::fromWCharArray(tempPath);
-        if (!ret.isEmpty()) {
-            while (ret.endsWith(QLatin1Char('\\')))
-                ret.chop(1);
-            ret = QDir::fromNativeSeparators(ret);
-        }
-    }
-    if (ret.isEmpty()) {
-#if !defined(Q_OS_WINCE)
-        ret = QLatin1String("c:/tmp");
-#else
-        ret = QLatin1String("/Temp");
-#endif
-    }
-    return ret;
+    return QFileSystemEngine::tempPath();
 }
 
 QFileInfoList QFSFileEngine::drives()
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index ad645e3..d94cf6d 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -71,6 +71,7 @@
 #  include <e32ldr.h>
 #  include "qeventdispatcher_symbian_p.h"
 #  include "private/qcore_symbian_p.h"
+#  include "private/qfilesystemengine_p.h"
 #elif defined(Q_OS_UNIX)
 #  if !defined(QT_NO_GLIB)
 #    include "qeventdispatcher_glib_p.h"
@@ -568,6 +569,12 @@ void QCoreApplication::init()
     Q_ASSERT_X(!self, "QCoreApplication", "there should be only one application object");
     QCoreApplication::self = this;
 
+#ifdef Q_OS_SYMBIAN
+    //ensure temp and working directories exist
+    QFileSystemEngine::createDirectory(QFileSystemEntry(QFileSystemEngine::tempPath()), true);
+    QFileSystemEngine::createDirectory(QFileSystemEntry(QFileSystemEngine::currentPath()), true);
+#endif
+
 #ifndef QT_NO_THREAD
     QThread::initialize();
 #endif