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>

6 files changed, 89 insertions, 92 deletions

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;