Refactor "startup" logic.

The first call to isEnabled() will cause the QT_LOGGING_CONFIG
environment variable to be checked.

Or if qSetLoggingRules[File]() is called, this will also check
the environment variable.

The QLoggingPrivate object is created only if a valid config file
can be found or a non-empty set of rules is given.

Change-Id: I5ed4a14e4ef105bb65663edd62c4e79761010b55
Reviewed-by: Wolfgang Beck <wolfgang.beck@nokia.com>

2 files changed, 70 insertions, 48 deletions

diff --git a/src/logger/qlogger.cpp b/src/logger/qlogger.cpp
index 302a6f4..196b973 100644
--- a/src/logger/qlogger.cpp
+++ b/src/logger/qlogger.cpp
@@ -54,9 +54,32 @@ QT_LOGGER_BEGIN_NAMESPACE
 
 Q_GLOBAL_STATIC(QLoggingPrivate, qLogging)
 
+// Set to true if a valid config file or set of rules has been specified
+static bool gEnabled = false;
+
+static enum {
+    EnvironmentNotChecked = -1, // We have not checked QT_LOGGING_CONF
+    EnvironmentNotFound = 0,    // QT_LOGGING_CONF does not indicate a valid file
+    EnvironmentFound = 1,       // QT_LOGGING_CONF is a valid file
+} gEnvironment = EnvironmentNotChecked;
+
+// Returns either the string to the config file identified by QT_LOGGING_CONFIG or an empty string
+static void checkEnvironment()
+{
+    gEnvironment = EnvironmentNotFound;
+    QByteArray ba = qgetenv("QT_LOGGING_CONFIG");
+    if (!ba.isEmpty()) {
+        QString path = QString::fromLocal8Bit(ba);
+        QString config = QLoggingPrivate::resolveConfigFile(path);
+        if (!config.isEmpty()) {
+            gEnvironment = EnvironmentFound;
+            qLogging()->setLoggingRulesFile(config);
+        }
+    }
+}
+
 namespace QLoggingCategories
 {
-    bool _enabled = false;
     QLoggingCategory default_QLoggingCategory("default");
 
     QLoggingCategory::QLoggingCategory(const char *cat)
@@ -90,14 +113,16 @@ namespace QLoggingCategories
         }
     }
 
-    bool isEnabled(QLoggingCategories::QLoggingCategory &category, QtMsgType type)
+    bool isEnabled()
     {
-        return qLogging()->isEnabled(category, type);
+        if (gEnvironment == EnvironmentNotChecked) checkEnvironment();
+        return gEnabled;
     }
 
-    bool isEnabled()
+    bool isEnabled(QLoggingCategories::QLoggingCategory &category, QtMsgType type)
     {
-        return _enabled;
+        if (!isEnabled()) return false;
+        return qLogging()->isEnabled(category, type);
     }
 
     QLoggingCategory& defaultCategory()
@@ -108,12 +133,19 @@ namespace QLoggingCategories
 
 void qSetLoggingRulesFile(const QString &path)
 {
-    qLogging()->setLoggingRulesFile(path);
+    if (gEnvironment == EnvironmentNotChecked) checkEnvironment();
+    if (gEnvironment == EnvironmentFound) return;
+    QString config = QLoggingPrivate::resolveConfigFile(path);
+    if (!config.isEmpty())
+        qLogging()->setLoggingRulesFile(config);
 }
 
 void qSetLoggingRules(const QByteArray &rules)
 {
-    qLogging()->setLoggingRules(rules);
+    if (gEnvironment == EnvironmentNotChecked) checkEnvironment();
+    if (gEnvironment == EnvironmentFound) return;
+    if (!rules.isEmpty())
+        qLogging()->setLoggingRules(rules);
 }
 
 /*!
@@ -125,13 +157,6 @@ QLoggingPrivate::QLoggingPrivate()
 {
     //add default category
     _registeredCategories.append(&QLoggingCategories::default_QLoggingCategory);
-
-     //Set the config file by using the envidonment variable QT_LOGGING_CONFIG
-    QByteArray ba = qgetenv("QT_LOGGING_CONFIG");
-    if (!ba.isEmpty()) {
-        setLoggingRulesFile(QString::fromLocal8Bit(ba));
-        _configFileEnvironmentVar = _configFile;
-    }
 }
 
 /*!
@@ -144,42 +169,43 @@ QLoggingPrivate::~QLoggingPrivate()
 
 /*!
     \internal
-    Function to set the logging config file.
-    This function set the new QLogging configuration config file.
-    If QT_LOGGING_CONFIG is set this function will do nothing.
+    Returns the resolved version of \a path.
 */
-void QLoggingPrivate::setLoggingRulesFile(const QString &path)
+QString QLoggingPrivate::resolveConfigFile(const QString &path)
 {
-    if (!_configFileEnvironmentVar.isEmpty())
-        return;
-
-    //Default no logging
-    QLoggingCategories::_enabled = false;
-
-    //check the file if its only a filename
     QFileInfo fi(path);
-    // If we have only a file, it lives in the config location
     if (fi.fileName() == path)
         fi.setFile(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + QLatin1Char('/') + path);
-    _configFile = fi.absoluteFilePath();
+    QString config = fi.absoluteFilePath();
+    if (QFile::exists(config))
+        return config;
+    return QString();
+}
 
-    //Check if logging rule file exits
-    if (QFile::exists(_configFile)) {
+/*!
+    \internal
+    Function to set the logging config file.
+    This function set the new QLogging configuration config file.
+    If QT_LOGGING_CONFIG is set this function will do nothing.
+*/
+void QLoggingPrivate::setLoggingRulesFile(const QString &path)
+{
+    gEnabled = false;
+    _configFile = path;
 
-        //Create filewatcher only if a config file exists
-        if (!_configFileWatcher) {
-            _configFileWatcher = new QFileSystemWatcher(this);
-            connect(_configFileWatcher, SIGNAL(fileChanged(QString)), SLOT(fileChanged(QString)));
-        }
+    //Create filewatcher only if a config file exists
+    if (!_configFileWatcher) {
+        _configFileWatcher = new QFileSystemWatcher(this);
+        connect(_configFileWatcher, SIGNAL(fileChanged(QString)), SLOT(fileChanged(QString)));
+    }
 
-        QStringList oldfiles = _configFileWatcher->files();
-        if (!oldfiles.isEmpty())
-            _configFileWatcher->removePaths(oldfiles);
-        _configFileWatcher->addPath(_configFile);
+    QStringList oldfiles = _configFileWatcher->files();
+    if (!oldfiles.isEmpty())
+        _configFileWatcher->removePaths(oldfiles);
+    _configFileWatcher->addPath(_configFile);
 
-        QFile cfgfile(_configFile);
-        readSettings(cfgfile);
-    }
+    QFile cfgfile(_configFile);
+    readSettings(cfgfile);
 }
 
 /*!
@@ -190,8 +216,7 @@ void QLoggingPrivate::setLoggingRulesFile(const QString &path)
 */
 void QLoggingPrivate::setLoggingRules(const QByteArray &rules)
 {
-    if (!_configFileEnvironmentVar.isEmpty())
-        return;
+    gEnabled = false;
 
     //Disable file watcher
     if (_configFileWatcher) {
@@ -199,8 +224,6 @@ void QLoggingPrivate::setLoggingRules(const QByteArray &rules)
         _configFileWatcher = 0;
     }
 
-    //Default no logging
-    QLoggingCategories::_enabled = false;
     QBuffer buffer;
     buffer.setData(rules);
     readSettings(buffer);
@@ -249,7 +272,7 @@ void QLoggingPrivate::readSettings(QIODevice &device)
             updateCategory(category);
         }
 
-        QLoggingCategories::_enabled = true;
+        gEnabled = true;
     }
 }
 
diff --git a/src/logger/qlogger_p.h b/src/logger/qlogger_p.h
index 4a3fee0..7f18b9b 100644
--- a/src/logger/qlogger_p.h
+++ b/src/logger/qlogger_p.h
@@ -76,6 +76,7 @@ public:
     QLoggingPrivate();
     virtual ~QLoggingPrivate();
 
+    static QString resolveConfigFile(const QString &path);
     void setLoggingRulesFile(const QString &path);
     void setLoggingRules(const QByteArray &configcontent);
     bool isEnabled(QLoggingCategories::QLoggingCategory &category, QtMsgType type);
@@ -90,9 +91,7 @@ private:
 private:
     QFileSystemWatcher *_configFileWatcher;
     QList<QLoggingCategories::QLoggingCategory *> _registeredCategories;
-    QString _configFileEnvironmentVar;
     QString _configFile;
-    QString _logFile;
     QMutex _mutex;
     QList<QLogConfigFilterItem> _logConfigItemList;
 };