1 files changed, 12 insertions, 12 deletions
diff --git a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
index f9441cd..6369581 100644
--- a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
+++ b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
@@ -86,13 +86,13 @@ void OutgoingJingleFileTransfer::start() {
 	if (state != Initial) {
 		SWIFT_LOG(warning) << "Incorrect state" << std::endl;
 		return;
 	}
 
 	setTransporter(transporterFactory->createInitiatorTransporter(getInitiator(), getResponder(), options));
-	setState(GeneratingInitialLocalCandidates);
+	setInternalState(GeneratingInitialLocalCandidates);
 	transporter->startGeneratingLocalCandidates();
 }
 
 void OutgoingJingleFileTransfer::cancel() {
 	terminate(JinglePayload::Reason::Cancel);
 }
@@ -113,13 +113,13 @@ void OutgoingJingleFileTransfer::handleSessionAcceptReceived(
 		JingleTransportPayload::ref transportPayload) {
 	SWIFT_LOG(debug) << std::endl;
 	if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
 
 	if (JingleS5BTransportPayload::ref s5bPayload = boost::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload)) {
 		transporter->addRemoteCandidates(s5bPayload->getCandidates(), s5bPayload->getDstAddr());
-		setState(TryingCandidates);
+		setInternalState(TryingCandidates);
 		transporter->startTryingRemoteCandidates();
 	}
 	else {
 		SWIFT_LOG(debug) << "Unknown transport payload. Falling back." << std::endl;
 		fallback();
 	}
@@ -175,13 +175,13 @@ void OutgoingJingleFileTransfer::sendSessionInfoHash() {
 	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" << std::endl; return; }
+	if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
 
 	fillCandidateMap(localCandidates, candidates);
 
 	JingleFileTransferDescription::ref description = boost::make_shared<JingleFileTransferDescription>();
 	fileInfo.addHash(HashElement("sha-1", ByteArray()));
 	fileInfo.addHash(HashElement("md5", ByteArray()));
@@ -192,23 +192,23 @@ void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(
 	transport->setMode(JingleS5BTransportPayload::TCPMode);
 	transport->setDstAddr(dstAddr);
 	foreach(JingleS5BTransportPayload::Candidate candidate, candidates) {
 		transport->addCandidate(candidate);	
 		SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString() << std::endl;
 	}
-	setState(WaitingForAccept);
+	setInternalState(WaitingForAccept);
 	session->sendInitiate(contentID, description, transport);
 }
 
 void OutgoingJingleFileTransfer::fallback() {
 	if (options.isInBandAllowed()) {
 		SWIFT_LOG(debug) << "Trying to fallback to IBB transport." << std::endl;
 		JingleIBBTransportPayload::ref ibbTransport = boost::make_shared<JingleIBBTransportPayload>();
 		ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);
 		ibbTransport->setSessionID(idGenerator->generateID());
-		setState(FallbackRequested);
+		setInternalState(FallbackRequested);
 		session->sendTransportReplace(contentID, ibbTransport);
 	}
 	else {
 		SWIFT_LOG(debug) << "Fallback to IBB transport not allowed." << std::endl;
 		terminate(JinglePayload::Reason::ConnectivityError);
 	}
@@ -222,34 +222,34 @@ void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTran
 		terminate(JinglePayload::Reason::ConnectivityError);
 	} 
 	else {
 		sendSessionInfoHash();
 
 		// wait for other party to terminate session after they have verified the hash
-		setState(WaitForTermination);
+		setInternalState(WaitForTermination);
 		waitForRemoteTermination->start();
 	}
 }
 
 void OutgoingJingleFileTransfer::startTransferring(boost::shared_ptr<TransportSession> transportSession) {
 	SWIFT_LOG(debug) << std::endl;
 
 	this->transportSession = transportSession;
 	processedBytesConnection = transportSession->onBytesSent.connect(
 			boost::bind(boost::ref(onProcessedBytes), _1));
 	transferFinishedConnection = transportSession->onFinished.connect(
 			boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));
-	setState(Transferring);
+	setInternalState(Transferring);
 	transportSession->start();
 }
 
 
-void OutgoingJingleFileTransfer::setState(State state) {
+void OutgoingJingleFileTransfer::setInternalState(State state) {
 	SWIFT_LOG(debug) <<  state << std::endl;
 	this->state = state;
-	onStateChanged(FileTransfer::State(getExternalState(state)));
+	setState(FileTransfer::State(getExternalState(state)));
 }
 
 void OutgoingJingleFileTransfer::setFinishedState(
 		FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {
 	SWIFT_LOG(debug) << std::endl;
 	this->state = Finished;
@@ -303,25 +303,25 @@ void OutgoingJingleFileTransfer::stopAll() {
 }
 
 void OutgoingJingleFileTransfer::startTransferViaRemoteCandidate() {
 	SWIFT_LOG(debug) << std::endl;
 
 	if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
-		setState(WaitingForPeerProxyActivate);
+		setInternalState(WaitingForPeerProxyActivate);
 	} 
 	else {
 		transportSession = createRemoteCandidateSession();
 		startTransferringIfCandidateAcknowledged();
 	}
 }
 
 void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {
 	SWIFT_LOG(debug) << std::endl;
 
 	if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
-		setState(WaitingForLocalProxyActivate);
+		setInternalState(WaitingForLocalProxyActivate);
 		transporter->startActivatingProxy(theirCandidateChoice->jid);
 	} 
 	else {
 		transportSession = createLocalCandidateSession();
 		startTransferringIfCandidateAcknowledged();
 	}
@@ -329,13 +329,13 @@ void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {
 
 void OutgoingJingleFileTransfer::startTransferringIfCandidateAcknowledged() {
 	if (candidateAcknowledged) {
 		startTransferring(transportSession);
 	}
 	else {
-		setState(WaitingForCandidateAcknowledge);
+		setInternalState(WaitingForCandidateAcknowledge);
 	}
 }
 
 void OutgoingJingleFileTransfer::handleTransportInfoAcknowledged(const std::string& id) {
 	if (id == candidateSelectRequestID) {
 		candidateAcknowledged = true;