Rename QPlatformMediaRecorder::error(code, desc) => updateError

The name 'updateError' works better as QPlatformMediaRecorder::error()
is also a getter returning the current error code.

Pick-to: 6.7 6.5
Change-Id: I9c6cdf4caa997a9465fc8fa89e50548432aee01c
Reviewed-by: Jøger Hansegård <joger.hansegard@qt.io>

11 files changed, 50 insertions, 50 deletions

diff --git a/src/multimedia/platform/qplatformmediarecorder.cpp b/src/multimedia/platform/qplatformmediarecorder.cpp
index ba9ea0165..30dba0a45 100644
--- a/src/multimedia/platform/qplatformmediarecorder.cpp
+++ b/src/multimedia/platform/qplatformmediarecorder.cpp
@@ -15,12 +15,12 @@ QPlatformMediaRecorder::QPlatformMediaRecorder(QMediaRecorder *parent)
 
 void QPlatformMediaRecorder::pause()
 {
-    error(QMediaRecorder::FormatError, QMediaRecorder::tr("Pause not supported"));
+    updateError(QMediaRecorder::FormatError, QMediaRecorder::tr("Pause not supported"));
 }
 
 void QPlatformMediaRecorder::resume()
 {
-    error(QMediaRecorder::FormatError, QMediaRecorder::tr("Resume not supported"));
+    updateError(QMediaRecorder::FormatError, QMediaRecorder::tr("Resume not supported"));
 }
 
 void QPlatformMediaRecorder::stateChanged(QMediaRecorder::RecorderState state)
@@ -47,7 +47,7 @@ void QPlatformMediaRecorder::actualLocationChanged(const QUrl &location)
     emit q->actualLocationChanged(location);
 }
 
-void QPlatformMediaRecorder::error(QMediaRecorder::Error error, const QString &errorString)
+void QPlatformMediaRecorder::updateError(QMediaRecorder::Error error, const QString &errorString)
 {
     m_error.setAndNotify(error, errorString, *q);
 }
diff --git a/src/multimedia/platform/qplatformmediarecorder_p.h b/src/multimedia/platform/qplatformmediarecorder_p.h
index 6e88dc187..dea45ac70 100644
--- a/src/multimedia/platform/qplatformmediarecorder_p.h
+++ b/src/multimedia/platform/qplatformmediarecorder_p.h
@@ -125,7 +125,7 @@ public:
     virtual void setOutputLocation(const QUrl &location) { m_outputLocation = location; }
     QUrl actualLocation() const { return m_actualLocation; }
     void clearActualLocation() { m_actualLocation.clear(); }
-    void clearError() { error(QMediaRecorder::NoError, QString()); }
+    void clearError() { updateError(QMediaRecorder::NoError, QString()); }
 
     QIODevice *outputDevice() const { return m_outputDevice; }
     void setOutputDevice(QIODevice *device) { m_outputDevice = device; }
@@ -136,7 +136,7 @@ protected:
     void stateChanged(QMediaRecorder::RecorderState state);
     void durationChanged(qint64 position);
     void actualLocationChanged(const QUrl &location);
-    void error(QMediaRecorder::Error error, const QString &errorString);
+    void updateError(QMediaRecorder::Error error, const QString &errorString);
     void metaDataChanged();
 
     QMediaRecorder *mediaRecorder() { return q; }
diff --git a/src/plugins/multimedia/android/mediacapture/qandroidcapturesession.cpp b/src/plugins/multimedia/android/mediacapture/qandroidcapturesession.cpp
index ee5af5dfd..3b005e4a5 100644
--- a/src/plugins/multimedia/android/mediacapture/qandroidcapturesession.cpp
+++ b/src/plugins/multimedia/android/mediacapture/qandroidcapturesession.cpp
@@ -133,7 +133,7 @@ void QAndroidCaptureSession::start(QMediaEncoderSettings &settings, const QUrl &
         return;
 
     if (!m_cameraSession && !m_audioInput) {
-        emit error(QMediaRecorder::ResourceError, QLatin1String("No devices are set"));
+        updateError(QMediaRecorder::ResourceError, QLatin1String("No devices are set"));
         return;
     }
 
@@ -142,13 +142,13 @@ void QAndroidCaptureSession::start(QMediaEncoderSettings &settings, const QUrl &
     const bool validCameraSession = m_cameraSession && m_cameraSession->camera();
 
     if (validCameraSession && !qt_androidCheckCameraPermission()) {
-        emit error(QMediaRecorder::ResourceError, QLatin1String("Camera permission denied."));
+        updateError(QMediaRecorder::ResourceError, QLatin1String("Camera permission denied."));
         setKeepAlive(false);
         return;
     }
 
     if (m_audioInput && !qt_androidCheckMicrophonePermission()) {
-        emit error(QMediaRecorder::ResourceError, QLatin1String("Microphone permission denied."));
+        updateError(QMediaRecorder::ResourceError, QLatin1String("Microphone permission denied."));
         setKeepAlive(false);
         return;
     }
@@ -221,15 +221,15 @@ void QAndroidCaptureSession::start(QMediaEncoderSettings &settings, const QUrl &
     }
 
     if (!m_mediaRecorder->prepare()) {
-        emit error(QMediaRecorder::FormatError, QLatin1String("Unable to prepare the media recorder."));
+        updateError(QMediaRecorder::FormatError,
+                    QLatin1String("Unable to prepare the media recorder."));
         restartViewfinder();
 
         return;
     }
 
     if (!m_mediaRecorder->start()) {
-        emit error(QMediaRecorder::FormatError,
-                   QMediaRecorderPrivate::msgFailedStartRecording());
+        updateError(QMediaRecorder::FormatError, QMediaRecorderPrivate::msgFailedStartRecording());
         restartViewfinder();
 
         return;
@@ -451,7 +451,7 @@ void QAndroidCaptureSession::onError(int what, int extra)
     Q_UNUSED(what);
     Q_UNUSED(extra);
     stop(true);
-    emit error(QMediaRecorder::ResourceError, QLatin1String("Unknown error."));
+    updateError(QMediaRecorder::ResourceError, QLatin1String("Unknown error."));
 }
 
 void QAndroidCaptureSession::onInfo(int what, int extra)
@@ -460,11 +460,11 @@ void QAndroidCaptureSession::onInfo(int what, int extra)
     if (what == 800) {
         // MEDIA_RECORDER_INFO_MAX_DURATION_REACHED
         stop();
-        emit error(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum duration reached."));
+        updateError(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum duration reached."));
     } else if (what == 801) {
         // MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
         stop();
-        emit error(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum file size reached."));
+        updateError(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum file size reached."));
     }
 }
 
diff --git a/src/plugins/multimedia/android/mediacapture/qandroidcapturesession_p.h b/src/plugins/multimedia/android/mediacapture/qandroidcapturesession_p.h
index ab91fc3ef..161d47994 100644
--- a/src/plugins/multimedia/android/mediacapture/qandroidcapturesession_p.h
+++ b/src/plugins/multimedia/android/mediacapture/qandroidcapturesession_p.h
@@ -67,10 +67,10 @@ public:
         if (m_mediaEncoder)
             m_mediaEncoder->actualLocationChanged(location);
     }
-    void error(int error, const QString &errorString)
+    void updateError(int error, const QString &errorString)
     {
         if (m_mediaEncoder)
-            m_mediaEncoder->error(QMediaRecorder::Error(error), errorString);
+            m_mediaEncoder->updateError(QMediaRecorder::Error(error), errorString);
     }
 
 private Q_SLOTS:
diff --git a/src/plugins/multimedia/darwin/camera/avfmediaencoder.mm b/src/plugins/multimedia/darwin/camera/avfmediaencoder.mm
index 4a138d4e9..3fbc57995 100644
--- a/src/plugins/multimedia/darwin/camera/avfmediaencoder.mm
+++ b/src/plugins/multimedia/darwin/camera/avfmediaencoder.mm
@@ -479,7 +479,7 @@ void AVFMediaEncoder::record(QMediaEncoderSettings &settings)
 
     if (!cameraControl && !audioInput) {
         qWarning() << Q_FUNC_INFO << "Cannot record without any inputs";
-        Q_EMIT error(QMediaRecorder::ResourceError, tr("No inputs specified"));
+        updateError(QMediaRecorder::ResourceError, tr("No inputs specified"));
         return;
     }
 
@@ -491,8 +491,8 @@ void AVFMediaEncoder::record(QMediaEncoderSettings &settings)
     if (!audioOnly) {
         if (!cameraControl || !cameraControl->isActive()) {
             qCDebug(qLcCamera) << Q_FUNC_INFO << "can not start record while camera is not active";
-            Q_EMIT error(QMediaRecorder::ResourceError,
-                         QMediaRecorderPrivate::msgFailedStartRecording());
+            updateError(QMediaRecorder::ResourceError,
+                        QMediaRecorderPrivate::msgFailedStartRecording());
             return;
         }
     }
@@ -506,13 +506,13 @@ void AVFMediaEncoder::record(QMediaEncoderSettings &settings)
     NSURL *nsFileURL = fileURL.toNSURL();
     if (!nsFileURL) {
         qWarning() << Q_FUNC_INFO << "invalid output URL:" << fileURL;
-        Q_EMIT error(QMediaRecorder::ResourceError, tr("Invalid output file URL"));
+        updateError(QMediaRecorder::ResourceError, tr("Invalid output file URL"));
         return;
     }
     if (!qt_is_writable_file_URL(nsFileURL)) {
         qWarning() << Q_FUNC_INFO << "invalid output URL:" << fileURL
                     << "(the location is not writable)";
-        Q_EMIT error(QMediaRecorder::ResourceError, tr("Non-writeable file location"));
+        updateError(QMediaRecorder::ResourceError, tr("Non-writeable file location"));
         return;
     }
     if (qt_file_exists(nsFileURL)) {
@@ -520,7 +520,7 @@ void AVFMediaEncoder::record(QMediaEncoderSettings &settings)
         // Objective-C exception, which is not good at all.
         qWarning() << Q_FUNC_INFO << "invalid output URL:" << fileURL
                     << "(file already exists)";
-        Q_EMIT error(QMediaRecorder::ResourceError, tr("File already exists"));
+        updateError(QMediaRecorder::ResourceError, tr("File already exists"));
         return;
     }
 
@@ -555,8 +555,7 @@ void AVFMediaEncoder::record(QMediaEncoderSettings &settings)
         [m_writer start];
     } else {
         [session startRunning];
-        Q_EMIT error(QMediaRecorder::FormatError,
-                     QMediaRecorderPrivate::msgFailedStartRecording());
+        updateError(QMediaRecorder::FormatError, QMediaRecorderPrivate::msgFailedStartRecording());
     }
 }
 
@@ -632,7 +631,7 @@ void AVFMediaEncoder::assetWriterFinished()
 
 void AVFMediaEncoder::assetWriterError(QString err)
 {
-    Q_EMIT error(QMediaRecorder::FormatError, err);
+    updateError(QMediaRecorder::FormatError, err);
     if (m_state != QMediaRecorder::StoppedState)
         stopWriter();
 }
diff --git a/src/plugins/multimedia/ffmpeg/qffmpegmediarecorder.cpp b/src/plugins/multimedia/ffmpeg/qffmpegmediarecorder.cpp
index 97b4570d5..67eb46eb9 100644
--- a/src/plugins/multimedia/ffmpeg/qffmpegmediarecorder.cpp
+++ b/src/plugins/multimedia/ffmpeg/qffmpegmediarecorder.cpp
@@ -32,7 +32,7 @@ bool QFFmpegMediaRecorder::isLocationWritable(const QUrl &) const
 
 void QFFmpegMediaRecorder::handleSessionError(QMediaRecorder::Error code, const QString &description)
 {
-    error(code, description);
+    updateError(code, description);
     stop();
 }
 
@@ -46,7 +46,7 @@ void QFFmpegMediaRecorder::record(QMediaEncoderSettings &settings)
     const auto hasAudio = m_session->audioInput() != nullptr;
 
     if (!hasVideo && !hasAudio) {
-        error(QMediaRecorder::ResourceError, QMediaRecorder::tr("No video or audio input"));
+        updateError(QMediaRecorder::ResourceError, QMediaRecorder::tr("No video or audio input"));
         return;
     }
 
@@ -72,8 +72,8 @@ void QFFmpegMediaRecorder::record(QMediaEncoderSettings &settings)
                              << settings.audioCodec();
 
     if (!formatContext->isAVIOOpen()) {
-        error(QMediaRecorder::LocationNotWritable,
-              QMediaRecorder::tr("Cannot open the output location for writing"));
+        updateError(QMediaRecorder::LocationNotWritable,
+                    QMediaRecorder::tr("Cannot open the output location for writing"));
         return;
     }
 
diff --git a/src/plugins/multimedia/gstreamer/mediacapture/qgstreamermediaencoder.cpp b/src/plugins/multimedia/gstreamer/mediacapture/qgstreamermediaencoder.cpp
index 93baa6343..4f9d3d364 100644
--- a/src/plugins/multimedia/gstreamer/mediacapture/qgstreamermediaencoder.cpp
+++ b/src/plugins/multimedia/gstreamer/mediacapture/qgstreamermediaencoder.cpp
@@ -54,7 +54,7 @@ bool QGstreamerMediaEncoder::isLocationWritable(const QUrl &) const
 
 void QGstreamerMediaEncoder::handleSessionError(QMediaRecorder::Error code, const QString &description)
 {
-    error(code, description);
+    updateError(code, description);
     stop();
 }
 
@@ -90,7 +90,7 @@ bool QGstreamerMediaEncoder::processBusMessage(const QGstreamerMessage &msg)
         QUniqueGErrorHandle err;
         QGString debug;
         gst_message_parse_error(msg.message(), &err, &debug);
-        error(QMediaRecorder::ResourceError, QString::fromUtf8(err.get()->message));
+        updateError(QMediaRecorder::ResourceError, QString::fromUtf8(err.get()->message));
         if (!m_finalizing)
             stop();
         finalize();
@@ -262,7 +262,7 @@ void QGstreamerMediaEncoder::record(QMediaEncoderSettings &settings)
     const auto hasAudio = m_session->audioInput() != nullptr;
 
     if (!hasVideo && !hasAudio) {
-        error(QMediaRecorder::ResourceError, QMediaRecorder::tr("No camera or audio input"));
+        updateError(QMediaRecorder::ResourceError, QMediaRecorder::tr("No camera or audio input"));
         return;
     }
 
diff --git a/src/plugins/multimedia/wasm/mediacapture/qwasmmediarecorder.cpp b/src/plugins/multimedia/wasm/mediacapture/qwasmmediarecorder.cpp
index 98d0d860b..98f04616a 100644
--- a/src/plugins/multimedia/wasm/mediacapture/qwasmmediarecorder.cpp
+++ b/src/plugins/multimedia/wasm/mediacapture/qwasmmediarecorder.cpp
@@ -285,8 +285,8 @@ void QWasmMediaRecorder::setStream(emscripten::val stream)
                 theError["target"]["data-mediarecordercontext"].as<quintptr>());
 
         if (recorder) {
-            recorder->error(QMediaRecorder::ResourceError,
-                            QString::fromStdString(theError["message"].as<std::string>()));
+            recorder->updateError(QMediaRecorder::ResourceError,
+                                  QString::fromStdString(theError["message"].as<std::string>()));
             emit recorder->stateChanged(recorder->state());
         }
     };
@@ -381,12 +381,12 @@ void QWasmMediaRecorder::audioDataAvailable(emscripten::val blob, double timeCod
     auto fileReader = std::make_shared<qstdweb::FileReader>();
 
     fileReader->onError([=](emscripten::val theError) {
-        error(QMediaRecorder::ResourceError,
-              QString::fromStdString(theError["message"].as<std::string>()));
+        updateError(QMediaRecorder::ResourceError,
+                    QString::fromStdString(theError["message"].as<std::string>()));
     });
 
     fileReader->onAbort([=](emscripten::val) {
-        error(QMediaRecorder::ResourceError, QStringLiteral("File read aborted"));
+        updateError(QMediaRecorder::ResourceError, QStringLiteral("File read aborted"));
     });
 
     fileReader->onLoad([=](emscripten::val) {
@@ -473,7 +473,8 @@ void QWasmMediaRecorder::setTrackContraints(QMediaEncoderSettings &settings, ems
                     qCDebug(qWasmMediaRecorder)
                             << theError["code"].as<int>()
                             << QString::fromStdString(theError["message"].as<std::string>());
-                    error(QMediaRecorder::ResourceError, QString::fromStdString(theError["message"].as<std::string>()));
+                    updateError(QMediaRecorder::ResourceError,
+                                QString::fromStdString(theError["message"].as<std::string>()));
                 } },
             constraints);
         }
diff --git a/src/plugins/multimedia/windows/mediacapture/qwindowsmediaencoder.cpp b/src/plugins/multimedia/windows/mediacapture/qwindowsmediaencoder.cpp
index 1d901c036..512110af6 100644
--- a/src/plugins/multimedia/windows/mediacapture/qwindowsmediaencoder.cpp
+++ b/src/plugins/multimedia/windows/mediacapture/qwindowsmediaencoder.cpp
@@ -52,8 +52,8 @@ void QWindowsMediaEncoder::record(QMediaEncoderSettings &settings)
         m_mediaDeviceSession->setActive(true);
 
         if (!m_mediaDeviceSession->isActivating()) {
-            error(QMediaRecorder::ResourceError,
-                  QMediaRecorderPrivate::msgFailedStartRecording());
+            updateError(QMediaRecorder::ResourceError,
+                        QMediaRecorderPrivate::msgFailedStartRecording());
             return;
         }
     }
@@ -72,7 +72,7 @@ void QWindowsMediaEncoder::record(QMediaEncoderSettings &settings)
         stateChanged(m_state);
 
     } else {
-        error(ec, QMediaRecorderPrivate::msgFailedStartRecording());
+        updateError(ec, QMediaRecorderPrivate::msgFailedStartRecording());
     }
 }
 
@@ -85,7 +85,7 @@ void QWindowsMediaEncoder::pause()
         m_state = QMediaRecorder::PausedState;
         stateChanged(m_state);
     } else {
-        error(QMediaRecorder::FormatError, tr("Failed to pause recording"));
+        updateError(QMediaRecorder::FormatError, tr("Failed to pause recording"));
     }
 }
 
@@ -98,7 +98,7 @@ void QWindowsMediaEncoder::resume()
         m_state = QMediaRecorder::RecordingState;
         stateChanged(m_state);
     } else {
-        error(QMediaRecorder::FormatError, tr("Failed to resume recording"));
+        updateError(QMediaRecorder::FormatError, tr("Failed to resume recording"));
     }
 }
 
@@ -178,11 +178,11 @@ void QWindowsMediaEncoder::onDurationChanged(qint64 duration)
 void QWindowsMediaEncoder::onStreamingError(int errorCode)
 {
     if (errorCode == MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED)
-        error(QMediaRecorder::ResourceError, tr("Camera is no longer present"));
+        updateError(QMediaRecorder::ResourceError, tr("Camera is no longer present"));
     else if (errorCode == MF_E_AUDIO_RECORDING_DEVICE_INVALIDATED)
-        error(QMediaRecorder::ResourceError, tr("Audio input is no longer present"));
+        updateError(QMediaRecorder::ResourceError, tr("Audio input is no longer present"));
     else
-        error(QMediaRecorder::ResourceError, tr("Streaming error"));
+        updateError(QMediaRecorder::ResourceError, tr("Streaming error"));
 
     if (m_state != QMediaRecorder::StoppedState) {
         m_mediaDeviceSession->stopRecording();
@@ -194,7 +194,7 @@ void QWindowsMediaEncoder::onStreamingError(int errorCode)
 void QWindowsMediaEncoder::onRecordingError(int errorCode)
 {
     Q_UNUSED(errorCode);
-    error(QMediaRecorder::ResourceError, tr("Recording error"));
+    updateError(QMediaRecorder::ResourceError, tr("Recording error"));
 
     auto lastState = m_state;
     m_state = QMediaRecorder::StoppedState;
diff --git a/tests/auto/unit/mockbackend/qmockmediaencoder.h b/tests/auto/unit/mockbackend/qmockmediaencoder.h
index 6d475df62..6cfea1bb0 100644
--- a/tests/auto/unit/mockbackend/qmockmediaencoder.h
+++ b/tests/auto/unit/mockbackend/qmockmediaencoder.h
@@ -41,7 +41,7 @@ public:
     }
     virtual QMediaMetaData metaData() const override { return m_metaData; }
 
-    using QPlatformMediaRecorder::error;
+    using QPlatformMediaRecorder::updateError;
 
 public:
     void record(QMediaEncoderSettings &settings) override
diff --git a/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp b/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
index e5d9d57db..a11f39207 100644
--- a/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
+++ b/tests/auto/unit/multimedia/qmediarecorder/tst_qmediarecorder.cpp
@@ -195,7 +195,7 @@ void tst_QMediaRecorder::testError()
     QCOMPARE(encoder->error(), QMediaRecorder::NoError);
     QCOMPARE(encoder->errorString(), QString());
 
-    mock->error(QMediaRecorder::FormatError, errorString);
+    mock->updateError(QMediaRecorder::FormatError, errorString);
     QCOMPARE(encoder->error(), QMediaRecorder::FormatError);
     QCOMPARE(encoder->errorString(), errorString);
     QCOMPARE(spy.size(), 1);
@@ -418,7 +418,7 @@ void tst_QMediaRecorder::testEnum()
     QCOMPARE(encoder->error(), QMediaRecorder::NoError);
     QCOMPARE(encoder->errorString(), QString());
 
-    emit mock->error(QMediaRecorder::ResourceError, errorString);
+    mock->updateError(QMediaRecorder::ResourceError, errorString);
     QCOMPARE(encoder->error(), QMediaRecorder::ResourceError);
     QCOMPARE(encoder->errorString(), errorString);
     QCOMPARE(spy.size(), 1);