Merge findByFile and findByFileName into mimeTypeForFile(flags).

These are API changes suggested by Lars.
Implement MatchContent.

Change-Id: I2baca9c99777573f6a5ac5dbf9221df6b37b01c9
Sanity-Review: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Lars Knoll <lars.knoll@nokia.com>
Reviewed-by: Wolf-Michael Bolle <wolf-michael.bolle@nokia.com>

11 files changed, 143 insertions, 132 deletions

diff --git a/examples/mimetypefinder/main.cpp b/examples/mimetypefinder/main.cpp
index 8da085a..ae1e9ee 100644
--- a/examples/mimetypefinder/main.cpp
+++ b/examples/mimetypefinder/main.cpp
@@ -28,14 +28,11 @@ int main(int argc, char *argv[])
         //mime = QMimeType::findByContent(data, &accuracy);
         mime = db.findByData(data);
     } else if (option == QLatin1String("-c")) {
-        QFile file(fileName);
-        if (file.open(QIODevice::ReadOnly)) {
-            mime = db.findByData(file.read(32000));
-        }
+        mime = db.mimeTypeForFile(fileName, QMimeDatabase::MatchContent);
     } else if (option == QLatin1String("-f")) {
-        mime = db.findByFileName(fileName);
+        mime = db.mimeTypeForFile(fileName, QMimeDatabase::MatchExtension);
     } else {
-        mime = db.findByFile(fileName);
+        mime = db.mimeTypeForFile(fileName);
     }
     if ( mime.isValid() /*&& !mime.isDefault()*/ ) {
         printf("%s\n", mime.name().toLatin1().constData());
diff --git a/examples/mimetypeviewer/mimetypeviewer.cpp b/examples/mimetypeviewer/mimetypeviewer.cpp
index bce2f9c..10341e5 100644
--- a/examples/mimetypeviewer/mimetypeviewer.cpp
+++ b/examples/mimetypeviewer/mimetypeviewer.cpp
@@ -27,7 +27,7 @@ void MimeTypeViewer::onOpenFileButtonClicked()
         return;
 
     ui->fileLineEdit->setText(file);
-    QMimeType mimeType = dataBase->findByFile(QFileInfo(file));
+    QMimeType mimeType = dataBase->mimeTypeForFile(QFileInfo(file));
     if (mimeType.isValid())
         setMimeType(mimeType);
 }
diff --git a/src/imports/mimetypes/plugins.qmltypes b/src/imports/mimetypes/plugins.qmltypes
index 3a2f099..ab6c8d1 100644
--- a/src/imports/mimetypes/plugins.qmltypes
+++ b/src/imports/mimetypes/plugins.qmltypes
@@ -15,12 +15,12 @@ Module {
             Parameter { name: "nameOrAlias"; type: "string" }
         }
         Method {
-            name: "findByFileName"
+            name: "mimeTypeForFileName"
             type: "QDeclarativeMimeType*"
             Parameter { name: "fileName"; type: "string" }
         }
         Method {
-            name: "findByFile"
+            name: "mimeTypeForFile"
             type: "QDeclarativeMimeType*"
             Parameter { name: "fileName"; type: "string" }
         }
diff --git a/src/imports/mimetypes/qdeclarativemimedatabase.cpp b/src/imports/mimetypes/qdeclarativemimedatabase.cpp
index 8edd0cb..18bdf48 100644
--- a/src/imports/mimetypes/qdeclarativemimedatabase.cpp
+++ b/src/imports/mimetypes/qdeclarativemimedatabase.cpp
@@ -266,7 +266,7 @@ QDeclarativeMimeType *QDeclarativeMimeDatabase::mimeTypeForName (
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \qmlmethod MimeType MimeDatabase::findByFileName(string fileName)
+    \qmlmethod MimeType MimeDatabase::mimeTypeForFileName(string fileName)
     \brief Returns a MIME type for the file \a fileName.
 
     A valid MIME type is always returned. If the file name doesn't match any
@@ -274,14 +274,14 @@ QDeclarativeMimeType *QDeclarativeMimeDatabase::mimeTypeForName (
     is returned.
 
     This function does not try to open the file. To also use the content
-    when determining the MIME type, use findByFile().
+    when determining the MIME type, use mimeTypeForFile().
 */
-QDeclarativeMimeType *QDeclarativeMimeDatabase::findByFileName (
+QDeclarativeMimeType *QDeclarativeMimeDatabase::mimeTypeForFileName (
                                                     const QString &fileName
                                                 )
 {
     return new QDeclarativeMimeType (
-                   m_MimeDatabase.findByFileName(fileName),
+                   m_MimeDatabase.mimeTypeForFile(fileName, QMimeDatabase::MatchExtension),
                    this   // <- The new object will be released later
                           //    when this registry is released.
                );
@@ -290,7 +290,7 @@ QDeclarativeMimeType *QDeclarativeMimeDatabase::findByFileName (
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \qmlmethod MimeType MimeDatabase::findByFile(string fileName)
+    \qmlmethod MimeType MimeDatabase::mimeTypeForFile(string fileName)
     \brief Returns a MIME type for \a fileName.
 
     This method looks at both the file name and the file contents,
@@ -304,12 +304,12 @@ QDeclarativeMimeType *QDeclarativeMimeDatabase::findByFileName (
 
     The \a fileName can also include an absolute or relative path.
 */
-QDeclarativeMimeType *QDeclarativeMimeDatabase::findByFile (
+QDeclarativeMimeType *QDeclarativeMimeDatabase::mimeTypeForFile(
                                                     const QString &fileName
                                                 )
 {
     return new QDeclarativeMimeType (
-                   m_MimeDatabase.findByFile(fileName),
+                   m_MimeDatabase.mimeTypeForFile(fileName),
                    this   // <- The new object will be released later
                           //    when this registry is released.
                );
diff --git a/src/imports/mimetypes/qdeclarativemimedatabase_p.h b/src/imports/mimetypes/qdeclarativemimedatabase_p.h
index 861ae95..533e3de 100644
--- a/src/imports/mimetypes/qdeclarativemimedatabase_p.h
+++ b/src/imports/mimetypes/qdeclarativemimedatabase_p.h
@@ -81,11 +81,11 @@ public:
                                           const QString &nameOrAlias
                                       );
 
-    Q_INVOKABLE QDeclarativeMimeType *findByFileName (
+    Q_INVOKABLE QDeclarativeMimeType *mimeTypeForFileName (
                                           const QString &fileName
                                       );
 
-    Q_INVOKABLE QDeclarativeMimeType *findByFile (
+    Q_INVOKABLE QDeclarativeMimeType *mimeTypeForFile (
                                           const QString &fileName
                                       );
 
diff --git a/src/mimetypes/qmimedatabase.cpp b/src/mimetypes/qmimedatabase.cpp
index 9a91591..1469b96 100644
--- a/src/mimetypes/qmimedatabase.cpp
+++ b/src/mimetypes/qmimedatabase.cpp
@@ -107,7 +107,7 @@ QMimeType QMimeDatabasePrivate::mimeTypeForName(const QString &nameOrAlias)
     return provider()->mimeTypeForName(provider()->resolveAlias(nameOrAlias));
 }
 
-QStringList QMimeDatabasePrivate::findByFileName(const QString &fileName, QString *foundSuffix)
+QStringList QMimeDatabasePrivate::mimeTypeForFileName(const QString &fileName, QString *foundSuffix)
 {
     if (fileName.endsWith(QLatin1Char('/')))
         return QStringList() << QLatin1String("inode/directory");
@@ -162,7 +162,7 @@ QMimeType QMimeDatabasePrivate::findByData(const QByteArray &data, int *accuracy
 
 // ------------------------------------------------------------------------------------------------
 
-QMimeType QMimeDatabasePrivate::findByFileNameAndData(const QString &fileName, QIODevice *device, int *accuracyPtr)
+QMimeType QMimeDatabasePrivate::mimeTypeForNameAndData(const QString &fileName, QIODevice *device, int *accuracyPtr)
 {
     // First, glob patterns are evaluated. If there is a match with max weight,
     // this one is selected and we are done. Otherwise, the file contents are
@@ -172,7 +172,7 @@ QMimeType QMimeDatabasePrivate::findByFileNameAndData(const QString &fileName, Q
     *accuracyPtr = 0;
 
     // Pass 1) Try to match on the file name
-    QStringList candidatesByName = findByFileName(fileName);
+    QStringList candidatesByName = mimeTypeForFileName(fileName);
     if (candidatesByName.count() == 1) {
         *accuracyPtr = 100;
         const QMimeType mime = mimeTypeForName(candidatesByName.at(0));
@@ -350,24 +350,34 @@ QMimeType QMimeDatabase::mimeTypeForName(const QString& nameOrAlias) const
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \fn QMimeType QMimeDatabase::findByFile(const QFileInfo &fileInfo) const;
     \brief Returns a MIME type for \a fileInfo.
 
-    This method looks at both the file name and the file contents,
-    if necessary. The file extension has priority over the contents,
+    A valid MIME type is always returned.
+
+    The default matching algorithm looks at both the file name and the file
+    contents, if necessary. The file extension has priority over the contents,
     but the contents will be used if the file extension is unknown, or
     matches multiple MIME types.
+    If \a fileInfo is a unix symbolic link, the file that it refers to
+    will be used instead.
+    If the file doesn't match any known pattern or data, the default MIME type
+    (application/octet-stream) is returned.
 
-    A valid MIME type is always returned. If the file doesn't match any
-    known extension or data, the default MIME type (application/octet-stream)
+    When \a flags is set to MatchExtension, only the file name is used, not
+    the file contents. The file doesn't even have to exist. If the file name
+    doesn't match any known pattern, the default MIME type (application/octet-stream)
     is returned.
+    If multiple MIME types match this file, the first one (alphabetically) is returned.
 
-    If \a fileInfo is a unix symbolic link, the file that it refers to
-    will be used instead.
+    When \a flags is set to MatchContent, and the file is readable, only the
+    file contents are used to determine the MIME type. This is equivalent to
+    calling mimeTypeForData with a QFile as input device.
+
+    In all cases, the \a fileName can also include an absolute or relative path.
 
     \sa isDefault
 */
-QMimeType QMimeDatabase::findByFile(const QFileInfo &fileInfo) const
+QMimeType QMimeDatabase::mimeTypeForFile(const QFileInfo &fileInfo, MatchFlags flags) const
 {
     DBG() << "fileInfo" << fileInfo.absoluteFilePath();
 
@@ -395,64 +405,46 @@ QMimeType QMimeDatabase::findByFile(const QFileInfo &fileInfo) const
 #endif
 
     int priority = 0;
-    return d->findByFileNameAndData(fileInfo.absoluteFilePath(), &file, &priority);
-}
-
-// ------------------------------------------------------------------------------------------------
-
-/*!
-    \fn QMimeType QMimeDatabase::findByFile(const QString &fileName) const;
-    \brief Returns a MIME type for \a fileName.
-
-    This method looks at both the file name and the file contents,
-    if necessary. The file extension has priority over the contents,
-    but the contents will be used if the file extension is unknown, or
-    matches multiple MIME types.
-
-    A valid MIME type is always returned. If the file doesn't match any
-    known pattern or data, the default MIME type (application/octet-stream)
-    is returned.
-
-    The \a fileName can also include an absolute or relative path.
-*/
-QMimeType QMimeDatabase::findByFile(const QString &fileName) const
-{
-    // Implemented as a wrapper around findByFile(QFileInfo), so no mutex.
-    QFileInfo fileInfo(fileName);
-    return findByFile(fileInfo);
+    if (flags == MatchDefault) {
+        return d->mimeTypeForNameAndData(fileInfo.absoluteFilePath(), &file, &priority);
+    } else if (flags == MatchExtension) {
+        locker.unlock();
+        return mimeTypeForFile(fileInfo.absoluteFilePath(), flags);
+    } else { // MatchContent
+        if (file.open(QIODevice::ReadOnly)) {
+            locker.unlock();
+            return findByData(&file);
+        } else
+            return d->mimeTypeForName(d->defaultMimeType());
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \fn QMimeType QMimeDatabase::findByFileName(const QString &fileName) const;
-    \brief Returns a MIME type for the file name \a fileName.
+    \brief Returns a MIME type for the file named \a fileName.
 
-    A valid MIME type is always returned. If the file name doesn't match any
-    known pattern, the default MIME type (application/octet-stream)
-    is returned.
-    If multiple MIME types match this file, the first one (alphabetically) is returned.
-
-    This function does not try to open the file. To also use the content
-    when determining the MIME type, use findByFile() or
-    findByFileNameAndData() instead.
-
-    \sa findMimeTypesByFileName
+    \overload
 */
-QMimeType QMimeDatabase::findByFileName(const QString &fileName) const
+QMimeType QMimeDatabase::mimeTypeForFile(const QString &fileName, MatchFlags flags) const
 {
-    QMutexLocker locker(&d->mutex);
-
-    QStringList matches = d->findByFileName(fileName);
-    const int matchCount = matches.count();
-    if (matchCount == 0)
-        return d->mimeTypeForName(d->defaultMimeType());
-    else if (matchCount == 1)
-        return d->mimeTypeForName(matches.first());
-    else {
-        // We have to pick one.
-        matches.sort(); // Make it deterministic
-        return d->mimeTypeForName(matches.first());
+    if (flags == MatchExtension) {
+        QMutexLocker locker(&d->mutex);
+        QStringList matches = d->mimeTypeForFileName(fileName);
+        const int matchCount = matches.count();
+        if (matchCount == 0)
+            return d->mimeTypeForName(d->defaultMimeType());
+        else if (matchCount == 1)
+            return d->mimeTypeForName(matches.first());
+        else {
+            // We have to pick one.
+            matches.sort(); // Make it deterministic
+            return d->mimeTypeForName(matches.first());
+        }
+    } else {
+        // Implemented as a wrapper around mimeTypeForFile(QFileInfo), so no mutex.
+        QFileInfo fileInfo(fileName);
+        return mimeTypeForFile(fileInfo);
     }
 }
 
@@ -467,15 +459,15 @@ QMimeType QMimeDatabase::findByFileName(const QString &fileName) const
 
     This function does not try to open the file. To also use the content
     when determining the MIME type, use findByFile() or
-    findByFileNameAndData() instead.
+    mimeTypeForNameAndData() instead.
 
-    \sa findByFileName
+    \sa mimeTypeForFile
 */
 QList<QMimeType> QMimeDatabase::findMimeTypesByFileName(const QString &fileName) const
 {
     QMutexLocker locker(&d->mutex);
 
-    QStringList matches = d->findByFileName(fileName);
+    QStringList matches = d->mimeTypeForFileName(fileName);
     QList<QMimeType> mimes;
     matches.sort(); // Make it deterministic
     foreach (const QString& mime, matches) {
@@ -495,7 +487,7 @@ QString QMimeDatabase::suffixForFileName(const QString &fileName) const
 {
     QMutexLocker locker(&d->mutex);
     QString foundSuffix;
-    d->findByFileName(fileName, &foundSuffix);
+    d->mimeTypeForFileName(fileName, &foundSuffix);
     return foundSuffix;
 }
 
@@ -544,7 +536,7 @@ QMimeType QMimeDatabase::findByData(QIODevice* device) const
 /*!
     Returns a MIME type for \a url.
 
-    If the url is a local file, this calls findByFile.
+    If the url is a local file, this calls mimeTypeForFile.
     Otherwise the matching is done based on the name only
     (except over schemes where filenames don't mean much, like HTTP)
 
@@ -556,18 +548,18 @@ QMimeType QMimeDatabase::findByUrl(const QUrl &url) const
 {
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
     if (url.isLocalFile())
-        return findByFile(url.toLocalFile());
+        return mimeTypeForFile(url.toLocalFile());
 #else
     QString localFile(url.toLocalFile());
     if (!localFile.isEmpty())
-        return findByFile(localFile);
+        return mimeTypeForFile(localFile);
 #endif
 
     const QString scheme = url.scheme();
     if (scheme.startsWith(QLatin1String("http")))
         return mimeTypeForName(d->defaultMimeType());
 
-    return findByFileName(url.path());
+    return mimeTypeForFile(url.path());
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -588,12 +580,12 @@ QMimeType QMimeDatabase::findByUrl(const QUrl &url) const
     but the contents will be used if the file extension is unknown, or
     matches multiple MIME types.
 */
-QMimeType QMimeDatabase::findByFileNameAndData(const QString &fileName, QIODevice *device) const
+QMimeType QMimeDatabase::mimeTypeForNameAndData(const QString &fileName, QIODevice *device) const
 {
     DBG() << "fileName" << fileName;
 
     int accuracy = 0;
-    return d->findByFileNameAndData(fileName, device, &accuracy);
+    return d->mimeTypeForNameAndData(fileName, device, &accuracy);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -614,13 +606,13 @@ QMimeType QMimeDatabase::findByFileNameAndData(const QString &fileName, QIODevic
     but the contents will be used if the file extension is unknown, or
     matches multiple MIME types.
 */
-QMimeType QMimeDatabase::findByFileNameAndData(const QString &fileName, const QByteArray &data) const
+QMimeType QMimeDatabase::mimeTypeForNameAndData(const QString &fileName, const QByteArray &data) const
 {
     DBG() << "fileName" << fileName;
 
     QBuffer buffer(const_cast<QByteArray *>(&data));
     int accuracy = 0;
-    return d->findByFileNameAndData(fileName, &buffer, &accuracy);
+    return d->mimeTypeForNameAndData(fileName, &buffer, &accuracy);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -630,7 +622,7 @@ QMimeType QMimeDatabase::findByFileNameAndData(const QString &fileName, const QB
 
     This can be useful for showing all MIME types to the user, for instance
     in a MIME type editor. Do not use unless really necessary in other cases
-    though, prefer using the findBy* methods for performance reasons.
+    though, prefer using the mimeTypeFor* methods for performance reasons.
 */
 QList<QMimeType> QMimeDatabase::allMimeTypes() const
 {
diff --git a/src/mimetypes/qmimedatabase.h b/src/mimetypes/qmimedatabase.h
index ad1aefc..47c59eb 100644
--- a/src/mimetypes/qmimedatabase.h
+++ b/src/mimetypes/qmimedatabase.h
@@ -47,17 +47,22 @@ public:
 
     QMimeType mimeTypeForName(const QString &nameOrAlias) const;
 
-    QMimeType findByFileName(const QString &fileName) const;
+    enum MatchFlags {
+        MatchDefault = 0x0,
+        MatchExtension = 0x1,
+        MatchContent = 0x2
+    };
+
+    QMimeType mimeTypeForFile(const QString &fileName, MatchFlags flags = MatchDefault) const;
+    QMimeType mimeTypeForFile(const QFileInfo &fileInfo, MatchFlags flags = MatchDefault) const;
     QList<QMimeType> findMimeTypesByFileName(const QString &fileName) const;
 
     QMimeType findByData(const QByteArray &data) const;
     QMimeType findByData(QIODevice *device) const;
 
-    QMimeType findByFile(const QString &fileName) const;
-    QMimeType findByFile(const QFileInfo &fileInfo) const;
     QMimeType findByUrl(const QUrl &url) const;
-    QMimeType findByFileNameAndData(const QString &fileName, QIODevice *device) const;
-    QMimeType findByFileNameAndData(const QString &fileName, const QByteArray &data) const;
+    QMimeType mimeTypeForNameAndData(const QString &fileName, QIODevice *device) const;
+    QMimeType mimeTypeForNameAndData(const QString &fileName, const QByteArray &data) const;
 
     QString suffixForFileName(const QString &fileName) const;
 
diff --git a/src/mimetypes/qmimedatabase_p.h b/src/mimetypes/qmimedatabase_p.h
index f418c35..106ad7a 100644
--- a/src/mimetypes/qmimedatabase_p.h
+++ b/src/mimetypes/qmimedatabase_p.h
@@ -59,9 +59,9 @@ struct QMimeDatabasePrivate
 
 
     QMimeType mimeTypeForName(const QString &nameOrAlias);
-    QMimeType findByFileNameAndData(const QString &fileName, QIODevice *device, int *priorityPtr);
+    QMimeType mimeTypeForNameAndData(const QString &fileName, QIODevice *device, int *priorityPtr);
     QMimeType findByData(const QByteArray &data, int *priorityPtr);
-    QStringList findByFileName(const QString &fileName, QString *foundSuffix = 0);
+    QStringList mimeTypeForFileName(const QString &fileName, QString *foundSuffix = 0);
 
     mutable QMimeProviderBase *m_provider;
     const QString m_defaultMimeType;
diff --git a/tests/auto/qdeclarativemimedatabase/tst_qdeclarativemimedatabase.qml b/tests/auto/qdeclarativemimedatabase/tst_qdeclarativemimedatabase.qml
index 89b2edb..da3627e 100644
--- a/tests/auto/qdeclarativemimedatabase/tst_qdeclarativemimedatabase.qml
+++ b/tests/auto/qdeclarativemimedatabase/tst_qdeclarativemimedatabase.qml
@@ -140,14 +140,14 @@ TestCase {
         return false;
     }
 
-    function test_findByFileName() {
+    function test_mimeTypeForFileName() {
         var ok = 0
 
         for (var listIx = 0; listIx < list().length; ++listIx) {
             //print(listValue(listIx).filePath)
 
-            var resultMimeTypeName = database.findByFileName(listValue(listIx).filePath).name
-            //print("findByFileName(" + listValue(listIx).filePath + ") returned", resultMimeTypeName)
+            var resultMimeTypeName = database.mimeTypeForFileName(listValue(listIx).filePath).name
+            //print("mimeTypeForFileName(" + listValue(listIx).filePath + ") returned", resultMimeTypeName)
 
             // Results are ambiguous when multiple MIME types have the same glob
             // -> accept the current result if the found MIME type actually
@@ -183,14 +183,14 @@ TestCase {
         compare(ok, list().length)
     }
     
-    function test_findByFile() {
+    function test_mimeTypeForFile() {
         var ok = 0
 
         for (var listIx = 0; listIx < list().length; ++listIx) {
             //print(listValue(listIx).filePath)
 
-            var resultMimeTypeName = database.findByFile(listValue(listIx).filePath).name
-            //print("findByFile(" + listValue(listIx).filePath + ") returned", resultMimeTypeName)
+            var resultMimeTypeName = database.mimeTypeForFile(listValue(listIx).filePath).name
+            //print("mimeTypeForFile(" + listValue(listIx).filePath + ") returned", resultMimeTypeName)
 
             // Expected to fail
             if (listValue(listIx).xFail.length >= 3 && listValue(listIx).xFail[2] == "x") {
diff --git a/tests/auto/qmimedatabase/tst_qmimedatabase.cpp b/tests/auto/qmimedatabase/tst_qmimedatabase.cpp
index 8c8dc89..653c99c 100644
--- a/tests/auto/qmimedatabase/tst_qmimedatabase.cpp
+++ b/tests/auto/qmimedatabase/tst_qmimedatabase.cpp
@@ -149,13 +149,13 @@ void tst_qmimedatabase::test_mimeTypeForName()
     else {
         const QString executableType = QString::fromLatin1("application/x-executable");
         //QTest::newRow("executable") << exePath << executableType;
-        QCOMPARE(db.findByFile(exePath).name(), executableType);
+        QCOMPARE(db.mimeTypeForFile(exePath).name(), executableType);
     }
 #endif
 
 }
 
-void tst_qmimedatabase::test_findByFileName_data()
+void tst_qmimedatabase::test_mimeTypeForFileName_data()
 {
     QTest::addColumn<QString>("fileName");
     QTest::addColumn<QString>("expectedMimeType");
@@ -190,12 +190,12 @@ void tst_qmimedatabase::test_findByFileName_data()
     QTest::newRow("doesn't exist but has known extension") << "IDontExist.txt" << "text/plain";
 }
 
-void tst_qmimedatabase::test_findByFileName()
+void tst_qmimedatabase::test_mimeTypeForFileName()
 {
     QFETCH(QString, fileName);
     QFETCH(QString, expectedMimeType);
     QMimeDatabase db;
-    QMimeType mime = db.findByFileName(fileName);
+    QMimeType mime = db.mimeTypeForFile(fileName, QMimeDatabase::MatchExtension);
     QVERIFY(mime.isValid());
     QCOMPARE(mime.name(), expectedMimeType);
 
@@ -320,12 +320,12 @@ void tst_qmimedatabase::test_aliases()
 void tst_qmimedatabase::test_icons()
 {
     QMimeDatabase db;
-    QMimeType directory = db.findByFileName(QString::fromLatin1("/"));
+    QMimeType directory = db.mimeTypeForFile(QString::fromLatin1("/"));
     QCOMPARE(directory.name(), QString::fromLatin1("inode/directory"));
     QCOMPARE(directory.iconName(), QString::fromLatin1("inode-directory"));
     QCOMPARE(directory.genericIconName(), QString::fromLatin1("inode-x-generic"));
 
-    QMimeType pub = db.findByFileName(QString::fromLatin1("foo.epub"));
+    QMimeType pub = db.mimeTypeForFile(QString::fromLatin1("foo.epub"), QMimeDatabase::MatchExtension);
     QCOMPARE(pub.name(), QString::fromLatin1("application/epub+zip"));
     QCOMPARE(pub.iconName(), QString::fromLatin1("application-epub+zip"));
     QCOMPARE(pub.genericIconName(), QString::fromLatin1("x-office-document"));
@@ -345,13 +345,13 @@ void tst_qmimedatabase::test_findByFileWithContent()
     QString tempFileName = tempFile.fileName();
     tempFile.write("%PDF-");
     tempFile.close();
-    mime = db.findByFile(tempFileName);
+    mime = db.mimeTypeForFile(tempFileName);
     QCOMPARE(mime.name(), QString::fromLatin1("application/pdf"));
     QFile file(tempFileName);
     mime = db.findByData(&file); // QIODevice ctor
     QCOMPARE(mime.name(), QString::fromLatin1("application/pdf"));
     // by name only, we cannot find the mimetype
-    mime = db.findByFileName(tempFileName);
+    mime = db.mimeTypeForFile(tempFileName, QMimeDatabase::MatchExtension);
     QVERIFY(mime.isValid());
     QVERIFY(mime.isDefault());
 
@@ -362,10 +362,10 @@ void tst_qmimedatabase::test_findByFileWithContent()
         txtTempFile.write("%PDF-");
         QString txtTempFileName = txtTempFile.fileName();
         txtTempFile.close();
-        mime = db.findByFile(txtTempFileName);
+        mime = db.mimeTypeForFile(txtTempFileName);
         QCOMPARE(mime.name(), QString::fromLatin1("text/plain"));
         // fast mode finds the same
-        mime = db.findByFileName(txtTempFileName);
+        mime = db.mimeTypeForFile(txtTempFileName, QMimeDatabase::MatchExtension);
         QCOMPARE(mime.name(), QString::fromLatin1("text/plain"));
     }
 
@@ -377,12 +377,12 @@ void tst_qmimedatabase::test_findByFileWithContent()
         txtTempFile.write("<smil");
         QString txtTempFileName = txtTempFile.fileName();
         txtTempFile.close();
-        mime = db.findByFile(txtTempFileName);
+        mime = db.mimeTypeForFile(txtTempFileName);
         QCOMPARE(mime.name(), QString::fromLatin1("text/plain"));
     }
 
     // Test what happens with an incorrect path
-    mime = db.findByFile(QString::fromLatin1("file:///etc/passwd" /* incorrect code, use a path instead */));
+    mime = db.mimeTypeForFile(QString::fromLatin1("file:///etc/passwd" /* incorrect code, use a path instead */));
     QVERIFY(mime.isDefault());
 
     // findByData when the device cannot be opened (e.g. a directory)
@@ -421,7 +421,7 @@ void tst_qmimedatabase::test_findByContent()
     QCOMPARE(db.findByData(&buffer).name(), expectedMimeTypeName);
 }
 
-void tst_qmimedatabase::test_findByFileNameAndContent_data()
+void tst_qmimedatabase::test_mimeTypeForFileAndContent_data()
 {
     QTest::addColumn<QString>("name");
     QTest::addColumn<QByteArray>("data");
@@ -440,14 +440,14 @@ void tst_qmimedatabase::test_findByFileNameAndContent_data()
     QTest::newRow("text.xls, found by extension, user is in control") << QString::fromLatin1("text.xls") << oleData << "application/vnd.ms-excel";
 }
 
-void tst_qmimedatabase::test_findByFileNameAndContent()
+void tst_qmimedatabase::test_mimeTypeForFileAndContent()
 {
     QFETCH(QString, name);
     QFETCH(QByteArray, data);
     QFETCH(QString, expectedMimeTypeName);
 
     QMimeDatabase db;
-    QCOMPARE(db.findByFileNameAndData(name, data).name(), expectedMimeTypeName);
+    QCOMPARE(db.mimeTypeForNameAndData(name, data).name(), expectedMimeTypeName);
 }
 
 void tst_qmimedatabase::test_allMimeTypes()
@@ -588,7 +588,7 @@ void tst_qmimedatabase::findByFileName()
 
     //qDebug() << Q_FUNC_INFO << filePath;
 
-    const QMimeType resultMimeType(database.findByFileName(filePath));
+    const QMimeType resultMimeType(database.mimeTypeForFile(filePath, QMimeDatabase::MatchExtension));
     if (resultMimeType.isValid()) {
         //qDebug() << Q_FUNC_INFO << "MIME type" << resultMimeType.name() << "has generic icon name" << resultMimeType.genericIconName() << "and icon name" << resultMimeType.iconName();
 
@@ -606,7 +606,7 @@ void tst_qmimedatabase::findByFileName()
 #endif
     }
     const QString resultMimeTypeName = resultMimeType.name();
-    //qDebug() << Q_FUNC_INFO << "findByFileName() returned" << resultMimeTypeName;
+    //qDebug() << Q_FUNC_INFO << "mimeTypeForFile() returned" << resultMimeTypeName;
 
     const bool failed = resultMimeTypeName != mimeTypeName;
     const bool shouldFail = (xFail.length() >= 1 && xFail.at(0) == QLatin1Char('x'));
@@ -630,6 +630,10 @@ void tst_qmimedatabase::findByFileName()
     } else {
         QCOMPARE(resultMimeTypeName, mimeTypeName);
     }
+
+    // Test QFileInfo overload
+    const QMimeType mimeForFileInfo = database.mimeTypeForFile(QFileInfo(filePath), QMimeDatabase::MatchExtension);
+    QCOMPARE(mimeForFileInfo.name(), resultMimeTypeName);
 }
 
 void tst_qmimedatabase::findByData_data()
@@ -655,6 +659,10 @@ void tst_qmimedatabase::findByData()
     } else {
         QCOMPARE(resultMimeTypeName, mimeTypeName);
     }
+
+    QFileInfo info(filePath);
+    QString mimeForInfo = database.mimeTypeForFile(info, QMimeDatabase::MatchContent).name();
+    QCOMPARE(mimeForInfo, resultMimeTypeName);
 }
 
 void tst_qmimedatabase::findByFile_data()
@@ -669,7 +677,7 @@ void tst_qmimedatabase::findByFile()
     QFETCH(QString, xFail);
 
     QMimeDatabase database;
-    const QString resultMimeTypeName = database.findByFile(QFileInfo(filePath)).name();
+    const QString resultMimeTypeName = database.mimeTypeForFile(filePath).name();
     //qDebug() << Q_FUNC_INFO << filePath << "->" << resultMimeTypeName;
     if (xFail.length() >= 3 && xFail.at(2) == QLatin1Char('x')) {
         // Expected to fail
@@ -677,6 +685,10 @@ void tst_qmimedatabase::findByFile()
     } else {
         QCOMPARE(resultMimeTypeName, mimeTypeName);
     }
+
+    // Test QFileInfo overload
+    const QMimeType mimeForFileInfo = database.mimeTypeForFile(QFileInfo(filePath));
+    QCOMPARE(mimeForFileInfo.name(), resultMimeTypeName);
 }
 
 
@@ -761,14 +773,16 @@ void tst_qmimedatabase::installNewGlobalMimeType()
     QVERIFY(QFile::copy(srcFile, destFile));
     waitAndRunUpdateMimeDatabase(mimeDir);
 
-    QCOMPARE(db.findByFileName(QLatin1String("foo.ymu")).name(), QString::fromLatin1("text/x-suse-ymu"));
+    QCOMPARE(db.mimeTypeForFile(QLatin1String("foo.ymu"), QMimeDatabase::MatchExtension).name(),
+             QString::fromLatin1("text/x-suse-ymu"));
     QVERIFY(db.mimeTypeForName(QLatin1String("text/x-suse-ymp")).isValid());
     checkHasMimeType("text/x-suse-ymp");
 
     // Now test removing it again
     QFile::remove(destFile);
     waitAndRunUpdateMimeDatabase(mimeDir);
-    QCOMPARE(db.findByFileName(QLatin1String("foo.ymu")).name(), QString::fromLatin1("application/octet-stream"));
+    QCOMPARE(db.mimeTypeForFile(QLatin1String("foo.ymu"), QMimeDatabase::MatchExtension).name(),
+             QString::fromLatin1("application/octet-stream"));
     QVERIFY(!db.mimeTypeForName(QLatin1String("text/x-suse-ymp")).isValid());
 }
 
@@ -789,19 +803,22 @@ void tst_qmimedatabase::installNewLocalMimeType()
     QVERIFY(QFile::copy(srcFile, destFile));
     runUpdateMimeDatabase(mimeDir);
 
-    QCOMPARE(db.findByFileName(QLatin1String("foo.ymu")).name(), QString::fromLatin1("text/x-suse-ymu"));
+    QCOMPARE(db.mimeTypeForFile(QLatin1String("foo.ymu"), QMimeDatabase::MatchExtension).name(),
+             QString::fromLatin1("text/x-suse-ymu"));
     QVERIFY(db.mimeTypeForName(QLatin1String("text/x-suse-ymp")).isValid());
     checkHasMimeType("text/x-suse-ymp");
 
     // Now test removing it again (note, this leaves a mostly-empty mime.cache file)
     QFile::remove(destFile);
     waitAndRunUpdateMimeDatabase(mimeDir);
-    QCOMPARE(db.findByFileName(QLatin1String("foo.ymu")).name(), QString::fromLatin1("application/octet-stream"));
+    QCOMPARE(db.mimeTypeForFile(QLatin1String("foo.ymu"), QMimeDatabase::MatchExtension).name(),
+             QString::fromLatin1("application/octet-stream"));
     QVERIFY(!db.mimeTypeForName(QLatin1String("text/x-suse-ymp")).isValid());
 
     // And now the user goes wild and uses rm -rf
     QFile::remove(mimeDir + QString::fromLatin1("/mime.cache"));
-    QCOMPARE(db.findByFileName(QLatin1String("foo.ymu")).name(), QString::fromLatin1("application/octet-stream"));
+    QCOMPARE(db.mimeTypeForFile(QLatin1String("foo.ymu"), QMimeDatabase::MatchExtension).name(),
+             QString::fromLatin1("application/octet-stream"));
     QVERIFY(!db.mimeTypeForName(QLatin1String("text/x-suse-ymp")).isValid());
 }
 
diff --git a/tests/auto/qmimedatabase/tst_qmimedatabase.h b/tests/auto/qmimedatabase/tst_qmimedatabase.h
index 74b9fa2..3ffeb6a 100644
--- a/tests/auto/qmimedatabase/tst_qmimedatabase.h
+++ b/tests/auto/qmimedatabase/tst_qmimedatabase.h
@@ -22,8 +22,8 @@ private slots:
     void cleanupTestCase();
 
     void test_mimeTypeForName();
-    void test_findByFileName_data();
-    void test_findByFileName();
+    void test_mimeTypeForFileName_data();
+    void test_mimeTypeForFileName();
     void test_findMultipleByName_data();
     void test_findMultipleByName();
     void test_inheritance();
@@ -33,8 +33,8 @@ private slots:
     void test_findByUrl();
     void test_findByContent_data();
     void test_findByContent();
-    void test_findByFileNameAndContent_data();
-    void test_findByFileNameAndContent();
+    void test_mimeTypeForFileAndContent_data();
+    void test_mimeTypeForFileAndContent();
     void test_allMimeTypes();
     void test_inheritsPerformance();
     void test_suffixes_data();