Utils: Rename QtcProcess::readAllStandard* to readAllRawStandard*

... and re-use the old QtcProcess::readAllStandard* names for
a QString-returning 'decoded' version.

For now, only use that in 'full Utf8' cases, to stay bug-compatible,
the plan is, however, to employ the QTextCodecs we have already
in the channel buffers. That will be one-by-one, though.

Change-Id: Id209e0671920d4ea4197918e872f441254112d52
Reviewed-by: Alessandro Portale <alessandro.portale@qt.io>

src/libs/qmljs/qmljsplugindumper.cpp

@@ -231,7 +231,7 @@ static QString qmlPluginDumpErrorMessage(QtcProcess *process)
     }
     errorMessage += '\n' + PluginDumper::tr("Arguments: %1").arg(process->commandLine().arguments());
     if (process->error() != QProcess::FailedToStart) {
-        const QString stdErr = QString::fromLocal8Bit(process->readAllStandardError());
+        const QString stdErr = QString::fromLocal8Bit(process->readAllRawStandardError());
         if (!stdErr.isEmpty()) {
             errorMessage += QLatin1Char('\n');
             errorMessage += stdErr;
@@ -264,7 +264,7 @@ void PluginDumper::qmlPluginTypeDumpDone(QtcProcess *process)
             return;
         }
 
-        const QByteArray output = process->readAllStandardOutput();
+        const QByteArray output = process->readAllRawStandardOutput();
 
         class CppQmlTypesInfo {
         public:

src/libs/utils/archive.cpp

@@ -162,7 +162,7 @@ void Archive::unarchive()
     m_process.reset(new QtcProcess);
     m_process->setProcessChannelMode(QProcess::MergedChannels);
     QObject::connect(m_process.get(), &QtcProcess::readyReadStandardOutput, this, [this] {
-        emit outputReceived(QString::fromUtf8(m_process->readAllStandardOutput()));
+        emit outputReceived(m_process->readAllStandardOutput());
     });
     QObject::connect(m_process.get(), &QtcProcess::done, this, [this] {
         const bool successfulFinish = m_process->result() == ProcessResult::FinishedWithSuccess;

src/libs/utils/deviceshell.cpp

@@ -93,8 +93,8 @@ RunResult DeviceShell::run(const CommandLine &cmd, const QByteArray &stdInData)
 
         return RunResult{
             proc.exitCode(),
-            proc.readAllStandardOutput(),
+            proc.readAllRawStandardOutput(),
-            proc.readAllStandardError()
+            proc.readAllRawStandardError()
         };
     }
 
@@ -213,7 +213,7 @@ bool DeviceShell::start()
                         &QtcProcess::readyReadStandardError,
                         m_shellProcess.get(),
                         [this] {
-                            const QByteArray stdErr = m_shellProcess->readAllStandardError();
+                            const QByteArray stdErr = m_shellProcess->readAllRawStandardError();
                             qCWarning(deviceShellLog)
                                 << "Received unexpected output on stderr:" << stdErr;
                         });
@@ -249,7 +249,7 @@ bool DeviceShell::checkCommand(const QByteArray &command)
         qCWarning(deviceShellLog) << "Timeout while trying to check for" << command;
         return false;
     }
-    QByteArray out = m_shellProcess->readAllStandardOutput();
+    QByteArray out = m_shellProcess->readAllRawStandardOutput();
     if (out.contains("<missing>")) {
         m_shellScriptState = State::NoScript;
         qCWarning(deviceShellLog) << "Command" << command << "was not found";
@@ -293,7 +293,7 @@ bool DeviceShell::installShellScript()
             return false;
         }
 
-        QByteArray out = m_shellProcess->readAllStandardError();
+        QByteArray out = m_shellProcess->readAllRawStandardError();
         if (out.contains("SCRIPT_INSTALLED")) {
             m_shellScriptState = State::Succeeded;
             return true;
@@ -399,7 +399,7 @@ QList<std::tuple<int, DeviceShell::ParseType, QByteArray>> parseShellOutput(cons
  */
 void DeviceShell::onReadyRead()
 {
-    m_commandBuffer += m_shellProcess->readAllStandardOutput();
+    m_commandBuffer += m_shellProcess->readAllRawStandardOutput();
     const qsizetype lastLineEndIndex = m_commandBuffer.lastIndexOf('\n') + 1;
 
     if (lastLineEndIndex == 0)

src/libs/utils/qtcprocess.cpp

@@ -1271,7 +1271,7 @@ bool QtcProcess::readDataFromProcess(QByteArray *stdOut, QByteArray *stdErr, int
         finished = waitForFinished(timeoutS > 0 ? timeoutS * 1000 : -1)
                 || state() == QProcess::NotRunning;
         // First check 'stdout'
-        const QByteArray newStdOut = readAllStandardOutput();
+        const QByteArray newStdOut = readAllRawStandardOutput();
         if (!newStdOut.isEmpty()) {
             hasData = true;
             if (stdOut)
@@ -1279,7 +1279,7 @@ bool QtcProcess::readDataFromProcess(QByteArray *stdOut, QByteArray *stdErr, int
         }
         // Check 'stderr' separately. This is a special handling
         // for 'git pull' and the like which prints its progress on stderr.
-        const QByteArray newStdErr = readAllStandardError();
+        const QByteArray newStdErr = readAllRawStandardError();
         if (!newStdErr.isEmpty()) {
             hasData = true;
             if (stdErr)
@@ -1481,12 +1481,12 @@ bool QtcProcess::waitForFinished(int msecs)
     return d->waitForSignal(ProcessSignalType::Done, msecs);
 }
 
-QByteArray QtcProcess::readAllStandardOutput()
+QByteArray QtcProcess::readAllRawStandardOutput()
 {
     return d->m_stdOut.readAllData();
 }
 
-QByteArray QtcProcess::readAllStandardError()
+QByteArray QtcProcess::readAllRawStandardError()
 {
     return d->m_stdErr.readAllData();
 }
@@ -1548,6 +1548,16 @@ void QtcProcess::stop()
     d->m_killTimer.start(d->m_process->m_setup.m_reaperTimeout);
 }
 
+QString QtcProcess::readAllStandardOutput()
+{
+    return QString::fromUtf8(readAllRawStandardOutput());
+}
+
+QString QtcProcess::readAllStandardError()
+{
+    return QString::fromUtf8(readAllRawStandardError());
+}
+
 /*!
     \class Utils::SynchronousProcess
 

src/libs/utils/qtcprocess.h

@@ -46,8 +46,11 @@ public:
     void close();
     void stop();
 
-    QByteArray readAllStandardOutput();
+    QString readAllStandardOutput();
-    QByteArray readAllStandardError();
+    QString readAllStandardError();
+
+    QByteArray readAllRawStandardOutput();
+    QByteArray readAllRawStandardError();
 
     qint64 write(const QString &input);
     qint64 writeRaw(const QByteArray &input);

src/plugins/android/androidavdmanager.cpp

@@ -106,7 +106,7 @@ static CreateAvdInfo createAvdCommand(const AndroidConfig &config, const CreateA
     QByteArray question;
     while (errorOutput.isEmpty()) {
         proc.waitForReadyRead(500);
-        question += proc.readAllStandardOutput();
+        question += proc.readAllRawStandardOutput();
         if (question.endsWith(QByteArray("]:"))) {
             // truncate to last line
             int index = question.lastIndexOf(QByteArray("\n"));
@@ -120,7 +120,7 @@ static CreateAvdInfo createAvdCommand(const AndroidConfig &config, const CreateA
         }
         // The exit code is always 0, so we need to check stderr
         // For now assume that any output at all indicates a error
-        errorOutput = QString::fromLocal8Bit(proc.readAllStandardError());
+        errorOutput = QString::fromLocal8Bit(proc.readAllRawStandardError());
         if (!proc.isRunning())
             break;
 
@@ -270,7 +270,7 @@ bool AndroidAvdManager::startAvdAsync(const QString &avdName) const
     avdProcess->setProcessChannelMode(QProcess::MergedChannels);
     QObject::connect(avdProcess, &QtcProcess::done, avdProcess, [avdProcess] {
         if (avdProcess->exitCode()) {
-            const QString errorOutput = QString::fromLatin1(avdProcess->readAllStandardOutput());
+            const QString errorOutput = QString::fromLatin1(avdProcess->readAllRawStandardOutput());
             QMetaObject::invokeMethod(Core::ICore::mainWindow(), [errorOutput] {
                 const QString title = Tr::tr("AVD Start Error");
                 QMessageBox::critical(Core::ICore::dialogParent(), title, errorOutput);

src/plugins/android/androidconfigurations.cpp

@@ -1489,7 +1489,7 @@ FilePath AndroidConfig::getJdkPath()
         findJdkPathProc.setCommand({"sh", args});
         findJdkPathProc.start();
         findJdkPathProc.waitForFinished();
-        QByteArray jdkPath = findJdkPathProc.readAllStandardOutput().trimmed();
+        QByteArray jdkPath = findJdkPathProc.readAllRawStandardOutput().trimmed();
 
         if (HostOsInfo::isMacHost()) {
             jdkHome = FilePath::fromUtf8(jdkPath);

src/plugins/android/androidsdkmanager.cpp

@@ -1012,7 +1012,7 @@ void AndroidSdkManagerPrivate::getPendingLicense(SdkCmdFutureInterface &fi)
     QTextCodec *codec = QTextCodec::codecForLocale();
     int inputCounter = 0, steps = -1;
     while (!licenseCommand.waitForFinished(200)) {
-        QString stdOut = codec->toUnicode(licenseCommand.readAllStandardOutput());
+        QString stdOut = codec->toUnicode(licenseCommand.readAllRawStandardOutput());
         bool assertionFound = false;
         if (!stdOut.isEmpty())
             assertionFound = onLicenseStdOut(stdOut, reviewingLicenses, result, fi);

src/plugins/android/androidsignaloperation.cpp

@@ -39,7 +39,7 @@ void AndroidSignalOperation::adbFindRunAsFinished()
     m_timeout->stop();
 
     handleCrashMessage();
-    const QString runAs = QString::fromLatin1(m_adbProcess->readAllStandardOutput());
+    const QString runAs = QString::fromLatin1(m_adbProcess->readAllRawStandardOutput());
     m_adbProcess.release()->deleteLater();
     if (runAs.isEmpty() || !m_errorMessage.isEmpty()) {
         m_errorMessage.prepend(QLatin1String("Cannot find User for process: ")
@@ -59,7 +59,7 @@ void AndroidSignalOperation::adbKillFinished()
     m_timeout->stop();
 
     if (!handleCrashMessage())
-        m_errorMessage = QString::fromLatin1(m_adbProcess->readAllStandardError());
+        m_errorMessage = QString::fromLatin1(m_adbProcess->readAllRawStandardError());
     m_adbProcess.release()->deleteLater();
     if (!m_errorMessage.isEmpty())
         m_errorMessage.prepend(QLatin1String("Cannot kill process: ") + QString::number(m_pid));

src/plugins/boot2qt/qdbdevicedebugsupport.cpp

@@ -36,10 +36,10 @@ public:
         connect(&m_launcher, &QtcProcess::done, this, &RunWorker::reportStopped);
 
         connect(&m_launcher, &QtcProcess::readyReadStandardOutput, this, [this] {
-                appendMessage(QString::fromUtf8(m_launcher.readAllStandardOutput()), StdOutFormat);
+                appendMessage(m_launcher.readAllStandardOutput(), StdOutFormat);
         });
         connect(&m_launcher, &QtcProcess::readyReadStandardError, this, [this] {
-                appendMessage(QString::fromUtf8(m_launcher.readAllStandardError()), StdErrFormat);
+                appendMessage(m_launcher.readAllStandardError(), StdErrFormat);
         });
 
         m_portsGatherer = new DebugServerPortsGatherer(runControl);

src/plugins/boot2qt/qdbmakedefaultappstep.cpp

@@ -50,7 +50,7 @@ private:
             process.setCommand(cmd);
             QtcProcess *proc = &process;
             connect(proc, &QtcProcess::readyReadStandardError, this, [this, proc] {
-                emit stdErrData(QString::fromUtf8(proc->readAllStandardError()));
+                emit stdErrData(proc->readAllStandardError());
             });
         };
         const auto doneHandler = [this](const QtcProcess &) {

src/plugins/boot2qt/qdbstopapplicationstep.cpp

@@ -42,7 +42,7 @@ Group QdbStopApplicationService::deployRecipe()
         process.setWorkingDirectory("/usr/bin");
         QtcProcess *proc = &process;
         connect(proc, &QtcProcess::readyReadStandardOutput, this, [this, proc] {
-            emit stdOutData(QString::fromUtf8(proc->readAllStandardOutput()));
+            emit stdOutData(proc->readAllStandardOutput());
         });
     };
     const auto doneHandler = [this](const QtcProcess &) {

src/plugins/clearcase/clearcasesync.cpp

@@ -38,7 +38,7 @@ static void runProcess(QFutureInterface<void> &future,
     int processed = 0;
     QString buffer;
     while (process.waitForReadyRead() && !future.isCanceled()) {
-        buffer += QString::fromLocal8Bit(process.readAllStandardOutput());
+        buffer += QString::fromLocal8Bit(process.readAllRawStandardOutput());
         while (const int index = buffer.indexOf('\n') != -1) {
             const QString line = buffer.left(index + 1);
             processLine(line, ++processed);

src/plugins/cmakeprojectmanager/cmakebuildsystem.cpp

@@ -927,7 +927,7 @@ void CMakeBuildSystem::runCTest()
         process.start();
         if (!process.waitForFinished() || process.result() != ProcessResult::FinishedWithSuccess)
             return;
-        futureInterface.reportResult(process.readAllStandardOutput());
+        futureInterface.reportResult(process.readAllRawStandardOutput());
     });
 
     Utils::onFinished(future, this, [this](const QFuture<QByteArray> &future) {
@@ -1409,10 +1409,10 @@ void CMakeBuildSystem::runGenerator(Utils::Id id)
     const auto proc = new QtcProcess(this);
     connect(proc, &QtcProcess::done, proc, &QtcProcess::deleteLater);
     connect(proc, &QtcProcess::readyReadStandardOutput, this, [proc] {
-        Core::MessageManager::writeFlashing(QString::fromLocal8Bit(proc->readAllStandardOutput()));
+        Core::MessageManager::writeFlashing(QString::fromLocal8Bit(proc->readAllRawStandardOutput()));
     });
     connect(proc, &QtcProcess::readyReadStandardError, this, [proc] {
-        Core::MessageManager::writeDisrupting(QString::fromLocal8Bit(proc->readAllStandardError()));
+        Core::MessageManager::writeDisrupting(QString::fromLocal8Bit(proc->readAllRawStandardError()));
     });
     proc->setWorkingDirectory(outDir);
     proc->setEnvironment(buildConfiguration()->environment());

src/plugins/coreplugin/externaltool.cpp

@@ -673,7 +673,7 @@ void ExternalToolRunner::readStandardOutput()
 {
     if (m_tool->outputHandling() == ExternalTool::Ignore)
         return;
-    const QByteArray data = m_process->readAllStandardOutput();
+    const QByteArray data = m_process->readAllRawStandardOutput();
     const QString output = m_outputCodec->toUnicode(data.constData(),
                                                     data.length(),
                                                     &m_outputCodecState);
@@ -687,7 +687,7 @@ void ExternalToolRunner::readStandardError()
 {
     if (m_tool->errorHandling() == ExternalTool::Ignore)
         return;
-    const QByteArray data = m_process->readAllStandardError();
+    const QByteArray data = m_process->readAllRawStandardError();
     const QString output = m_outputCodec->toUnicode(data.constData(),
                                                     data.length(),
                                                     &m_errorCodecState);

src/plugins/coreplugin/locator/executefilter.cpp

@@ -124,7 +124,7 @@ void ExecuteFilter::done()
 void ExecuteFilter::readStandardOutput()
 {
     QTC_ASSERT(m_process, return);
-    const QByteArray data = m_process->readAllStandardOutput();
+    const QByteArray data = m_process->readAllRawStandardOutput();
     MessageManager::writeSilently(
         QTextCodec::codecForLocale()->toUnicode(data.constData(), data.size(), &m_stdoutState));
 }
@@ -132,7 +132,7 @@ void ExecuteFilter::readStandardOutput()
 void ExecuteFilter::readStandardError()
 {
     QTC_ASSERT(m_process, return);
-    const QByteArray data = m_process->readAllStandardError();
+    const QByteArray data = m_process->readAllRawStandardError();
     MessageManager::writeSilently(
         QTextCodec::codecForLocale()->toUnicode(data.constData(), data.size(), &m_stderrState));
 }

src/plugins/coreplugin/locator/spotlightlocatorfilter.cpp

@@ -78,7 +78,7 @@ SpotlightIterator::SpotlightIterator(const QStringList &command)
     });
     QObject::connect(m_process.get(), &QtcProcess::readyReadStandardOutput,
                      m_process.get(), [this] {
-        QString output = QString::fromUtf8(m_process->readAllStandardOutput());
+        QString output = m_process->readAllStandardOutput();
         output.replace("\r\n", "\n");
         const QStringList items = output.split('\n');
         QMutexLocker lock(&m_mutex);

src/plugins/cppcheck/cppcheckrunner.cpp

@@ -20,7 +20,7 @@ CppcheckRunner::CppcheckRunner(CppcheckTool &tool) : m_tool(tool)
         getConf.setCommand({"getconf", {"ARG_MAX"}});
         getConf.start();
         getConf.waitForFinished(2000);
-        const QByteArray argMax = getConf.readAllStandardOutput().replace("\n", "");
+        const QByteArray argMax = getConf.readAllRawStandardOutput().replace("\n", "");
         m_maxArgumentsLength = std::max(argMax.toInt(), m_maxArgumentsLength);
     }
 

src/plugins/cppeditor/cppcodemodelsettings.cpp

@@ -375,7 +375,7 @@ static FilePath getClangHeadersPathFromClang(const FilePath &clangdFilePath)
     if (!clang.waitForFinished())
         return {};
     const FilePath resourceDir = FilePath::fromUserInput(QString::fromLocal8Bit(
-            clang.readAllStandardOutput().trimmed()));
+            clang.readAllRawStandardOutput().trimmed()));
     if (resourceDir.isEmpty() || !resourceDir.exists())
         return {};
     const FilePath includeDir = resourceDir.pathAppended("include");

src/plugins/cppeditor/cppmodelmanager.cpp

@@ -457,7 +457,7 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
             return;
         }
         if (isMsvc)
-            saveAndOpen(outFilePath, compiler->readAllStandardOutput(), inNextSplit);
+            saveAndOpen(outFilePath, compiler->readAllRawStandardOutput(), inNextSplit);
         else
             openEditor(outFilePath, inNextSplit, Core::Constants::K_DEFAULT_TEXT_EDITOR_ID);
     });

src/plugins/debugger/debuggerruncontrol.cpp

@@ -131,7 +131,7 @@ private:
             m_tempCoreFile.setFileName(m_tempCoreFilePath.path());
             m_tempCoreFile.open(QFile::WriteOnly);
             connect(&m_coreUnpackProcess, &QtcProcess::readyReadStandardOutput, this, [this] {
-                m_tempCoreFile.write(m_coreUnpackProcess.readAllStandardOutput());
+                m_tempCoreFile.write(m_coreUnpackProcess.readAllRawStandardOutput());
             });
             m_coreUnpackProcess.setCommand({"gzip", {"-c", "-d", m_coreFilePath.path()}});
             reportStarted();

src/plugins/debugger/debuggersourcepathmappingwidget.cpp

@@ -431,7 +431,7 @@ static QString findQtInstallPath(const FilePath &qmakePath)
         qWarning("%s: '%s' crashed.", Q_FUNC_INFO, qPrintable(qmakePath.toString()));
         return QString();
     }
-    const QByteArray ba = proc.readAllStandardOutput().trimmed();
+    const QByteArray ba = proc.readAllRawStandardOutput().trimmed();
     QDir dir(QString::fromLocal8Bit(ba));
     if (dir.exists() && dir.cdUp())
         return dir.absolutePath();

src/plugins/debugger/gdb/gdbengine.cpp

@@ -589,7 +589,7 @@ void GdbEngine::handleAsyncOutput(const QString &asyncClass, const GdbMi &result
 
 void GdbEngine::readGdbStandardError()
 {
-    QString err = QString::fromUtf8(m_gdbProc.readAllStandardError());
+    QString err = QString::fromUtf8(m_gdbProc.readAllRawStandardError());
     showMessage("UNEXPECTED GDB STDERR: " + err);
     if (err == "Undefined command: \"bb\".  Try \"help\".\n")
         return;
@@ -616,7 +616,7 @@ void GdbEngine::readGdbStandardOutput()
     int newstart = 0;
     int scan = m_inbuffer.size();
 
-    QByteArray out = m_gdbProc.readAllStandardOutput();
+    QByteArray out = m_gdbProc.readAllRawStandardOutput();
     m_inbuffer.append(out);
 
     // This can trigger when a dialog starts a nested event loop.

src/plugins/debugger/lldb/lldbengine.cpp

@@ -824,14 +824,14 @@ QString LldbEngine::errorMessage(QProcess::ProcessError error) const
 
 void LldbEngine::readLldbStandardError()
 {
-    QString err = QString::fromUtf8(m_lldbProc.readAllStandardError());
+    QString err = QString::fromUtf8(m_lldbProc.readAllRawStandardError());
     qDebug() << "\nLLDB STDERR UNEXPECTED: " << err;
     showMessage("Lldb stderr: " + err, LogError);
 }
 
 void LldbEngine::readLldbStandardOutput()
 {
-    QByteArray outba = m_lldbProc.readAllStandardOutput();
+    QByteArray outba = m_lldbProc.readAllRawStandardOutput();
     outba.replace("\r\n", "\n");
     QString out = QString::fromUtf8(outba);
     showMessage(out, LogOutput);

src/plugins/debugger/pdb/pdbengine.cpp

@@ -413,7 +413,7 @@ void PdbEngine::handlePdbDone()
 
 void PdbEngine::readPdbStandardError()
 {
-    QString err = QString::fromUtf8(m_proc.readAllStandardError());
+    QString err = QString::fromUtf8(m_proc.readAllRawStandardError());
     //qWarning() << "Unexpected pdb stderr:" << err;
     showMessage("Unexpected pdb stderr: " + err);
     //handleOutput(err);
@@ -421,8 +421,7 @@ void PdbEngine::readPdbStandardError()
 
 void PdbEngine::readPdbStandardOutput()
 {
-    QString out = QString::fromUtf8(m_proc.readAllStandardOutput());
+    handleOutput(m_proc.readAllStandardOutput());
-    handleOutput(out);
 }
 
 void PdbEngine::handleOutput(const QString &data)

src/plugins/debugger/qml/qmlengine.cpp

@@ -251,11 +251,11 @@ QmlEngine::QmlEngine()
 
     connect(&d->process, &QtcProcess::readyReadStandardOutput, this, [this] {
         // FIXME: Redirect to RunControl
-        showMessage(QString::fromUtf8(d->process.readAllStandardOutput()), AppOutput);
+        showMessage(d->process.readAllStandardOutput(), AppOutput);
     });
     connect(&d->process, &QtcProcess::readyReadStandardError, this, [this] {
         // FIXME: Redirect to RunControl
-        showMessage(QString::fromUtf8(d->process.readAllStandardError()), AppOutput);
+        showMessage(d->process.readAllStandardError(), AppOutput);
     });
 
     connect(&d->process, &QtcProcess::done, this, &QmlEngine::disconnected);

src/plugins/docker/dockerdevice.cpp

@@ -236,7 +236,7 @@ DockerProcessImpl::DockerProcessImpl(IDevice::ConstPtr device, DockerDevicePriva
 
     connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
         if (!m_hasReceivedFirstOutput) {
-            QByteArray output = m_process.readAllStandardOutput();
+            QByteArray output = m_process.readAllRawStandardOutput();
             qsizetype idx = output.indexOf('\n');
             QByteArray firstLine = output.left(idx);
             QByteArray rest = output.mid(idx + 1);
@@ -256,11 +256,11 @@ DockerProcessImpl::DockerProcessImpl(IDevice::ConstPtr device, DockerDevicePriva
                 return;
             }
         }
-        emit readyRead(m_process.readAllStandardOutput(), {});
+        emit readyRead(m_process.readAllRawStandardOutput(), {});
     });
 
     connect(&m_process, &QtcProcess::readyReadStandardError, this, [this] {
-        emit readyRead({}, m_process.readAllStandardError());
+        emit readyRead({}, m_process.readAllRawStandardError());
     });
 
     connect(&m_process, &QtcProcess::done, this, [this] {
@@ -1005,7 +1005,7 @@ public:
         m_process->setCommand(cmd);
 
         connect(m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
-            const QString out = QString::fromUtf8(m_process->readAllStandardOutput().trimmed());
+            const QString out = m_process->readAllStandardOutput().trimmed();
             m_log->append(out);
             for (const QString &line : out.split('\n')) {
                 const QStringList parts = line.trimmed().split('\t');

src/plugins/git/gerrit/gerritmodel.cpp

@@ -260,12 +260,12 @@ QueryContext::QueryContext(const QString &query,
         m_arguments = server.curlArguments() << url;
     }
     connect(&m_process, &QtcProcess::readyReadStandardError, this, [this] {
-        const QString text = QString::fromLocal8Bit(m_process.readAllStandardError());
+        const QString text = QString::fromLocal8Bit(m_process.readAllRawStandardError());
         VcsOutputWindow::appendError(text);
         m_error.append(text);
     });
     connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
-        m_output.append(m_process.readAllStandardOutput());
+        m_output.append(m_process.readAllRawStandardOutput());
     });
     connect(&m_process, &QtcProcess::done, this, &QueryContext::processDone);
     m_process.setEnvironment(Git::Internal::GitClient::instance()->processEnvironment());

src/plugins/git/gerrit/gerritplugin.cpp

@@ -95,10 +95,10 @@ FetchContext::FetchContext(const QSharedPointer<GerritChange> &change,
     m_process.setUseCtrlCStub(true);
     connect(&m_process, &QtcProcess::done, this, &FetchContext::processDone);
     connect(&m_process, &QtcProcess::readyReadStandardError, this, [this] {
-        VcsBase::VcsOutputWindow::append(QString::fromLocal8Bit(m_process.readAllStandardError()));
+        VcsBase::VcsOutputWindow::append(QString::fromLocal8Bit(m_process.readAllRawStandardError()));
     });
     connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
-        VcsBase::VcsOutputWindow::append(QString::fromLocal8Bit(m_process.readAllStandardOutput()));
+        VcsBase::VcsOutputWindow::append(QString::fromLocal8Bit(m_process.readAllRawStandardOutput()));
     });
     m_process.setWorkingDirectory(repository);
     m_process.setEnvironment(GitClient::instance()->processEnvironment());

src/plugins/git/mergetool.cpp

@@ -169,7 +169,7 @@ void MergeTool::prompt(const QString &title, const QString &question)
 
 void MergeTool::readData()
 {
-    QString newData = QString::fromLocal8Bit(m_process.readAllStandardOutput());
+    QString newData = QString::fromLocal8Bit(m_process.readAllRawStandardOutput());
     newData.remove('\r');
     VcsOutputWindow::append(newData);
     QString data = m_unfinishedLine + newData;

src/plugins/gitlab/queryrunner.cpp

@@ -111,7 +111,7 @@ QueryRunner::QueryRunner(const Query &query, const Id &id, QObject *parent)
             }
             VcsBase::VcsOutputWindow::appendError(m_process.exitMessage());
         } else {
-            emit resultRetrieved(m_process.readAllStandardOutput());
+            emit resultRetrieved(m_process.readAllRawStandardOutput());
         }
         emit finished();
     });

src/plugins/languageclient/languageclientinterface.cpp

@@ -152,7 +152,7 @@ void StdIOClientInterface::readError()
 {
     QTC_ASSERT(m_process, return);
 
-    const QByteArray stdErr = m_process->readAllStandardError();
+    const QByteArray stdErr = m_process->readAllRawStandardError();
     m_logFile.write(stdErr);
 
     qCDebug(LOGLSPCLIENTV) << "StdIOClient std err:\n";
@@ -162,7 +162,7 @@ void StdIOClientInterface::readError()
 void StdIOClientInterface::readOutput()
 {
     QTC_ASSERT(m_process, return);
-    const QByteArray &out = m_process->readAllStandardOutput();
+    const QByteArray &out = m_process->readAllRawStandardOutput();
     qCDebug(LOGLSPCLIENTV) << "StdIOClient std out:\n";
     qCDebug(LOGLSPCLIENTV).noquote() << out;
     parseData(out);

src/plugins/mesonprojectmanager/mesonprocess.cpp

@@ -51,8 +51,8 @@ void MesonProcess::handleProcessDone()
         ProjectExplorer::TaskHub::addTask(ProjectExplorer::BuildSystemTask{
                 ProjectExplorer::Task::TaskType::Error, m_process->exitMessage()});
     }
-    m_stdo = m_process->readAllStandardOutput();
+    m_stdo = m_process->readAllRawStandardOutput();
-    m_stderr = m_process->readAllStandardError();
+    m_stderr = m_process->readAllRawStandardError();
     const QString elapsedTime = formatElapsedTime(m_elapsed.elapsed());
     MessageManager::writeSilently(elapsedTime);
     emit finished(m_process->exitCode(), m_process->exitStatus());
@@ -105,14 +105,14 @@ bool MesonProcess::sanityCheck(const Command &command) const
 
 void MesonProcess::processStandardOutput()
 {
-    const auto data = m_process->readAllStandardOutput();
+    const auto data = m_process->readAllRawStandardOutput();
     MessageManager::writeSilently(QString::fromLocal8Bit(data));
     emit readyReadStandardOutput(data);
 }
 
 void MesonProcess::processStandardError()
 {
-    MessageManager::writeSilently(QString::fromLocal8Bit(m_process->readAllStandardError()));
+    MessageManager::writeSilently(QString::fromLocal8Bit(m_process->readAllRawStandardError()));
 }
 
 } // namespace Internal

src/plugins/mesonprojectmanager/mesonwrapper.h

@@ -42,7 +42,7 @@ inline bool run_meson(const Command &command, QIODevice *output = nullptr)
     if (!process.waitForFinished())
         return false;
     if (output) {
-        output->write(process.readAllStandardOutput());
+        output->write(process.readAllRawStandardOutput());
     }
     return process.exitCode() == 0;
 }

src/plugins/nim/project/nimblebuildsystem.cpp

@@ -22,7 +22,7 @@ const char C_NIMBLEPROJECT_TASKS[] = "Nim.NimbleProject.Tasks";
 
 static QList<QByteArray> linesFromProcessOutput(QtcProcess *process)
 {
-    QList<QByteArray> lines = process->readAllStandardOutput().split('\n');
+    QList<QByteArray> lines = process->readAllRawStandardOutput().split('\n');
     lines = Utils::transform(lines, [](const QByteArray &line){ return line.trimmed(); });
     Utils::erase(lines, [](const QByteArray &line) { return line.isEmpty(); });
     return lines;

src/plugins/nim/project/nimtoolchain.cpp

@@ -100,7 +100,7 @@ bool NimToolChain::parseVersion(const FilePath &path, std::tuple<int, int, int>
     process.start();
     if (!process.waitForFinished())
         return false;
-    const QString version = QString::fromUtf8(process.readAllStandardOutput()).section('\n', 0, 0);
+    const QString version = process.readAllStandardOutput().section('\n', 0, 0);
     if (version.isEmpty())
         return false;
     const QRegularExpression regex("(\\d+)\\.(\\d+)\\.(\\d+)");

src/plugins/nim/suggest/server.cpp

@@ -60,12 +60,12 @@ QString NimSuggestServer::projectFilePath() const
 void NimSuggestServer::onStandardOutputAvailable()
 {
     if (!m_portAvailable) {
-        const QString output = QString::fromUtf8(m_process.readAllStandardOutput());
+        const QString output = m_process.readAllStandardOutput();
         m_port = static_cast<uint16_t>(output.toUInt());
         m_portAvailable = true;
         emit started();
     } else {
-        qDebug() << m_process.readAllStandardOutput();
+        qDebug() << m_process.readAllRawStandardOutput();
     }
 }
 

src/plugins/perfprofiler/perfconfigwidget.cpp

@@ -161,7 +161,7 @@ void PerfConfigWidget::handleProcessDone()
         return;
     }
     const QList<QByteArray> lines =
-            m_process->readAllStandardOutput().append(m_process->readAllStandardError())
+            m_process->readAllRawStandardOutput().append(m_process->readAllRawStandardError())
             .split('\n');
     auto model = eventsView->model();
     const int previousRows = model->rowCount();

src/plugins/perfprofiler/perfprofilerruncontrol.cpp

@@ -194,11 +194,11 @@ void PerfProfilerRunner::start()
         // That's the local case.
         QtcProcess *recorder = prw->recorder();
         connect(recorder, &QtcProcess::readyReadStandardError, this, [this, recorder] {
-            appendMessage(QString::fromLocal8Bit(recorder->readAllStandardError()),
+            appendMessage(QString::fromLocal8Bit(recorder->readAllRawStandardError()),
                           Utils::StdErrFormat);
         });
         connect(recorder, &QtcProcess::readyReadStandardOutput, this, [this, reader, recorder] {
-            if (!reader->feedParser(recorder->readAllStandardOutput()))
+            if (!reader->feedParser(recorder->readAllRawStandardOutput()))
                 reportFailure(Tr::tr("Failed to transfer Perf data to perfparser."));
         });
     }

src/plugins/perfprofiler/perftracepointdialog.cpp

@@ -116,11 +116,11 @@ void PerfTracePointDialog::handleProcessDone()
     } else if ((m_process->exitStatus() == QProcess::CrashExit) || (m_process->exitCode() != 0)) {
         message = Tr::tr("Failed to create trace points.");
     } else {
-        message = Tr::tr("Created trace points for: %1").arg(QString::fromUtf8(
+        message = Tr::tr("Created trace points for: %1").arg(
-            m_process->readAllStandardOutput().trimmed().replace('\n', ", ")));
+            m_process->readAllStandardOutput().trimmed().replace('\n', ", "));
     }
     m_label->setText(message);
-    m_textEdit->setHtml(QString::fromUtf8(m_process->readAllStandardError()));
+    m_textEdit->setHtml(m_process->readAllStandardError());
     m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     m_buttonBox->button(QDialogButtonBox::Cancel)->setEnabled(false);
 }

src/plugins/projectexplorer/abstractprocessstep.cpp

@@ -223,11 +223,11 @@ void AbstractProcessStep::setupProcess(QtcProcess *process)
         process->setLowPriority();
 
     connect(process, &QtcProcess::readyReadStandardOutput, this, [this, process] {
-        emit addOutput(d->stdoutStream->toUnicode(process->readAllStandardOutput()),
+        emit addOutput(d->stdoutStream->toUnicode(process->readAllRawStandardOutput()),
                        OutputFormat::Stdout, DontAppendNewline);
     });
     connect(process, &QtcProcess::readyReadStandardError, this, [this, process] {
-        emit addOutput(d->stderrStream->toUnicode(process->readAllStandardError()),
+        emit addOutput(d->stderrStream->toUnicode(process->readAllRawStandardError()),
                        OutputFormat::Stderr, DontAppendNewline);
     });
     connect(process, &QtcProcess::started, this, [this] {

src/plugins/projectexplorer/devicesupport/deviceusedportsgatherer.cpp

@@ -87,7 +87,7 @@ void DeviceUsedPortsGatherer::setupUsedPorts()
 {
     d->usedPorts.clear();
     const QList<Port> usedPorts = d->portsGatheringMethod.parsePorts(
-                                  d->process->readAllStandardOutput());
+                                  d->process->readAllRawStandardOutput());
     for (const Port port : usedPorts) {
         if (d->device->freePorts().contains(port))
             d->usedPorts << port;
@@ -107,7 +107,7 @@ void DeviceUsedPortsGatherer::handleProcessDone()
         setupUsedPorts();
     } else {
         QString errMsg = d->process->errorString();
-        const QByteArray stdErr = d->process->readAllStandardError();
+        const QByteArray stdErr = d->process->readAllRawStandardError();
         if (!stdErr.isEmpty()) {
             errMsg += QLatin1Char('\n');
             errMsg += tr("Remote error output was: %1").arg(QString::fromUtf8(stdErr));

src/plugins/projectexplorer/runcontrol.cpp

@@ -1360,7 +1360,7 @@ void SimpleTargetRunnerPrivate::handleDone()
 
 void SimpleTargetRunnerPrivate::handleStandardOutput()
 {
-    const QByteArray data = m_process.readAllStandardOutput();
+    const QByteArray data = m_process.readAllRawStandardOutput();
     const QString msg = m_outputCodec->toUnicode(
                 data.constData(), data.length(), &m_outputCodecState);
     q->appendMessageChunk(msg, StdOutFormat);
@@ -1368,7 +1368,7 @@ void SimpleTargetRunnerPrivate::handleStandardOutput()
 
 void SimpleTargetRunnerPrivate::handleStandardError()
 {
-    const QByteArray data = m_process.readAllStandardError();
+    const QByteArray data = m_process.readAllRawStandardError();
     const QString msg = m_outputCodec->toUnicode(
                 data.constData(), data.length(), &m_errorCodecState);
     q->appendMessageChunk(msg, StdErrFormat);

src/plugins/python/pipsupport.cpp

@@ -88,14 +88,14 @@ void PipInstallTask::handleDone()
 
 void PipInstallTask::handleOutput()
 {
-    const QString &stdOut = QString::fromLocal8Bit(m_process.readAllStandardOutput().trimmed());
+    const QString &stdOut = QString::fromLocal8Bit(m_process.readAllRawStandardOutput().trimmed());
     if (!stdOut.isEmpty())
         Core::MessageManager::writeSilently(stdOut);
 }
 
 void PipInstallTask::handleError()
 {
-    const QString &stdErr = QString::fromLocal8Bit(m_process.readAllStandardError().trimmed());
+    const QString &stdErr = QString::fromLocal8Bit(m_process.readAllRawStandardError().trimmed());
     if (!stdErr.isEmpty())
         Core::MessageManager::writeSilently(stdErr);
 }

src/plugins/python/pysideuicextracompiler.cpp

@@ -41,7 +41,7 @@ FileNameToContentsHash PySideUicExtraCompiler::handleProcessFinished(QtcProcess
         return result;
     // As far as I can discover in the UIC sources, it writes out local 8-bit encoding. The
     // conversion below is to normalize both the encoding, and the line terminators.
-    result[targetList.first()] = QString::fromLocal8Bit(process->readAllStandardOutput()).toUtf8();
+    result[targetList.first()] = QString::fromLocal8Bit(process->readAllRawStandardOutput()).toUtf8();
     return result;
 }
 

src/plugins/qbsprojectmanager/qbsprofilemanager.cpp

@@ -232,9 +232,9 @@ QString QbsProfileManager::runQbsConfig(QbsConfigOp op, const QString &key, cons
     } else if (qbsConfig.exitCode() != 0) {
         Core::MessageManager::writeFlashing(
             Tr::tr("Failed to run qbs config: %1")
-                .arg(QString::fromLocal8Bit(qbsConfig.readAllStandardError())));
+                .arg(QString::fromLocal8Bit(qbsConfig.readAllRawStandardError())));
     }
-    return QString::fromLocal8Bit(qbsConfig.readAllStandardOutput()).trimmed();
+    return QString::fromLocal8Bit(qbsConfig.readAllRawStandardOutput()).trimmed();
 }
 
 QVariant fromJSLiteral(const QString &str)

src/plugins/qbsprojectmanager/qbssession.cpp

@@ -156,10 +156,10 @@ void QbsSession::initialize()
     d->qbsProcess->setProcessMode(ProcessMode::Writer);
     d->qbsProcess->setEnvironment(env);
     connect(d->qbsProcess, &QtcProcess::readyReadStandardOutput, this, [this] {
-        d->packetReader->handleData(d->qbsProcess->readAllStandardOutput());
+        d->packetReader->handleData(d->qbsProcess->readAllRawStandardOutput());
     });
     connect(d->qbsProcess, &QtcProcess::readyReadStandardError, this, [this] {
-        qCDebug(qbsPmLog) << "[qbs stderr]: " << d->qbsProcess->readAllStandardError();
+        qCDebug(qbsPmLog) << "[qbs stderr]: " << d->qbsProcess->readAllRawStandardError();
     });
     connect(d->qbsProcess, &QtcProcess::done, this, [this] {
         if (d->qbsProcess->result() == ProcessResult::StartFailed) {

src/plugins/qbsprojectmanager/qbssettings.cpp

@@ -37,7 +37,7 @@ static QString getQbsVersion(const FilePath &qbsExe)
     qbsProc.start();
     if (!qbsProc.waitForFinished(5000) || qbsProc.exitCode() != 0)
         return {};
-    return QString::fromLocal8Bit(qbsProc.readAllStandardOutput()).trimmed();
+    return QString::fromLocal8Bit(qbsProc.readAllRawStandardOutput()).trimmed();
 }
 
 static bool operator==(const QbsSettingsData &s1, const QbsSettingsData &s2)

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -1588,10 +1588,10 @@ void QmakeBuildSystem::runGenerator(Utils::Id id)
     const auto proc = new QtcProcess(this);
     connect(proc, &QtcProcess::done, proc, &QtcProcess::deleteLater);
     connect(proc, &QtcProcess::readyReadStandardOutput, this, [proc] {
-        Core::MessageManager::writeFlashing(QString::fromLocal8Bit(proc->readAllStandardOutput()));
+        Core::MessageManager::writeFlashing(QString::fromLocal8Bit(proc->readAllRawStandardOutput()));
     });
     connect(proc, &QtcProcess::readyReadStandardError, this, [proc] {
-        Core::MessageManager::writeDisrupting(QString::fromLocal8Bit(proc->readAllStandardError()));
+        Core::MessageManager::writeDisrupting(QString::fromLocal8Bit(proc->readAllRawStandardError()));
     });
     proc->setWorkingDirectory(outDir);
     proc->setEnvironment(buildConfiguration()->environment());

src/plugins/qmldesigner/designercore/instances/nodeinstanceview.cpp

@@ -2073,7 +2073,7 @@ void NodeInstanceView::handleQsbProcessExit(Utils::QtcProcess *qsbProcess, const
     --m_remainingQsbTargets;
 
     const QString errStr = qsbProcess->errorString();
-    const QByteArray stdErrStr = qsbProcess->readAllStandardError();
+    const QByteArray stdErrStr = qsbProcess->readAllRawStandardError();
 
     if (!errStr.isEmpty() || !stdErrStr.isEmpty()) {
         Core::MessageManager::writeSilently(QCoreApplication::translate(

src/plugins/qnx/qnxdevice.cpp

@@ -110,7 +110,7 @@ void QnxDevice::updateVersionNumber() const
     versionNumberProcess.setCommand({filePath("uname"), {"-r"}});
     versionNumberProcess.runBlocking(EventLoopMode::On);
 
-    QByteArray output = versionNumberProcess.readAllStandardOutput();
+    QByteArray output = versionNumberProcess.readAllRawStandardOutput();
     QString versionMessage = QString::fromLatin1(output);
     const QRegularExpression versionNumberRegExp("(\\d+)\\.(\\d+)\\.(\\d+)");
     const QRegularExpressionMatch match = versionNumberRegExp.match(versionMessage);

src/plugins/qnx/slog2inforunner.cpp

@@ -60,10 +60,10 @@ void Slog2InfoRunner::start()
     const auto logStartHandler = [this](QtcProcess &process) {
         process.setCommand({device()->filePath("slog2info"), {"-w"}});
         connect(&process, &QtcProcess::readyReadStandardOutput, this, [&] {
-            processLogInput(QString::fromLatin1(process.readAllStandardOutput()));
+            processLogInput(QString::fromLatin1(process.readAllRawStandardOutput()));
         });
         connect(&process, &QtcProcess::readyReadStandardError, this, [&] {
-            appendMessage(QString::fromLatin1(process.readAllStandardError()), StdErrFormat);
+            appendMessage(QString::fromLatin1(process.readAllRawStandardError()), StdErrFormat);
         });
     };
     const auto logErrorHandler = [this](const QtcProcess &process) {

src/plugins/qtsupport/baseqtversion.cpp

@@ -1696,7 +1696,7 @@ static QByteArray runQmakeQuery(const FilePath &binary, const Environment &env,
         return {};
     }
 
-    const QByteArray out = process.readAllStandardOutput();
+    const QByteArray out = process.readAllRawStandardOutput();
     if (out.isEmpty()) {
         *error = Tr::tr("\"%1\" produced no output: %2.")
                 .arg(binary.displayName(), process.cleanedStdErr());

src/plugins/qtsupport/qtversionmanager.cpp

@@ -375,7 +375,7 @@ static QList<QByteArray> runQtChooser(const QString &qtchooser, const QStringLis
     p.start();
     p.waitForFinished();
     const bool success = p.exitCode() == 0;
-    return success ? p.readAllStandardOutput().split('\n') : QList<QByteArray>();
+    return success ? p.readAllRawStandardOutput().split('\n') : QList<QByteArray>();
 }
 
 // Asks qtchooser for the qmake path of a given version

src/plugins/qtsupport/uicgenerator.cpp

@@ -59,7 +59,7 @@ FileNameToContentsHash UicGenerator::handleProcessFinished(Utils::QtcProcess *pr
         return result;
     // As far as I can discover in the UIC sources, it writes out local 8-bit encoding. The
     // conversion below is to normalize both the encoding, and the line terminators.
-    QByteArray content = QString::fromLocal8Bit(process->readAllStandardOutput()).toUtf8();
+    QByteArray content = QString::fromLocal8Bit(process->readAllRawStandardOutput()).toUtf8();
     content.prepend("#pragma once\n");
     result[targetList.first()] = content;
     return result;

src/plugins/remotelinux/customcommanddeploystep.cpp

@@ -56,10 +56,10 @@ Group CustomCommandDeployService::deployRecipe()
                                  {"-c", m_commandLine}});
         QtcProcess *proc = &process;
         connect(proc, &QtcProcess::readyReadStandardOutput, this, [this, proc] {
-            emit stdOutData(QString::fromUtf8(proc->readAllStandardOutput()));
+            emit stdOutData(proc->readAllStandardOutput());
         });
         connect(proc, &QtcProcess::readyReadStandardError, this, [this, proc] {
-            emit stdErrData(QString::fromUtf8(proc->readAllStandardError()));
+            emit stdErrData(proc->readAllStandardError());
         });
     };
     const auto doneHandler = [this](const QtcProcess &) {

src/plugins/remotelinux/genericdirectuploadservice.cpp

@@ -132,7 +132,7 @@ QDateTime GenericDirectUploadServicePrivate::timestampFromStat(const DeployableF
                                .arg(file.remoteFilePath(), error));
         return {};
     }
-    const QByteArray output = statProc->readAllStandardOutput().trimmed();
+    const QByteArray output = statProc->readAllRawStandardOutput().trimmed();
     const QString warningString(Tr::tr("Unexpected stat output for remote file \"%1\": %2")
                                 .arg(file.remoteFilePath()).arg(QString::fromUtf8(output)));
     if (!output.startsWith(file.remoteFilePath().toUtf8())) {

src/plugins/remotelinux/linuxdevice.cpp

@@ -164,7 +164,7 @@ void SshSharedConnection::connectToHost()
     m_timer.setSingleShot(true);
     connect(&m_timer, &QTimer::timeout, this, &SshSharedConnection::autoDestructRequested);
     connect(m_masterProcess.get(), &QtcProcess::readyReadStandardOutput, this, [this] {
-        const QByteArray reply = m_masterProcess->readAllStandardOutput();
+        const QByteArray reply = m_masterProcess->readAllRawStandardOutput();
         if (reply == "\n")
             emitConnected();
         // TODO: otherwise emitError and finish master process?
@@ -719,14 +719,14 @@ void SshProcessInterfacePrivate::handleReadyReadStandardOutput()
 {
     // By default emits signal. LinuxProcessImpl does custom parsing for processId
     // and emits delayed start() - only when terminal is off.
-    q->handleReadyReadStandardOutput(m_process.readAllStandardOutput());
+    q->handleReadyReadStandardOutput(m_process.readAllRawStandardOutput());
 }
 
 void SshProcessInterfacePrivate::handleReadyReadStandardError()
 {
     // By default emits signal. LinuxProcessImpl buffers the error channel until
     // it emits delayed start() - only when terminal is off.
-    q->handleReadyReadStandardError(m_process.readAllStandardError());
+    q->handleReadyReadStandardError(m_process.readAllRawStandardError());
 }
 
 void SshProcessInterfacePrivate::clearForStart()
@@ -1175,7 +1175,7 @@ protected:
                                                 : m_setup.m_files.first().direction();
         SshParameters::setupSshEnvironment(&m_process);
         connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
-            emit progress(QString::fromLocal8Bit(m_process.readAllStandardOutput()));
+            emit progress(QString::fromLocal8Bit(m_process.readAllRawStandardOutput()));
         });
         connect(&m_process, &QtcProcess::done, this, &SshTransferInterface::doneImpl);
     }
@@ -1190,7 +1190,7 @@ protected:
             resultData.m_errorString = Tr::tr("\"%1\" crashed.")
                     .arg(FileTransfer::transferMethodName(m_setup.m_method));
         } else if (resultData.m_exitCode != 0) {
-            resultData.m_errorString = QString::fromLocal8Bit(m_process.readAllStandardError());
+            resultData.m_errorString = QString::fromLocal8Bit(m_process.readAllRawStandardError());
         } else {
             return false;
         }

src/plugins/remotelinux/remotelinuxsignaloperation.cpp

@@ -89,7 +89,7 @@ void RemoteLinuxSignalOperation::runnerDone()
     } else if (m_process->exitCode() != 0) {
         m_errorMessage = Tr::tr("Exit code is %1. stderr:").arg(m_process->exitCode())
                 + QLatin1Char(' ')
-                + QString::fromLatin1(m_process->readAllStandardError());
+                + QString::fromLatin1(m_process->readAllRawStandardError());
     }
     m_process.release()->deleteLater();
     emit finished(m_errorMessage);

src/plugins/remotelinux/rsyncdeploystep.cpp

@@ -70,7 +70,7 @@ TaskItem RsyncDeployService::mkdirTask()
         process.setCommand({deviceConfiguration()->filePath("mkdir"),
                             QStringList("-p") + remoteDirs});
         connect(&process, &QtcProcess::readyReadStandardError, this, [this, proc = &process] {
-            emit stdErrData(QString::fromLocal8Bit(proc->readAllStandardError()));
+            emit stdErrData(QString::fromLocal8Bit(proc->readAllRawStandardError()));
         });
     };
     const auto errorHandler = [this](const QtcProcess &process) {

src/plugins/remotelinux/sshkeycreationdialog.cpp

@@ -118,7 +118,7 @@ void SshKeyCreationDialog::generateKeys()
     if (!keygen.waitForFinished())
         errorMsg = keygen.errorString();
     else if (keygen.exitCode() != 0)
-        errorMsg = QString::fromLocal8Bit(keygen.readAllStandardError());
+        errorMsg = QString::fromLocal8Bit(keygen.readAllRawStandardError());
     if (!errorMsg.isEmpty()) {
         showError(Tr::tr("The ssh-keygen tool at \"%1\" failed: %2")
                   .arg(SshSettings::keygenFilePath().toUserOutput(), errorMsg));

src/plugins/remotelinux/tarpackagedeploystep.cpp

@@ -80,10 +80,10 @@ TaskItem TarPackageDeployService::installTask()
         process.setCommand({deviceConfiguration()->filePath("/bin/sh"), {"-c", cmdLine}});
         QtcProcess *proc = &process;
         connect(proc, &QtcProcess::readyReadStandardOutput, this, [this, proc] {
-            emit stdOutData(QString::fromUtf8(proc->readAllStandardOutput()));
+            emit stdOutData(proc->readAllStandardOutput());
         });
         connect(proc, &QtcProcess::readyReadStandardError, this, [this, proc] {
-            emit stdErrData(QString::fromUtf8(proc->readAllStandardError()));
+            emit stdErrData(proc->readAllStandardError());
         });
         emit progressMessage(Tr::tr("Installing package to device..."));
     };

src/plugins/squish/squishtools.cpp

@@ -802,7 +802,7 @@ void SquishTools::onRecorderFinished()
 void SquishTools::onServerOutput()
 {
     // output used for getting the port information of the current squishserver
-    const QByteArray output = m_serverProcess.readAllStandardOutput();
+    const QByteArray output = m_serverProcess.readAllRawStandardOutput();
     const QList<QByteArray> lines = output.split('\n');
     for (const QByteArray &line : lines) {
         const QByteArray trimmed = line.trimmed();
@@ -830,7 +830,7 @@ void SquishTools::onServerOutput()
 void SquishTools::onServerErrorOutput()
 {
     // output that must be send to the Runner/Server Log
-    const QByteArray output = m_serverProcess.readAllStandardError();
+    const QByteArray output = m_serverProcess.readAllRawStandardError();
     const QList<QByteArray> lines = output.split('\n');
     for (const QByteArray &line : lines) {
         const QByteArray trimmed = line.trimmed();
@@ -922,7 +922,7 @@ void SquishTools::onRunnerOutput()
 void SquishTools::onRunnerErrorOutput()
 {
     // output that must be send to the Runner/Server Log
-    const QByteArray output = m_runnerProcess.readAllStandardError();
+    const QByteArray output = m_runnerProcess.readAllRawStandardError();
     const QList<QByteArray> lines = output.split('\n');
     for (const QByteArray &line : lines) {
         const QByteArray trimmed = line.trimmed();

src/plugins/texteditor/formattexteditor.cpp

@@ -103,14 +103,13 @@ static FormatTask format(FormatTask task)
                     .arg(executable, task.filePath.displayName());
             return task;
         }
-        const QByteArray errorText = process.readAllStandardError();
+        const QString errorText = process.readAllStandardError();
         if (!errorText.isEmpty()) {
-            task.error = QString::fromLatin1("%1: %2").arg(executable,
+            task.error = QString::fromLatin1("%1: %2").arg(executable, errorText);
-                                                           QString::fromUtf8(errorText));
             return task;
         }
 
-        task.formattedData = QString::fromUtf8(process.readAllStandardOutput());
+        task.formattedData = process.readAllStandardOutput();
 
         if (task.command.pipeAddsNewline() && task.formattedData.endsWith('\n')) {
             task.formattedData.chop(1);

src/plugins/valgrind/memchecktool.cpp

@@ -136,7 +136,7 @@ public:
                 reportFailure();
                 return;
             }
-            const QByteArrayList data = m_process->readAllStandardOutput().split(' ');
+            const QByteArrayList data = m_process->readAllRawStandardOutput().split(' ');
             if (data.size() != 3) {
                 reportFailure();
                 return;

src/plugins/valgrind/valgrindrunner.cpp

@@ -34,12 +34,10 @@ public:
             emit q->finished();
         });
         connect(&m_process, &QtcProcess::readyReadStandardOutput, this, [this] {
-            emit q->appendMessage(QString::fromUtf8(m_process.readAllStandardOutput()),
+            emit q->appendMessage(m_process.readAllStandardOutput(), StdOutFormat);
-                                  StdOutFormat);
         });
         connect(&m_process, &QtcProcess::readyReadStandardError, this, [this] {
-            emit q->appendMessage(QString::fromUtf8(m_process.readAllStandardError()),
+            emit q->appendMessage(m_process.readAllStandardError(), StdErrFormat);
-                                  StdErrFormat);
         });
 
         connect(&m_xmlServer, &QTcpServer::newConnection, this, &Private::xmlSocketConnected);

src/plugins/webassembly/webassemblyrunconfigurationaspects.cpp

@@ -54,7 +54,7 @@ static WebBrowserEntries emrunBrowsers(ProjectExplorer::Target *target)
         browserLister.start();
 
         if (browserLister.waitForFinished())
-            result.append(parseEmrunOutput(browserLister.readAllStandardOutput()));
+            result.append(parseEmrunOutput(browserLister.readAllRawStandardOutput()));
     }
     return result;
 }

tests/auto/utils/commandline/tst_commandline.cpp

@@ -33,7 +33,7 @@ private:
         p.setCommand(cmd);
         p.setEnvironment(testEnv);
         p.runBlocking();
-        return QString::fromUtf8(p.readAllStandardOutput());
+        return QString::fromUtf8(p.readAllRawStandardOutput());
     }
 
 private slots:

tests/auto/utils/qtcprocess/tst_qtcprocess.cpp

@@ -234,13 +234,13 @@ void tst_QtcProcess::multiRead()
     process.writeRaw("echo hi\n");
 
     QVERIFY(process.waitForReadyRead(1000));
-    buffer = process.readAllStandardOutput();
+    buffer = process.readAllRawStandardOutput();
     QCOMPARE(buffer, QByteArray("hi\n"));
 
     process.writeRaw("echo you\n");
 
     QVERIFY(process.waitForReadyRead(1000));
-    buffer = process.readAllStandardOutput();
+    buffer = process.readAllRawStandardOutput();
     QCOMPARE(buffer, QByteArray("you\n"));
 }
 
@@ -1164,8 +1164,8 @@ void tst_QtcProcess::channelForwarding()
     process.start();
     QVERIFY(process.waitForFinished());
 
-    const QByteArray output = process.readAllStandardOutput();
+    const QByteArray output = process.readAllRawStandardOutput();
-    const QByteArray error = process.readAllStandardError();
+    const QByteArray error = process.readAllRawStandardError();
 
     QCOMPARE(output.contains(QByteArray(s_outputData)), outputForwarded);
     QCOMPARE(error.contains(QByteArray(s_errorData)), errorForwarded);
@@ -1208,8 +1208,8 @@ void tst_QtcProcess::mergedChannels()
     process.start();
     QVERIFY(process.waitForFinished());
 
-    const QByteArray output = process.readAllStandardOutput();
+    const QByteArray output = process.readAllRawStandardOutput();
-    const QByteArray error = process.readAllStandardError();
+    const QByteArray error = process.readAllRawStandardError();
 
     QCOMPARE(output.contains(QByteArray(s_outputData)), outputOnOutput);
     QCOMPARE(error.contains(QByteArray(s_outputData)), outputOnError);
@@ -1256,7 +1256,7 @@ void tst_QtcProcess::flushFinishedWhileWaitingForReadyRead()
     QByteArray reply;
     while (process.state() == QProcess::Running) {
         process.waitForReadyRead(500);
-        reply += process.readAllStandardOutput();
+        reply += process.readAllRawStandardOutput();
         if (timer.hasExpired())
             break;
     }
@@ -1344,12 +1344,12 @@ void tst_QtcProcess::recursiveBlockingProcess()
         process.start();
         QVERIFY(process.waitForStarted(1000));
         QVERIFY(process.waitForReadyRead(1000));
-        QCOMPARE(process.readAllStandardOutput(), s_leafProcessStarted);
+        QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessStarted);
         QCOMPARE(runningTestProcessCount(), recursionDepth);
         QVERIFY(!process.waitForFinished(1000));
         process.terminate();
         QVERIFY(process.waitForReadyRead());
-        QCOMPARE(process.readAllStandardOutput(), s_leafProcessTerminated);
+        QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessTerminated);
         QVERIFY(process.waitForFinished());
         QCOMPARE(process.exitStatus(), QProcess::NormalExit);
         QCOMPARE(process.exitCode(), s_crashCode);
@@ -1404,7 +1404,7 @@ void tst_QtcProcess::quitBlockingProcess()
     QVERIFY(process.isRunning());
 
     QVERIFY(process.waitForReadyRead(1000));
-    QCOMPARE(process.readAllStandardOutput(), s_leafProcessStarted);
+    QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessStarted);
 
     switch (quitType) {
     case QuitType::Terminate: process.terminate(); break;
@@ -1426,11 +1426,11 @@ void tst_QtcProcess::quitBlockingProcess()
         if (gracefulQuit) {
             if (HostOsInfo::isWindowsHost())
                 QSKIP(s_skipTerminateOnWindows);
-            QCOMPARE(process.readAllStandardOutput(), s_leafProcessTerminated);
+            QCOMPARE(process.readAllRawStandardOutput(), s_leafProcessTerminated);
             QCOMPARE(process.exitStatus(), QProcess::NormalExit);
             QCOMPARE(process.exitCode(), s_crashCode);
         } else {
-            QCOMPARE(process.readAllStandardOutput(), QByteArray());
+            QCOMPARE(process.readAllRawStandardOutput(), QByteArray());
             QCOMPARE(process.exitStatus(), QProcess::CrashExit);
             QVERIFY(process.exitCode() != s_crashCode);
         }