Reduce indentation of HTTPFetchOngoing

Also clean up some related things.

1 files changed, 30 insertions, 30 deletions

diff --git a/src/clientmedia.cpp b/src/clientmedia.cpp
index c1043c769..e2679ed46 100644
--- a/src/clientmedia.cpp
+++ b/src/clientmedia.cpp
@@ -140,17 +140,17 @@ void ClientMediaDownloader::step(Client *client)
 	// Remote media: check for completion of fetches
 	if (m_httpfetch_active) {
 		bool fetched_something = false;
-		HTTPFetchResult fetchresult;
+		HTTPFetchResult fetch_result;
 
-		while (httpfetch_async_get(m_httpfetch_caller, fetchresult)) {
+		while (httpfetch_async_get(m_httpfetch_caller, fetch_result)) {
 			m_httpfetch_active--;
 			fetched_something = true;
 
 			// Is this a hashset (index.mth) or a media file?
-			if (fetchresult.request_id < m_remotes.size())
-				remoteHashSetReceived(fetchresult);
+			if (fetch_result.request_id < m_remotes.size())
+				remoteHashSetReceived(fetch_result);
 			else
-				remoteMediaReceived(fetchresult, client);
+				remoteMediaReceived(fetch_result, client);
 		}
 
 		if (fetched_something)
@@ -259,17 +259,17 @@ void ClientMediaDownloader::initialStep(Client *client)
 			actionstream << "Client: Contacting remote server \""
 				<< remote->baseurl << "\"" << std::endl;
 
-			HTTPFetchRequest fetchrequest;
-			fetchrequest.url =
+			HTTPFetchRequest fetch_request;
+			fetch_request.url =
 				remote->baseurl + MTHASHSET_FILE_NAME;
-			fetchrequest.caller = m_httpfetch_caller;
-			fetchrequest.request_id = m_httpfetch_next_id; // == i
-			fetchrequest.timeout = m_httpfetch_timeout;
-			fetchrequest.connect_timeout = m_httpfetch_timeout;
-			fetchrequest.post_data = required_hash_set;
-			fetchrequest.extra_headers.push_back(
+			fetch_request.caller = m_httpfetch_caller;
+			fetch_request.request_id = m_httpfetch_next_id; // == i
+			fetch_request.timeout = m_httpfetch_timeout;
+			fetch_request.connect_timeout = m_httpfetch_timeout;
+			fetch_request.post_data = required_hash_set;
+			fetch_request.extra_headers.push_back(
 				"Content-Type: application/octet-stream");
-			httpfetch_async(fetchrequest);
+			httpfetch_async(fetch_request);
 
 			m_httpfetch_active++;
 			m_httpfetch_next_id++;
@@ -279,21 +279,21 @@ void ClientMediaDownloader::initialStep(Client *client)
 }
 
 void ClientMediaDownloader::remoteHashSetReceived(
-		const HTTPFetchResult &fetchresult)
+		const HTTPFetchResult &fetch_result)
 {
-	u32 remote_id = fetchresult.request_id;
+	u32 remote_id = fetch_result.request_id;
 	assert(remote_id < m_remotes.size());
 	RemoteServerStatus *remote = m_remotes[remote_id];
 
 	m_outstanding_hash_sets--;
 
-	if (fetchresult.succeeded) {
+	if (fetch_result.succeeded) {
 		try {
 			// Server sent a list of file hashes that are
 			// available on it, try to parse the list
 
 			std::set<std::string> sha1_set;
-			deSerializeHashSet(fetchresult.data, sha1_set);
+			deSerializeHashSet(fetch_result.data, sha1_set);
 
 			// Parsing succeeded: For every file that is
 			// available on this server, add this server
@@ -320,7 +320,7 @@ void ClientMediaDownloader::remoteHashSetReceived(
 	// Do NOT check for any particular response code (e.g. 404) here,
 	// because different servers respond differently
 
-	if (!fetchresult.succeeded && !fetchresult.timeout) {
+	if (!fetch_result.succeeded && !fetch_result.timeout) {
 		infostream << "Client: Enabling compatibility mode for remote "
 			<< "server \"" << remote->baseurl << "\"" << std::endl;
 		remote->request_by_filename = true;
@@ -338,7 +338,7 @@ void ClientMediaDownloader::remoteHashSetReceived(
 }
 
 void ClientMediaDownloader::remoteMediaReceived(
-		const HTTPFetchResult &fetchresult,
+		const HTTPFetchResult &fetch_result,
 		Client *client)
 {
 	// Some remote server sent us a file.
@@ -349,7 +349,7 @@ void ClientMediaDownloader::remoteMediaReceived(
 	std::string name;
 	{
 		std::map<unsigned long, std::string>::iterator it =
-			m_remote_file_transfers.find(fetchresult.request_id);
+			m_remote_file_transfers.find(fetch_result.request_id);
 		assert(it != m_remote_file_transfers.end());
 		name = it->second;
 		m_remote_file_transfers.erase(it);
@@ -368,9 +368,9 @@ void ClientMediaDownloader::remoteMediaReceived(
 
 	// If fetch succeeded, try to load media file
 
-	if (fetchresult.succeeded) {
+	if (fetch_result.succeeded) {
 		bool success = checkAndLoad(name, filestatus->sha1,
-				fetchresult.data, false, client);
+				fetch_result.data, false, client);
 		if (success) {
 			filestatus->received = true;
 			assert(m_uncached_received_count < m_uncached_count);
@@ -445,14 +445,14 @@ void ClientMediaDownloader::startRemoteMediaTransfers()
 					<< "\"" << name << "\" "
 					<< "\"" << url << "\"" << std::endl;
 
-				HTTPFetchRequest fetchrequest;
-				fetchrequest.url = url;
-				fetchrequest.caller = m_httpfetch_caller;
-				fetchrequest.request_id = m_httpfetch_next_id;
-				fetchrequest.timeout = 0; // no data timeout!
-				fetchrequest.connect_timeout =
+				HTTPFetchRequest fetch_request;
+				fetch_request.url = url;
+				fetch_request.caller = m_httpfetch_caller;
+				fetch_request.request_id = m_httpfetch_next_id;
+				fetch_request.timeout = 0; // no data timeout!
+				fetch_request.connect_timeout =
 					m_httpfetch_timeout;
-				httpfetch_async(fetchrequest);
+				httpfetch_async(fetch_request);
 
 				m_remote_file_transfers.insert(std::make_pair(
 							m_httpfetch_next_id,