1 files changed, 31 insertions, 31 deletions
diff --git a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
index 367fc97..57a18a8 100644
--- a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
+++ b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 // TODO:
 // - We should handle incoming terminates after we have terminated, so the other
@@ -84,15 +84,15 @@ OutgoingJingleFileTransfer::~OutgoingJingleFileTransfer() {
     delete hashCalculator;
     hashCalculator = nullptr;
     removeTransporter();
 }
 
 void OutgoingJingleFileTransfer::start() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (state != Initial) {
-        SWIFT_LOG(warning) << "Incorrect state" << std::endl;
+        SWIFT_LOG(warning) << "Incorrect state";
         return;
     }
 
     if (!options.isInBandAllowed() && !options.isDirectAllowed() && !options.isAssistedAllowed() && !options.isProxiedAllowed()) {
         // Started outgoing file transfer while not supporting transport methods.
         setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::UnknownError));
@@ -106,45 +106,45 @@ void OutgoingJingleFileTransfer::start() {
 
 void OutgoingJingleFileTransfer::cancel() {
     terminate(JinglePayload::Reason::Cancel);
 }
 
 void OutgoingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {
-    SWIFT_LOG(debug) << reason << std::endl;
+    SWIFT_LOG(debug) << reason;
 
     if (state != Initial && state != GeneratingInitialLocalCandidates && state != Finished) {
         session->sendTerminate(reason);
     }
     stopAll();
     setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));
 }
 
 void OutgoingJingleFileTransfer::handleSessionAcceptReceived(
         const JingleContentID&,
         JingleDescription::ref,
         JingleTransportPayload::ref transportPayload) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (JingleS5BTransportPayload::ref s5bPayload = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload)) {
         transporter->addRemoteCandidates(s5bPayload->getCandidates(), s5bPayload->getDstAddr());
         setInternalState(TryingCandidates);
         transporter->startTryingRemoteCandidates();
     }
     else if (JingleIBBTransportPayload::ref ibbPayload = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transportPayload)) {
         startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));
     }
     else {
-        SWIFT_LOG(debug) << "Unknown transport payload. Falling back." << std::endl;
+        SWIFT_LOG(debug) << "Unknown transport payload. Falling back.";
         fallback();
     }
 }
 
 void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     stopAll();
     if (state == WaitForTermination) {
         waitForRemoteTermination->stop();
     }
     if (reason && reason->type == JinglePayload::Reason::Cancel) {
@@ -159,92 +159,92 @@ void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<
     else {
         setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransportAcceptReceived(const JingleContentID&, JingleTransportPayload::ref transport) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != FallbackRequested) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != FallbackRequested) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (JingleIBBTransportPayload::ref ibbPayload = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport)) {
         startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));
     }
     else {
-        SWIFT_LOG(debug) << "Unknown transport replacement" << std::endl;
+        SWIFT_LOG(debug) << "Unknown transport replacement";
         terminate(JinglePayload::Reason::FailedTransport);
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransportRejectReceived(const JingleContentID &, std::shared_ptr<JingleTransportPayload>) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     terminate(JinglePayload::Reason::UnsupportedTransports);
 }
 
 void OutgoingJingleFileTransfer::sendSessionInfoHash() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     JingleFileTransferHash::ref hashElement = std::make_shared<JingleFileTransferHash>();
     hashElement->getFileInfo().addHash(HashElement("sha-1", hashCalculator->getSHA1Hash()));
     hashElement->getFileInfo().addHash(HashElement("md5", hashCalculator->getMD5Hash()));
     session->sendInfo(hashElement);
 }
 
 void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(
         const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>& candidates, const std::string& dstAddr) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     fillCandidateMap(localCandidates, candidates);
 
     JingleFileTransferDescription::ref description = std::make_shared<JingleFileTransferDescription>();
     fileInfo.addHash(HashElement("sha-1", ByteArray()));
     fileInfo.addHash(HashElement("md5", ByteArray()));
     description->setFileInfo(fileInfo);
 
     JingleTransportPayload::ref transport;
     if (candidates.empty()) {
-        SWIFT_LOG(debug) << "no S5B candidates generated. Send IBB transport candidate." << std::endl;
+        SWIFT_LOG(debug) << "no S5B candidates generated. Send IBB transport candidate.";
         JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();
         ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);
         ibbTransport->setSessionID(idGenerator->generateID());
         transport = ibbTransport;
     }
     else {
         JingleS5BTransportPayload::ref s5bTransport = std::make_shared<JingleS5BTransportPayload>();
         s5bTransport->setSessionID(s5bSessionID);
         s5bTransport->setMode(JingleS5BTransportPayload::TCPMode);
         s5bTransport->setDstAddr(dstAddr);
         for (auto&& candidate : candidates) {
             s5bTransport->addCandidate(candidate);
-            SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString() << std::endl;
+            SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString();
         }
         transport = s5bTransport;
     }
     setInternalState(WaitingForAccept);
     session->sendInitiate(contentID, description, transport);
 }
 
 void OutgoingJingleFileTransfer::fallback() {
     if (options.isInBandAllowed()) {
-        SWIFT_LOG(debug) << "Trying to fallback to IBB transport." << std::endl;
+        SWIFT_LOG(debug) << "Trying to fallback to IBB transport.";
         JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();
         ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);
         ibbTransport->setSessionID(idGenerator->generateID());
         setInternalState(FallbackRequested);
         session->sendTransportReplace(contentID, ibbTransport);
     }
     else {
-        SWIFT_LOG(debug) << "Fallback to IBB transport not allowed." << std::endl;
+        SWIFT_LOG(debug) << "Fallback to IBB transport not allowed.";
         terminate(JinglePayload::Reason::ConnectivityError);
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != Transferring) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != Transferring) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     if (error) {
         terminate(JinglePayload::Reason::ConnectivityError);
     }
     else {
         sendSessionInfoHash();
@@ -253,33 +253,33 @@ void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTran
         setInternalState(WaitForTermination);
         waitForRemoteTermination->start();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     this->transportSession = transportSession;
     processedBytesConnection = transportSession->onBytesSent.connect(
             boost::bind(boost::ref(onProcessedBytes), _1));
     transferFinishedConnection = transportSession->onFinished.connect(
             boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));
     setInternalState(Transferring);
     transportSession->start();
 }
 
 
 void OutgoingJingleFileTransfer::setInternalState(State state) {
-    SWIFT_LOG(debug) <<  state << std::endl;
+    SWIFT_LOG(debug) <<  state;
     this->state = state;
     setState(FileTransfer::State(getExternalState(state)));
 }
 
 void OutgoingJingleFileTransfer::setFinishedState(
         FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     this->state = Finished;
     onStateChanged(type);
     onFinished(error);
 }
 
 FileTransfer::State::Type OutgoingJingleFileTransfer::getExternalState(State state) {
@@ -298,15 +298,15 @@ FileTransfer::State::Type OutgoingJingleFileTransfer::getExternalState(State sta
     }
     assert(false);
     return FileTransfer::State::Initial;
 }
 
 void OutgoingJingleFileTransfer::stopAll() {
-    SWIFT_LOG(debug) << state << std::endl;
+    SWIFT_LOG(debug) << state;
     switch (state) {
-        case Initial: SWIFT_LOG(warning) << "Not yet started" << std::endl; break;
+        case Initial: SWIFT_LOG(warning) << "Not yet started"; break;
         case GeneratingInitialLocalCandidates: transporter->stopGeneratingLocalCandidates(); break;
         case WaitingForAccept: break;
         case TryingCandidates: transporter->stopTryingRemoteCandidates(); break;
         case FallbackRequested: break;
         case WaitingForPeerProxyActivate: break;
         case WaitingForLocalProxyActivate: transporter->stopActivatingProxy(); break;
@@ -317,33 +317,33 @@ void OutgoingJingleFileTransfer::stopAll() {
             transferFinishedConnection.disconnect();
             transportSession->stop();
             transportSession.reset();
             break;
         case WaitForTermination:
             break;
-        case Finished: SWIFT_LOG(warning) << "Already finished" << std::endl; break;
+        case Finished: SWIFT_LOG(warning) << "Already finished"; break;
     }
     if (state != Initial) {
         removeTransporter();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferViaRemoteCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setInternalState(WaitingForPeerProxyActivate);
     }
     else {
         transportSession = createRemoteCandidateSession();
         startTransferringIfCandidateAcknowledged();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setInternalState(WaitingForLocalProxyActivate);
         transporter->startActivatingProxy(theirCandidateChoice->jid);
     }
     else {
@@ -397,11 +397,11 @@ std::shared_ptr<TransportSession> OutgoingJingleFileTransfer::createLocalCandida
 std::shared_ptr<TransportSession> OutgoingJingleFileTransfer::createRemoteCandidateSession() {
     return transporter->createRemoteCandidateSession(stream, ourCandidateChoice.get());
 }
 
 void OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout() {
     assert(state == WaitForTermination);
-    SWIFT_LOG(warning) << "Other party did not terminate session. Terminate it now." << std::endl;
+    SWIFT_LOG(warning) << "Other party did not terminate session. Terminate it now.";
     waitForRemoteTermination->stop();
     terminate(JinglePayload::Reason::MediaError);
 }