Fix debug stream operators.

- Use QDebugStateSaver to restore space setting in stream operators
  instead of returning dbg.space() which breaks formatting on streams
  that already have nospace() set.
- Fix some single character string constants, streamline code.

Change-Id: I18ae7324b172ea801aa9b5fe56ddf6fe527fdde9
Reviewed-by: Yoann Lopes <yoann.lopes@theqtcompany.com>

examples/multimedia/video/qmlvideo/trace.h

@@ -62,8 +62,9 @@ struct PtrWrapper
 template <typename T>
 inline QDebug& operator<<(QDebug &debug, const Trace::PtrWrapper<T> &wrapper)
 {
-    debug.nospace() << "[" << (void*)wrapper.m_ptr << "]";
+    QDebugStateSaver saver(debug);
-    return debug.space();
+    debug.nospace() << '[' << static_cast<const void *>(wrapper.m_ptr) << ']';
+    return debug;
 }
 
 template<typename T>

examples/multimedia/video/qmlvideofx/trace.h

@@ -62,8 +62,9 @@ struct PtrWrapper
 template <typename T>
 inline QDebug &operator<<(QDebug &debug, const Trace::PtrWrapper<T> &wrapper)
 {
-    debug.nospace() << "[" << (void*)wrapper.m_ptr << "]";
+    QDebugStateSaver saver(debug);
-    return debug.space();
+    debug.nospace() << '[' << static_cast<const void *>(wrapper.m_ptr) << ']';
+    return debug;
 }
 
 #ifdef ENABLE_TRACE

src/multimedia/audio/qaudio.cpp

@@ -86,59 +86,62 @@ Q_CONSTRUCTOR_FUNCTION(qRegisterAudioMetaTypes)
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, QAudio::Error error)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (error) {
         case QAudio::NoError:
-            nospace << "NoError";
+            dbg << "NoError";
             break;
         case QAudio::OpenError:
-            nospace << "OpenError";
+            dbg << "OpenError";
             break;
         case QAudio::IOError:
-            nospace << "IOError";
+            dbg << "IOError";
             break;
         case QAudio::UnderrunError:
-            nospace << "UnderrunError";
+            dbg << "UnderrunError";
             break;
         case QAudio::FatalError:
-            nospace << "FatalError";
+            dbg << "FatalError";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, QAudio::State state)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (state) {
         case QAudio::ActiveState:
-            nospace << "ActiveState";
+            dbg << "ActiveState";
             break;
         case QAudio::SuspendedState:
-            nospace << "SuspendedState";
+            dbg << "SuspendedState";
             break;
         case QAudio::StoppedState:
-            nospace << "StoppedState";
+            dbg << "StoppedState";
             break;
         case QAudio::IdleState:
-            nospace << "IdleState";
+            dbg << "IdleState";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, QAudio::Mode mode)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (mode) {
         case QAudio::AudioInput:
-            nospace << "AudioInput";
+            dbg << "AudioInput";
             break;
         case QAudio::AudioOutput:
-            nospace << "AudioOutput";
+            dbg << "AudioOutput";
             break;
     }
-    return nospace;
+    return dbg;
 }
 #endif
 

src/multimedia/audio/qaudioformat.cpp

@@ -459,49 +459,50 @@ int QAudioFormat::bytesPerFrame() const
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, QAudioFormat::Endian endian)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (endian) {
         case QAudioFormat::BigEndian:
-            nospace << "BigEndian";
+            dbg << "BigEndian";
             break;
         case QAudioFormat::LittleEndian:
-            nospace << "LittleEndian";
+            dbg << "LittleEndian";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, QAudioFormat::SampleType type)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (type) {
         case QAudioFormat::SignedInt:
-            nospace << "SignedInt";
+            dbg << "SignedInt";
             break;
         case QAudioFormat::UnSignedInt:
-            nospace << "UnSignedInt";
+            dbg << "UnSignedInt";
             break;
         case QAudioFormat::Float:
-            nospace << "Float";
+            dbg << "Float";
             break;
        default:
-            nospace << "Unknown";
+            dbg << "Unknown";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, const QAudioFormat &f)
 {
-    dbg.nospace() << "QAudioFormat(" << f.sampleRate();
+    QDebugStateSaver saver(dbg);
-    dbg.nospace() << "Hz, " << f.sampleSize();
+    dbg.nospace();
-    dbg.nospace() << "bit, channelCount=" << f.channelCount();
+    dbg << "QAudioFormat(" << f.sampleRate() << "Hz, "
-    dbg.nospace() << ", sampleType=" << f.sampleType();
+        << f.sampleSize() << "bit, channelCount=" << f.channelCount()
-    dbg.nospace() << ", byteOrder=" << f.byteOrder();
+        << ", sampleType=" << f.sampleType() << ", byteOrder=" << f.byteOrder()
-    dbg.nospace() << ", codec=" << f.codec();
+        << ", codec=" << f.codec() << ')';
-    dbg.nospace() << ")";
 
-    return dbg.space();
+    return dbg;
 }
 #endif
 

src/multimedia/qmediatimerange.cpp

@@ -705,11 +705,13 @@ QMediaTimeRange operator-(const QMediaTimeRange &r1, const QMediaTimeRange &r2)
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, const QMediaTimeRange &range)
 {
-    dbg.nospace() << "QMediaTimeRange( ";
+    QDebugStateSaver saver(dbg);
-    foreach (const QMediaTimeInterval &interval, range.intervals()) {
+    dbg.nospace();
-        dbg.nospace() << "(" <<  interval.start() << ", " << interval.end() << ") ";
+    dbg << "QMediaTimeRange( ";
-    }
+    foreach (const QMediaTimeInterval &interval, range.intervals())
-    dbg.space() << ")";
+        dbg << '(' <<  interval.start() << ", " << interval.end() << ") ";
+    dbg.space();
+    dbg << ')';
     return dbg;
 }
 #endif

src/multimedia/video/qabstractvideobuffer.cpp

@@ -350,33 +350,37 @@ uchar *QAbstractPlanarVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPe
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, QAbstractVideoBuffer::HandleType type)
 {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (type) {
     case QAbstractVideoBuffer::NoHandle:
-        return dbg.nospace() << "NoHandle";
+        return dbg << "NoHandle";
     case QAbstractVideoBuffer::GLTextureHandle:
-        return dbg.nospace() << "GLTextureHandle";
+        return dbg << "GLTextureHandle";
     case QAbstractVideoBuffer::XvShmImageHandle:
-        return dbg.nospace() << "XvShmImageHandle";
+        return dbg << "XvShmImageHandle";
     case QAbstractVideoBuffer::CoreImageHandle:
-        return dbg.nospace() << "CoreImageHandle";
+        return dbg << "CoreImageHandle";
     case QAbstractVideoBuffer::QPixmapHandle:
-        return dbg.nospace() << "QPixmapHandle";
+        return dbg << "QPixmapHandle";
     default:
-        return dbg.nospace() << QString(QLatin1String("UserHandle(%1)")).arg(int(type)).toLatin1().constData();
+        return dbg << "UserHandle(" << int(type) << ')';
     }
 }
 
 QDebug operator<<(QDebug dbg, QAbstractVideoBuffer::MapMode mode)
 {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (mode) {
     case QAbstractVideoBuffer::ReadOnly:
-        return dbg.nospace() << "ReadOnly";
+        return dbg << "ReadOnly";
     case QAbstractVideoBuffer::ReadWrite:
-        return dbg.nospace() << "ReadWrite";
+        return dbg << "ReadWrite";
     case QAbstractVideoBuffer::WriteOnly:
-        return dbg.nospace() << "WriteOnly";
+        return dbg << "WriteOnly";
     default:
-        return dbg.nospace() << "NotMapped";
+        return dbg << "NotMapped";
     }
 }
 #endif

src/multimedia/video/qabstractvideosurface.cpp

@@ -353,18 +353,26 @@ void QAbstractVideoSurface::setNativeResolution(const QSize &resolution)
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, const QAbstractVideoSurface::Error& error)
 {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (error) {
     case QAbstractVideoSurface::UnsupportedFormatError:
-        return dbg.nospace() << "UnsupportedFormatError";
+        dbg << "UnsupportedFormatError";
+        break;
     case QAbstractVideoSurface::IncorrectFormatError:
-        return dbg.nospace() << "IncorrectFormatError";
+        dbg << "IncorrectFormatError";
+        break;
     case QAbstractVideoSurface::StoppedError:
-        return dbg.nospace() << "StoppedError";
+        dbg << "StoppedError";
+        break;
     case QAbstractVideoSurface::ResourceError:
-        return dbg.nospace() << "ResourceError";
+        dbg << "ResourceError";
+        break;
     default:
-        return dbg.nospace() << "NoError";
+        dbg << "NoError";
+        break;
     }
+    return dbg;
 }
 #endif
 

src/multimedia/video/qvideoframe.cpp

@@ -1002,90 +1002,94 @@ QImage::Format QVideoFrame::imageFormatFromPixelFormat(PixelFormat format)
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, QVideoFrame::PixelFormat pf)
 {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (pf) {
         case QVideoFrame::Format_Invalid:
-            return dbg.nospace() << "Format_Invalid";
+            return dbg << "Format_Invalid";
         case QVideoFrame::Format_ARGB32:
-            return dbg.nospace() << "Format_ARGB32";
+            return dbg << "Format_ARGB32";
         case QVideoFrame::Format_ARGB32_Premultiplied:
-            return dbg.nospace() << "Format_ARGB32_Premultiplied";
+            return dbg << "Format_ARGB32_Premultiplied";
         case QVideoFrame::Format_RGB32:
-            return dbg.nospace() << "Format_RGB32";
+            return dbg << "Format_RGB32";
         case QVideoFrame::Format_RGB24:
-            return dbg.nospace() << "Format_RGB24";
+            return dbg << "Format_RGB24";
         case QVideoFrame::Format_RGB565:
-            return dbg.nospace() << "Format_RGB565";
+            return dbg << "Format_RGB565";
         case QVideoFrame::Format_RGB555:
-            return dbg.nospace() << "Format_RGB555";
+            return dbg << "Format_RGB555";
         case QVideoFrame::Format_ARGB8565_Premultiplied:
-            return dbg.nospace() << "Format_ARGB8565_Premultiplied";
+            return dbg << "Format_ARGB8565_Premultiplied";
         case QVideoFrame::Format_BGRA32:
-            return dbg.nospace() << "Format_BGRA32";
+            return dbg << "Format_BGRA32";
         case QVideoFrame::Format_BGRA32_Premultiplied:
-            return dbg.nospace() << "Format_BGRA32_Premultiplied";
+            return dbg << "Format_BGRA32_Premultiplied";
         case QVideoFrame::Format_BGR32:
-            return dbg.nospace() << "Format_BGR32";
+            return dbg << "Format_BGR32";
         case QVideoFrame::Format_BGR24:
-            return dbg.nospace() << "Format_BGR24";
+            return dbg << "Format_BGR24";
         case QVideoFrame::Format_BGR565:
-            return dbg.nospace() << "Format_BGR565";
+            return dbg << "Format_BGR565";
         case QVideoFrame::Format_BGR555:
-            return dbg.nospace() << "Format_BGR555";
+            return dbg << "Format_BGR555";
         case QVideoFrame::Format_BGRA5658_Premultiplied:
-            return dbg.nospace() << "Format_BGRA5658_Premultiplied";
+            return dbg << "Format_BGRA5658_Premultiplied";
         case QVideoFrame::Format_AYUV444:
-            return dbg.nospace() << "Format_AYUV444";
+            return dbg << "Format_AYUV444";
         case QVideoFrame::Format_AYUV444_Premultiplied:
-            return dbg.nospace() << "Format_AYUV444_Premultiplied";
+            return dbg << "Format_AYUV444_Premultiplied";
         case QVideoFrame::Format_YUV444:
-            return dbg.nospace() << "Format_YUV444";
+            return dbg << "Format_YUV444";
         case QVideoFrame::Format_YUV420P:
-            return dbg.nospace() << "Format_YUV420P";
+            return dbg << "Format_YUV420P";
         case QVideoFrame::Format_YV12:
-            return dbg.nospace() << "Format_YV12";
+            return dbg << "Format_YV12";
         case QVideoFrame::Format_UYVY:
-            return dbg.nospace() << "Format_UYVY";
+            return dbg << "Format_UYVY";
         case QVideoFrame::Format_YUYV:
-            return dbg.nospace() << "Format_YUYV";
+            return dbg << "Format_YUYV";
         case QVideoFrame::Format_NV12:
-            return dbg.nospace() << "Format_NV12";
+            return dbg << "Format_NV12";
         case QVideoFrame::Format_NV21:
-            return dbg.nospace() << "Format_NV21";
+            return dbg << "Format_NV21";
         case QVideoFrame::Format_IMC1:
-            return dbg.nospace() << "Format_IMC1";
+            return dbg << "Format_IMC1";
         case QVideoFrame::Format_IMC2:
-            return dbg.nospace() << "Format_IMC2";
+            return dbg << "Format_IMC2";
         case QVideoFrame::Format_IMC3:
-            return dbg.nospace() << "Format_IMC3";
+            return dbg << "Format_IMC3";
         case QVideoFrame::Format_IMC4:
-            return dbg.nospace() << "Format_IMC4";
+            return dbg << "Format_IMC4";
         case QVideoFrame::Format_Y8:
-            return dbg.nospace() << "Format_Y8";
+            return dbg << "Format_Y8";
         case QVideoFrame::Format_Y16:
-            return dbg.nospace() << "Format_Y16";
+            return dbg << "Format_Y16";
         case QVideoFrame::Format_Jpeg:
-            return dbg.nospace() << "Format_Jpeg";
+            return dbg << "Format_Jpeg";
         case QVideoFrame::Format_AdobeDng:
-            return dbg.nospace() << "Format_AdobeDng";
+            return dbg << "Format_AdobeDng";
         case QVideoFrame::Format_CameraRaw:
-            return dbg.nospace() << "Format_CameraRaw";
+            return dbg << "Format_CameraRaw";
 
         default:
-            return dbg.nospace() << QString(QLatin1String("UserType(%1)" )).arg(int(pf)).toLatin1().constData();
+            return dbg << QString(QLatin1String("UserType(%1)" )).arg(int(pf)).toLatin1().constData();
     }
 }
 
 QDebug operator<<(QDebug dbg, QVideoFrame::FieldType f)
 {
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (f) {
         case QVideoFrame::TopField:
-            return dbg.nospace() << "TopField";
+            return dbg << "TopField";
         case QVideoFrame::BottomField:
-            return dbg.nospace() << "BottomField";
+            return dbg << "BottomField";
         case QVideoFrame::InterlacedFrame:
-            return dbg.nospace() << "InterlacedFrame";
+            return dbg << "InterlacedFrame";
         default:
-            return dbg.nospace() << "ProgressiveFrame";
+            return dbg << "ProgressiveFrame";
     }
 }
 
@@ -1161,16 +1165,17 @@ static QString qFormatTimeStamps(qint64 start, qint64 end)
 
 QDebug operator<<(QDebug dbg, const QVideoFrame& f)
 {
-    dbg.nospace() << "QVideoFrame(" << f.size() << ", "
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
+    dbg << "QVideoFrame(" << f.size() << ", "
                << f.pixelFormat() << ", "
                << f.handleType() << ", "
                << f.mapMode() << ", "
                << qFormatTimeStamps(f.startTime(), f.endTime()).toLatin1().constData();
-    if (f.availableMetaData().count()) {
+    if (f.availableMetaData().count())
-        dbg.nospace() << ", metaData: ";
+        dbg << ", metaData: " << f.availableMetaData();
-        dbg.nospace() << f.availableMetaData();
+    dbg << ')';
-    }
+    return dbg;
-    return dbg.nospace() << ")";
 }
 #endif
 

src/multimedia/video/qvideosurfaceformat.cpp

@@ -569,61 +569,62 @@ void QVideoSurfaceFormat::setProperty(const char *name, const QVariant &value)
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, QVideoSurfaceFormat::YCbCrColorSpace cs)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (cs) {
         case QVideoSurfaceFormat::YCbCr_BT601:
-            nospace << "YCbCr_BT601";
+            dbg << "YCbCr_BT601";
             break;
         case QVideoSurfaceFormat::YCbCr_BT709:
-            nospace << "YCbCr_BT709";
+            dbg << "YCbCr_BT709";
             break;
         case QVideoSurfaceFormat::YCbCr_JPEG:
-            nospace << "YCbCr_JPEG";
+            dbg << "YCbCr_JPEG";
             break;
         case QVideoSurfaceFormat::YCbCr_xvYCC601:
-            nospace << "YCbCr_xvYCC601";
+            dbg << "YCbCr_xvYCC601";
             break;
         case QVideoSurfaceFormat::YCbCr_xvYCC709:
-            nospace << "YCbCr_xvYCC709";
+            dbg << "YCbCr_xvYCC709";
             break;
         case QVideoSurfaceFormat::YCbCr_CustomMatrix:
-            nospace << "YCbCr_CustomMatrix";
+            dbg << "YCbCr_CustomMatrix";
             break;
         default:
-            nospace << "YCbCr_Undefined";
+            dbg << "YCbCr_Undefined";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, QVideoSurfaceFormat::Direction dir)
 {
-    QDebug nospace = dbg.nospace();
+    QDebugStateSaver saver(dbg);
+    dbg.nospace();
     switch (dir) {
         case QVideoSurfaceFormat::BottomToTop:
-            nospace << "BottomToTop";
+            dbg << "BottomToTop";
             break;
         case QVideoSurfaceFormat::TopToBottom:
-            nospace << "TopToBottom";
+            dbg << "TopToBottom";
             break;
     }
-    return nospace;
+    return dbg;
 }
 
 QDebug operator<<(QDebug dbg, const QVideoSurfaceFormat &f)
 {
-    dbg.nospace() << "QVideoSurfaceFormat(" << f.pixelFormat();
+    QDebugStateSaver saver(dbg);
-    dbg.nospace() << ", " << f.frameSize();
+    dbg.nospace();
-    dbg.nospace() << ", viewport=" << f.viewport();
+    dbg << "QVideoSurfaceFormat(" << f.pixelFormat() << ", " << f.frameSize()
-    dbg.nospace() << ", pixelAspectRatio=" << f.pixelAspectRatio();
+        << ", viewport=" << f.viewport() << ", pixelAspectRatio=" << f.pixelAspectRatio()
-    dbg.nospace() << ", handleType=" << f.handleType();
+        << ", handleType=" << f.handleType() <<  ", yCbCrColorSpace=" << f.yCbCrColorSpace()
-    dbg.nospace() << ", yCbCrColorSpace=" << f.yCbCrColorSpace();
+        << ')';
-    dbg.nospace() << ")";
 
     foreach(const QByteArray& propertyName, f.propertyNames())
         dbg << "\n    " << propertyName.data() << " = " << f.property(propertyName.data());
 
-    return dbg.space();
+    return dbg;
 }
 #endif