From 96d04a050b4eee3fc0e0728043d5aa960d06eb9e Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 30 Jul 2015 16:13:56 -0700
Subject: Added patchAndYield to httputil adapter Converted All AISv3 commands
 (except copyLibrary) to coro model.

---
 indra/newview/llaisapi.cpp | 698 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 557 insertions(+), 141 deletions(-)

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index 9d887a61f1..3565c04609 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -36,6 +36,422 @@
 #include "llinventoryobserver.h"
 #include "llviewercontrol.h"
 
+///----------------------------------------------------------------------------
+#if 1
+/*static*/ 
+void AISAPI::CreateInventoryCommand(const LLUUID& parentId, const LLSD& newInventory, completion_t callback)
+{
+#if 1
+    std::string cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    LLUUID tid;
+    tid.generate();
+
+    std::string url = cap + std::string("/category/") + parentId.asString() + "?tid=" + tid.asString();
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    // I may be suffering from golden hammer here, but the first part of this bind 
+    // is actually a static cast for &HttpCoroutineAdapter::postAndYield so that 
+    // the compiler can identify the correct signature to select.
+    // 
+    // Reads as follows:
+    // LLSD     - method returning LLSD
+    // (LLCoreHttpUtil::HttpCoroutineAdapter::*) - pointer to member function of HttpCoroutineAdapter
+    // (LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t) - signature of method
+    //  
+    invokationFn_t postFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD (LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndYield), _1, _2, _3, _4, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, postFn, url, parentId, newInventory, callback));
+#else
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::CreateInventoryCommandCoro, 
+        _1, parentId, newInventory, callback));
+
+#endif
+    EnqueueAISCommand("CreateInventory", proc);
+
+}
+
+/*static*/ 
+void AISAPI::SlamFolderCommand(const LLUUID& folderId, const LLSD& newInventory, completion_t callback)
+{
+#if 1
+    std::string cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    LLUUID tid;
+    tid.generate();
+
+    std::string url = cap + std::string("/category/") + folderId.asString() + "/links?tid=" + tid.asString();
+
+    // see comment above in CreateInventoryCommand
+    invokationFn_t putFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndYield), _1, _2, _3, _4, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, putFn, url, folderId, newInventory, callback));
+
+#else
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::SlamFolderCommandCoro,
+        _1, folderId, newInventory, callback));
+#endif
+
+    EnqueueAISCommand("SlamFolder", proc);
+}
+
+void AISAPI::RemoveCategoryCommand(const LLUUID &categoryId, completion_t callback)
+{
+    std::string cap;
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    std::string url = cap + std::string("/category/") + categoryId.asString();
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    invokationFn_t delFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, delFn, url, categoryId, LLSD(), callback));
+
+    EnqueueAISCommand("RemoveCategory", proc);
+}
+
+/*static*/ 
+void AISAPI::RemoveItemCommand(const LLUUID &itemId, completion_t callback)
+{
+#if 1
+    std::string cap;
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    std::string url = cap + std::string("/item/") + itemId.asString();
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    invokationFn_t delFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, delFn, url, itemId, LLSD(), callback));
+
+#else
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::RemoveItemCommandCoro,
+        _1, itemId, callback));
+#endif
+
+    EnqueueAISCommand("RemoveItem", proc);
+}
+
+
+/*static*/ 
+void AISAPI::PurgeDescendentsCommand(const LLUUID &categoryId, completion_t callback)
+{
+    std::string cap;
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    std::string url = cap + std::string("/category/") + categoryId.asString() + "/children";
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    invokationFn_t delFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, delFn, url, categoryId, LLSD(), callback));
+
+    EnqueueAISCommand("PurgeDescendents", proc);
+}
+
+
+/*static*/
+void AISAPI::UpdateCategoryCommand(const LLUUID &categoryId, const LLSD &updates, completion_t callback)
+{
+    std::string cap;
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+    std::string url = cap + std::string("/category/") + categoryId.asString();
+
+    invokationFn_t patchFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, patchFn, url, categoryId, updates, callback));
+
+    EnqueueAISCommand("UpdateCategory", proc);
+}
+
+/*static*/
+void AISAPI::UpdateItemCommand(const LLUUID &itemId, const LLSD &updates, completion_t callback)
+{
+
+    std::string cap;
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+    std::string url = cap + std::string("/item/") + itemId.asString();
+
+    invokationFn_t patchFn = boost::bind(
+        // Humans ignore next line.  It is just a cast.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
+
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, patchFn, url, itemId, updates, callback));
+
+    EnqueueAISCommand("UpdateItem", proc);
+}
+
+/*static*/
+void AISAPI::EnqueueAISCommand(const std::string &procName, LLCoprocedureManager::CoProcedure_t proc)
+{
+    std::string procFullName = "AIS(" + procName + ")";
+    LLCoprocedureManager::getInstance()->enqueueCoprocedure("AIS", procFullName, proc);
+
+}
+
+/*static*/ 
+std::string AISAPI::getInvCap()
+{
+    if (gAgent.getRegion())
+    {
+        return gAgent.getRegion()->getCapability("InventoryAPIv3");
+    }
+
+    return std::string();
+}
+
+/*static*/ 
+std::string AISAPI::getLibCap()
+{
+    if (gAgent.getRegion())
+    {
+        return gAgent.getRegion()->getCapability("LibraryAPIv3");
+    }
+    return std::string();
+}
+
+/*static*/
+void AISAPI::InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, 
+        invokationFn_t invoke, std::string url, 
+        LLUUID targetId, LLSD body, completion_t callback)
+{
+    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
+    LLCore::HttpHeaders::ptr_t httpHeaders;
+
+    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
+
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    LLSD result = invoke(httpAdapter, httpRequest, url, body, httpOptions, httpHeaders);
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status || !result.isMap())
+    {
+        if (!result.isMap())
+        {
+            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
+        }
+        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
+        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
+    }
+
+    gInventory.onAISUpdateReceived("AISCommand", result);
+
+    if (callback)
+    {   // UUID always null
+        callback(LLUUID::null);
+    }
+
+}
+
+#if 0
+/*static*/
+void AISAPI::CreateInventoryCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID parentId, LLSD newInventory, completion_t callback)
+{
+    std::string cap;
+    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
+
+    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    LLUUID tid;
+    tid.generate();
+
+    std::string url = cap + std::string("/category/") + parentId.asString() + "?tid=" + tid.asString();
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    LLSD result = httpAdapter->postAndYield(httpRequest, url, newInventory, httpOptions);
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status || !result.isMap())
+    {
+        if (!result.isMap())
+        {
+            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
+        }
+        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
+        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
+    }
+
+    gInventory.onAISUpdateReceived("AISCommand", result);
+
+    if (callback)
+    {   // UUID always null
+        callback(LLUUID::null);
+    }
+
+}
+
+/*static*/
+void AISAPI::SlamFolderCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID folderId, LLSD newInventory, completion_t callback)
+{
+    std::string cap;
+    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
+
+    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    LLUUID tid;
+    tid.generate();
+
+    std::string url = cap + std::string("/category/") + folderId.asString() + "/links?tid=" + tid.asString();
+
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    LLSD result = httpAdapter->putAndYield(httpRequest, url, newInventory, httpOptions);
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status || !result.isMap())
+    {
+        if (!result.isMap())
+        {
+            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
+        }
+        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
+        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
+    }
+
+    gInventory.onAISUpdateReceived("AISCommand", result);
+
+    if (callback)
+    {   // UUID always null
+        callback(LLUUID::null);
+    }
+
+}
+
+void AISAPI::RemoveItemCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID itemId, completion_t callback)
+{
+    std::string cap;
+    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
+
+    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
+
+    cap = getInvCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
+        return;
+    }
+
+    std::string url = cap + std::string("/item/") + itemId.asString();
+    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+
+    LLSD result = httpAdapter->deleteAndYield(httpRequest, url, httpOptions);
+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
+
+    if (!status || !result.isMap())
+    {
+        if (!result.isMap())
+        {
+            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
+        }
+        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
+        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
+    }
+
+    gInventory.onAISUpdateReceived("AISCommand", result);
+
+    if (callback)
+    {   // UUID always null
+        callback(LLUUID::null);
+    }
+}
+#endif
+#endif
 ///----------------------------------------------------------------------------
 /// Classes for AISv3 support.
 ///----------------------------------------------------------------------------
@@ -165,153 +581,153 @@ void AISCommand::getCapabilityNames(LLSD& capabilityNames)
 	capabilityNames.append("LibraryAPIv3");
 }
 
-RemoveItemCommand::RemoveItemCommand(const LLUUID& item_id,
-									 LLPointer<LLInventoryCallback> callback):
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	std::string url = cap + std::string("/item/") + item_id.asString();
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LLHTTPClient::ResponderPtr responder = this;
-	LLSD headers;
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// RemoveItemCommand::RemoveItemCommand(const LLUUID& item_id,
+// 									 LLPointer<LLInventoryCallback> callback):
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	std::string url = cap + std::string("/item/") + item_id.asString();
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LLHTTPClient::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-RemoveCategoryCommand::RemoveCategoryCommand(const LLUUID& item_id,
-											 LLPointer<LLInventoryCallback> callback):
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	std::string url = cap + std::string("/category/") + item_id.asString();
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LLHTTPClient::ResponderPtr responder = this;
-	LLSD headers;
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// RemoveCategoryCommand::RemoveCategoryCommand(const LLUUID& item_id,
+// 											 LLPointer<LLInventoryCallback> callback):
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	std::string url = cap + std::string("/category/") + item_id.asString();
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LLHTTPClient::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-PurgeDescendentsCommand::PurgeDescendentsCommand(const LLUUID& item_id,
-												 LLPointer<LLInventoryCallback> callback):
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	std::string url = cap + std::string("/category/") + item_id.asString() + "/children";
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// PurgeDescendentsCommand::PurgeDescendentsCommand(const LLUUID& item_id,
+// 												 LLPointer<LLInventoryCallback> callback):
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	std::string url = cap + std::string("/category/") + item_id.asString() + "/children";
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LLCurl::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-UpdateItemCommand::UpdateItemCommand(const LLUUID& item_id,
-									 const LLSD& updates,
-									 LLPointer<LLInventoryCallback> callback):
-	mUpdates(updates),
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	std::string url = cap + std::string("/item/") + item_id.asString();
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LL_DEBUGS("Inventory") << "request: " << ll_pretty_print_sd(mUpdates) << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	headers["Content-Type"] = "application/llsd+xml";
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// UpdateItemCommand::UpdateItemCommand(const LLUUID& item_id,
+// 									 const LLSD& updates,
+// 									 LLPointer<LLInventoryCallback> callback):
+// 	mUpdates(updates),
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	std::string url = cap + std::string("/item/") + item_id.asString();
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LL_DEBUGS("Inventory") << "request: " << ll_pretty_print_sd(mUpdates) << LL_ENDL;
+// 	LLCurl::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	headers["Content-Type"] = "application/llsd+xml";
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-UpdateCategoryCommand::UpdateCategoryCommand(const LLUUID& cat_id,
-											 const LLSD& updates,
-											 LLPointer<LLInventoryCallback> callback):
-	mUpdates(updates),
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	std::string url = cap + std::string("/category/") + cat_id.asString();
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	headers["Content-Type"] = "application/llsd+xml";
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// UpdateCategoryCommand::UpdateCategoryCommand(const LLUUID& cat_id,
+// 											 const LLSD& updates,
+// 											 LLPointer<LLInventoryCallback> callback):
+// 	mUpdates(updates),
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	std::string url = cap + std::string("/category/") + cat_id.asString();
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LLCurl::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	headers["Content-Type"] = "application/llsd+xml";
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-CreateInventoryCommand::CreateInventoryCommand(const LLUUID& parent_id,
-							 				   const LLSD& new_inventory,
-							 				   LLPointer<LLInventoryCallback> callback):
-	mNewInventory(new_inventory),
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	LLUUID tid;
-	tid.generate();
-	std::string url = cap + std::string("/category/") + parent_id.asString() + "?tid=" + tid.asString();
-	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	headers["Content-Type"] = "application/llsd+xml";
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::post, url, mNewInventory, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// CreateInventoryCommand::CreateInventoryCommand(const LLUUID& parent_id,
+// 							 				   const LLSD& new_inventory,
+// 							 				   LLPointer<LLInventoryCallback> callback):
+// 	mNewInventory(new_inventory),
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	LLUUID tid;
+// 	tid.generate();
+// 	std::string url = cap + std::string("/category/") + parent_id.asString() + "?tid=" + tid.asString();
+// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+// 	LLCurl::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	headers["Content-Type"] = "application/llsd+xml";
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::post, url, mNewInventory, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
-SlamFolderCommand::SlamFolderCommand(const LLUUID& folder_id, const LLSD& contents, LLPointer<LLInventoryCallback> callback):
-	mContents(contents),
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getInvCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	LLUUID tid;
-	tid.generate();
-	std::string url = cap + std::string("/category/") + folder_id.asString() + "/links?tid=" + tid.asString();
-	LL_INFOS() << url << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	headers["Content-Type"] = "application/llsd+xml";
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::put, url, mContents, responder, headers, timeout);
-	setCommandFunc(cmd);
-}
+// SlamFolderCommand::SlamFolderCommand(const LLUUID& folder_id, const LLSD& contents, LLPointer<LLInventoryCallback> callback):
+// 	mContents(contents),
+// 	AISCommand(callback)
+// {
+// 	std::string cap;
+// 	if (!getInvCap(cap))
+// 	{
+// 		LL_WARNS() << "No cap found" << LL_ENDL;
+// 		return;
+// 	}
+// 	LLUUID tid;
+// 	tid.generate();
+// 	std::string url = cap + std::string("/category/") + folder_id.asString() + "/links?tid=" + tid.asString();
+// 	LL_INFOS() << url << LL_ENDL;
+// 	LLCurl::ResponderPtr responder = this;
+// 	LLSD headers;
+// 	headers["Content-Type"] = "application/llsd+xml";
+// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
+// 	command_func_type cmd = boost::bind(&LLHTTPClient::put, url, mContents, responder, headers, timeout);
+// 	setCommandFunc(cmd);
+// }
 
 CopyLibraryCategoryCommand::CopyLibraryCategoryCommand(const LLUUID& source_id,
 													   const LLUUID& dest_id,
-- 
cgit v1.3


From 248d61fe0eadd128c7704e37922ba7fdef35d630 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 12 Aug 2015 16:32:49 -0700
Subject: MAINT-5500: Finish converting the AIS responders to the new coroutine
 model, Cleaned up dead an unused code. MAINT-4952: Added COPY and MOVE
 methods to Core:Http adapter

---
 indra/llcorehttp/_httpoprequest.cpp |  18 +
 indra/llcorehttp/_httpoprequest.h   |   9 +-
 indra/llcorehttp/httprequest.cpp    |  31 ++
 indra/llcorehttp/httprequest.h      |  27 +-
 indra/llmessage/llcorehttputil.cpp  |  94 ++++-
 indra/llmessage/llcorehttputil.h    |  52 ++-
 indra/newview/llaisapi.cpp          | 659 +++++++++---------------------------
 indra/newview/llaisapi.h            | 146 ++------
 indra/newview/llappearancemgr.cpp   |  24 +-
 indra/newview/llviewerinventory.cpp |  84 ++---
 indra/newview/llviewerregion.cpp    |   2 +-
 11 files changed, 441 insertions(+), 705 deletions(-)

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/llcorehttp/_httpoprequest.cpp b/indra/llcorehttp/_httpoprequest.cpp
index e588ed8a9b..86110f5b46 100755
--- a/indra/llcorehttp/_httpoprequest.cpp
+++ b/indra/llcorehttp/_httpoprequest.cpp
@@ -380,6 +380,19 @@ HttpStatus HttpOpRequest::setupCopy(HttpRequest::policy_t policy_id,
 }
 
 
+HttpStatus HttpOpRequest::setupMove(HttpRequest::policy_t policy_id,
+    HttpRequest::priority_t priority,
+    const std::string & url,
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t &headers)
+{
+    setupCommon(policy_id, priority, url, NULL, options, headers);
+    mReqMethod = HOR_MOVE;
+
+    return HttpStatus();
+}
+
+
 void HttpOpRequest::setupCommon(HttpRequest::policy_t policy_id,
 								HttpRequest::priority_t priority,
 								const std::string & url,
@@ -626,6 +639,11 @@ HttpStatus HttpOpRequest::prepareRequest(HttpService * service)
         check_curl_easy_code(code, CURLOPT_CUSTOMREQUEST);
         break;
 
+    case HOR_MOVE:
+        code = curl_easy_setopt(mCurlHandle, CURLOPT_CUSTOMREQUEST, "MOVE");
+        check_curl_easy_code(code, CURLOPT_CUSTOMREQUEST);
+        break;
+
 	default:
 		LL_ERRS(LOG_CORE) << "Invalid HTTP method in request:  "
 						  << int(mReqMethod)  << ".  Can't recover."
diff --git a/indra/llcorehttp/_httpoprequest.h b/indra/llcorehttp/_httpoprequest.h
index a9083be02b..1b449a5abc 100755
--- a/indra/llcorehttp/_httpoprequest.h
+++ b/indra/llcorehttp/_httpoprequest.h
@@ -83,7 +83,8 @@ public:
 		HOR_PUT,
         HOR_DELETE,
         HOR_PATCH,
-        HOR_COPY
+        HOR_COPY,
+        HOR_MOVE
 	};
 	
 	virtual void stageFromRequest(HttpService *);
@@ -148,6 +149,12 @@ public:
                         const HttpOptions::ptr_t & options,
                         const HttpHeaders::ptr_t & headers);
 
+    HttpStatus setupMove(HttpRequest::policy_t policy_id,
+                        HttpRequest::priority_t priority,
+                        const std::string & url,
+                        const HttpOptions::ptr_t & options,
+                        const HttpHeaders::ptr_t & headers);
+
     // Internal method used to setup the libcurl options for a request.
 	// Does all the libcurl handle setup in one place.
 	//
diff --git a/indra/llcorehttp/httprequest.cpp b/indra/llcorehttp/httprequest.cpp
index f0dfde6153..63233259fb 100755
--- a/indra/llcorehttp/httprequest.cpp
+++ b/indra/llcorehttp/httprequest.cpp
@@ -419,6 +419,37 @@ HttpHandle HttpRequest::requestCopy(policy_t policy_id,
     return handle;
 }
 
+HttpHandle HttpRequest::requestMove(policy_t policy_id,
+    priority_t priority,
+    const std::string & url,
+    const HttpOptions::ptr_t & options,
+    const HttpHeaders::ptr_t & headers,
+    HttpHandler * user_handler)
+{
+    HttpStatus status;
+    HttpHandle handle(LLCORE_HTTP_HANDLE_INVALID);
+
+    HttpOpRequest * op = new HttpOpRequest();
+    if (!(status = op->setupMove(policy_id, priority, url, options, headers)))
+    {
+        op->release();
+        mLastReqStatus = status;
+        return handle;
+    }
+    op->setReplyPath(mReplyQueue, user_handler);
+    if (!(status = mRequestQueue->addOp(op)))			// transfers refcount
+    {
+        op->release();
+        mLastReqStatus = status;
+        return handle;
+    }
+
+    mLastReqStatus = status;
+    handle = static_cast<HttpHandle>(op);
+
+    return handle;
+}
+
 
 HttpHandle HttpRequest::requestNoOp(HttpHandler * user_handler)
 {
diff --git a/indra/llcorehttp/httprequest.h b/indra/llcorehttp/httprequest.h
index 20a223c482..6c2449266f 100755
--- a/indra/llcorehttp/httprequest.h
+++ b/indra/llcorehttp/httprequest.h
@@ -478,7 +478,7 @@ public:
 						  HttpHandler * handler);
 
 
-    /// Queue a full HTTP PUT.  Query arguments and body may
+    /// Queue a full HTTP DELETE.  Query arguments and body may
     /// be provided.  Caller is responsible for escaping and
     /// encoding and communicating the content types.
     ///
@@ -497,7 +497,7 @@ public:
             const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
-    /// Queue a full HTTP PUT.  Query arguments and body may
+    /// Queue a full HTTP PATCH.  Query arguments and body may
     /// be provided.  Caller is responsible for escaping and
     /// encoding and communicating the content types.
     ///
@@ -520,7 +520,7 @@ public:
             const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
 
-    /// Queue a full HTTP PUT.  Query arguments and body may
+    /// Queue a full HTTP COPY.  Query arguments and body may
     /// be provided.  Caller is responsible for escaping and
     /// encoding and communicating the content types.
     ///
@@ -538,7 +538,26 @@ public:
             const HttpOptions::ptr_t & options,
             const HttpHeaders::ptr_t & headers,
             HttpHandler * user_handler);
-       
+
+    /// Queue a full HTTP MOVE.  Query arguments and body may
+    /// be provided.  Caller is responsible for escaping and
+    /// encoding and communicating the content types.
+    ///
+    /// @param	policy_id		@see requestGet()
+    /// @param	priority		"
+    /// @param	url				"
+    /// @param	options			@see requestGet()K(optional)
+    /// @param	headers			"
+    /// @param	handler			"
+    /// @return					"
+    ///
+    HttpHandle requestMove(policy_t policy_id,
+            priority_t priority,
+            const std::string & url,
+            const HttpOptions::ptr_t & options,
+            const HttpHeaders::ptr_t & headers,
+            HttpHandler * user_handler);
+
     /// Queue a NoOp request.
 	/// The request is queued and serviced by the working thread which
 	/// immediately processes it and returns the request to the reply
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 50c866f370..d342888255 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -700,7 +700,6 @@ LLSD HttpCoroutineAdapter::postAndYield_(LLCore::HttpRequest::ptr_t &request,
     LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
     cleanState();
 
-    //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
     return results;
 }
 
@@ -737,7 +736,7 @@ LLSD HttpCoroutineAdapter::putAndYield_(LLCore::HttpRequest::ptr_t &request,
     saveState(hhandle, request, handler);
     LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
     cleanState();
-    //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
+
     return results;
 }
 
@@ -792,7 +791,7 @@ LLSD HttpCoroutineAdapter::getAndYield_(LLCore::HttpRequest::ptr_t &request,
     saveState(hhandle, request, handler);
     LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
     cleanState();
-    //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
+
     return results;
 }
 
@@ -827,7 +826,7 @@ LLSD HttpCoroutineAdapter::deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
     saveState(hhandle, request, handler);
     LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
     cleanState();
-    //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
+
     return results;
 }
 
@@ -865,10 +864,95 @@ LLSD HttpCoroutineAdapter::patchAndYield_(LLCore::HttpRequest::ptr_t &request,
     saveState(hhandle, request, handler);
     LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
     cleanState();
-    //LL_INFOS() << "Results for transaction " << transactionId << LL_ENDL;
+
+    return results;
+}
+
+LLSD HttpCoroutineAdapter::copyAndYield(LLCore::HttpRequest::ptr_t request,
+    const std::string & url, const std::string dest,
+    LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
+{
+    LLEventStream  replyPump(mAdapterName + "Reply", true);
+    HttpCoroHandler::ptr_t httpHandler = HttpCoroHandler::ptr_t(new HttpCoroLLSDHandler(replyPump));
+
+    if (!headers)
+        headers.reset(new LLCore::HttpHeaders);
+    headers->append(HTTP_OUT_HEADER_DESTINATION, dest);
+
+    return copyAndYield_(request, url, options, headers, httpHandler);
+}
+
+
+LLSD HttpCoroutineAdapter::copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+    const std::string & url, 
+    LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+    HttpCoroHandler::ptr_t &handler)
+{
+    HttpRequestPumper pumper(request);
+
+    checkDefaultHeaders(headers);
+
+    // The HTTPCoroHandler does not self delete, so retrieval of a the contained 
+    // pointer from the smart pointer is safe in this case.
+    // 
+    LLCore::HttpHandle hhandle = request->requestCopy(mPolicyId, mPriority, url,
+        options, headers, handler.get());
+
+    if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
+    {
+        return HttpCoroutineAdapter::buildImmediateErrorResult(request, url);
+    }
+
+    saveState(hhandle, request, handler);
+    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    cleanState();
+
+    return results;
+}
+
+LLSD HttpCoroutineAdapter::moveAndYield(LLCore::HttpRequest::ptr_t request,
+    const std::string & url, const std::string dest,
+    LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
+{
+    LLEventStream  replyPump(mAdapterName + "Reply", true);
+    HttpCoroHandler::ptr_t httpHandler = HttpCoroHandler::ptr_t(new HttpCoroLLSDHandler(replyPump));
+
+    if (!headers)
+        headers.reset(new LLCore::HttpHeaders);
+    headers->append(HTTP_OUT_HEADER_DESTINATION, dest);
+
+    return moveAndYield_(request, url, options, headers, httpHandler);
+}
+
+
+LLSD HttpCoroutineAdapter::moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+    const std::string & url,
+    LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+    HttpCoroHandler::ptr_t &handler)
+{
+    HttpRequestPumper pumper(request);
+
+    checkDefaultHeaders(headers);
+
+    // The HTTPCoroHandler does not self delete, so retrieval of a the contained 
+    // pointer from the smart pointer is safe in this case.
+    // 
+    LLCore::HttpHandle hhandle = request->requestMove(mPolicyId, mPriority, url,
+        options, headers, handler.get());
+
+    if (hhandle == LLCORE_HTTP_HANDLE_INVALID)
+    {
+        return HttpCoroutineAdapter::buildImmediateErrorResult(request, url);
+    }
+
+    saveState(hhandle, request, handler);
+    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    cleanState();
+
     return results;
 }
 
+
 void HttpCoroutineAdapter::checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &headers)
 {
     if (!headers)
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 8fe2354d6b..31a73bb900 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -457,7 +457,7 @@ public:
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
 
-    /// Execute a Post transaction on the supplied URL and yield execution of 
+    /// Execute a PATCH transaction on the supplied URL and yield execution of 
     /// the coroutine until a result is available. 
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
@@ -474,6 +474,46 @@ public:
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
+    /// Execute a COPY transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available. 
+    /// 
+    /// @Note: The destination is passed through the HTTP pipe as a header
+    /// The header used is defined as: HTTP_OUT_HEADER_DESTINATION("Destination");
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD copyAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const std::string dest,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD copyAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const std::string & dest,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return copyAndYield(request, url, dest,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
+    /// Execute a MOVE transaction on the supplied URL and yield execution of 
+    /// the coroutine until a result is available. 
+    /// 
+    /// @Note: The destination is passed through the HTTP pipe in the headers.
+    /// The header used is defined as: HTTP_OUT_HEADER_DESTINATION("Destination");
+    /// 
+    /// @Note: the request's smart pointer is passed by value so that it will
+    /// not be deallocated during the yield.
+    LLSD moveAndYield(LLCore::HttpRequest::ptr_t request,
+        const std::string & url, const std::string dest,
+        LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
+        LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
+    LLSD moveAndYield(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, const std::string & dest,
+        LLCore::HttpHeaders::ptr_t &headers)
+    {
+        return moveAndYield(request, url, dest,
+            LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
+    }
+
     ///
     void cancelYieldingOperation();
 
@@ -541,6 +581,16 @@ private:
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
+    LLSD copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url, 
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
+    LLSD moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+        const std::string & url,
+        LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
+        HttpCoroHandler::ptr_t &handler);
+
     static void trivialGetCoro(std::string url, LLCore::HttpRequest::policy_t policyId, completionCallback_t success, completionCallback_t failure);
     static void trivialPostCoro(std::string url, LLCore::HttpRequest::policy_t policyId, LLSD postData, completionCallback_t success, completionCallback_t failure);
 
diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index 3565c04609..23ea692a16 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -37,11 +37,54 @@
 #include "llviewercontrol.h"
 
 ///----------------------------------------------------------------------------
-#if 1
+/// Classes for AISv3 support.
+///----------------------------------------------------------------------------
+
+//=========================================================================
+const std::string AISAPI::INVENTORY_CAP_NAME("InventoryAPIv3");
+const std::string AISAPI::LIBRARY_CAP_NAME("LibraryAPIv3");
+
+//-------------------------------------------------------------------------
+/*static*/
+bool AISAPI::isAvailable()
+{
+    if (gAgent.getRegion())
+    {
+        return gAgent.getRegion()->isCapabilityAvailable(INVENTORY_CAP_NAME);
+    }
+    return false;
+}
+
+/*static*/
+void AISAPI::getCapNames(LLSD& capNames)
+{
+    capNames.append(INVENTORY_CAP_NAME);
+    capNames.append(LIBRARY_CAP_NAME);
+}
+
+/*static*/
+std::string AISAPI::getInvCap()
+{
+    if (gAgent.getRegion())
+    {
+        return gAgent.getRegion()->getCapability(INVENTORY_CAP_NAME);
+    }
+    return std::string();
+}
+
+/*static*/
+std::string AISAPI::getLibCap()
+{
+    if (gAgent.getRegion())
+    {
+        return gAgent.getRegion()->getCapability(LIBRARY_CAP_NAME);
+    }
+    return std::string();
+}
+
 /*static*/ 
-void AISAPI::CreateInventoryCommand(const LLUUID& parentId, const LLSD& newInventory, completion_t callback)
+void AISAPI::CreateInventory(const LLUUID& parentId, const LLSD& newInventory, completion_t callback)
 {
-#if 1
     std::string cap = getInvCap();
     if (cap.empty())
     {
@@ -68,23 +111,22 @@ void AISAPI::CreateInventoryCommand(const LLUUID& parentId, const LLSD& newInven
         // Humans ignore next line.  It is just a cast.
         static_cast<LLSD (LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndYield), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, postFn, url, parentId, newInventory, callback));
-#else
-    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::CreateInventoryCommandCoro, 
-        _1, parentId, newInventory, callback));
-
-#endif
+        _1, postFn, url, parentId, newInventory, callback, COPYINVENTORY));
     EnqueueAISCommand("CreateInventory", proc);
-
 }
 
 /*static*/ 
-void AISAPI::SlamFolderCommand(const LLUUID& folderId, const LLSD& newInventory, completion_t callback)
+void AISAPI::SlamFolder(const LLUUID& folderId, const LLSD& newInventory, completion_t callback)
 {
-#if 1
     std::string cap = getInvCap();
     if (cap.empty())
     {
@@ -99,23 +141,24 @@ void AISAPI::SlamFolderCommand(const LLUUID& folderId, const LLSD& newInventory,
 
     // see comment above in CreateInventoryCommand
     invokationFn_t putFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndYield), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, putFn, url, folderId, newInventory, callback));
-
-#else
-    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::SlamFolderCommandCoro,
-        _1, folderId, newInventory, callback));
-#endif
+        _1, putFn, url, folderId, newInventory, callback, SLAMFOLDER));
 
     EnqueueAISCommand("SlamFolder", proc);
 }
 
-void AISAPI::RemoveCategoryCommand(const LLUUID &categoryId, completion_t callback)
+void AISAPI::RemoveCategory(const LLUUID &categoryId, completion_t callback)
 {
     std::string cap;
 
@@ -130,21 +173,26 @@ void AISAPI::RemoveCategoryCommand(const LLUUID &categoryId, completion_t callba
     LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
 
     invokationFn_t delFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, delFn, url, categoryId, LLSD(), callback));
+        _1, delFn, url, categoryId, LLSD(), callback, REMOVECATEGORY));
 
     EnqueueAISCommand("RemoveCategory", proc);
 }
 
 /*static*/ 
-void AISAPI::RemoveItemCommand(const LLUUID &itemId, completion_t callback)
+void AISAPI::RemoveItem(const LLUUID &itemId, completion_t callback)
 {
-#if 1
     std::string cap;
 
     cap = getInvCap();
@@ -158,25 +206,64 @@ void AISAPI::RemoveItemCommand(const LLUUID &itemId, completion_t callback)
     LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
 
     invokationFn_t delFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, delFn, url, itemId, LLSD(), callback));
-
-#else
-    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::RemoveItemCommandCoro,
-        _1, itemId, callback));
-#endif
+        _1, delFn, url, itemId, LLSD(), callback, REMOVEITEM));
 
     EnqueueAISCommand("RemoveItem", proc);
 }
 
+void AISAPI::CopyLibraryCategory(const LLUUID& sourceId, const LLUUID& destId, completion_t callback)
+{
+    std::string cap;
+
+    cap = getLibCap();
+    if (cap.empty())
+    {
+        LL_WARNS("Inventory") << "Library cap not found!" << LL_ENDL;
+        return;
+    }
+
+    LL_DEBUGS("Inventory") << "Copying library category: " << sourceId << " => " << destId << LL_ENDL;
+
+    LLUUID tid;
+    tid.generate();
+
+    std::string url = cap + std::string("/category/") + sourceId.asString() + "?tid=" + tid.asString();
+    LL_INFOS() << url << LL_ENDL;
+
+    std::string destination = destId.asString();
+
+    invokationFn_t copyFn = boost::bind(
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
+        static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const std::string, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
+        //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::copyAndYield), _1, _2, _3, destination, _5, _6);
+         
+    LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
+        _1, copyFn, url, destId, LLSD(), callback, COPYLIBRARYCATEGORY));
+
+    EnqueueAISCommand("CopyLibraryCategory", proc);
+}
 
 /*static*/ 
-void AISAPI::PurgeDescendentsCommand(const LLUUID &categoryId, completion_t callback)
+void AISAPI::PurgeDescendents(const LLUUID &categoryId, completion_t callback)
 {
     std::string cap;
 
@@ -191,20 +278,26 @@ void AISAPI::PurgeDescendentsCommand(const LLUUID &categoryId, completion_t call
     LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
 
     invokationFn_t delFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, delFn, url, categoryId, LLSD(), callback));
+        _1, delFn, url, categoryId, LLSD(), callback, PURGEDESCENDENTS));
 
     EnqueueAISCommand("PurgeDescendents", proc);
 }
 
 
 /*static*/
-void AISAPI::UpdateCategoryCommand(const LLUUID &categoryId, const LLSD &updates, completion_t callback)
+void AISAPI::UpdateCategory(const LLUUID &categoryId, const LLSD &updates, completion_t callback)
 {
     std::string cap;
 
@@ -217,19 +310,25 @@ void AISAPI::UpdateCategoryCommand(const LLUUID &categoryId, const LLSD &updates
     std::string url = cap + std::string("/category/") + categoryId.asString();
 
     invokationFn_t patchFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, patchFn, url, categoryId, updates, callback));
+        _1, patchFn, url, categoryId, updates, callback, UPDATECATEGORY));
 
     EnqueueAISCommand("UpdateCategory", proc);
 }
 
 /*static*/
-void AISAPI::UpdateItemCommand(const LLUUID &itemId, const LLSD &updates, completion_t callback)
+void AISAPI::UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t callback)
 {
 
     std::string cap;
@@ -243,13 +342,19 @@ void AISAPI::UpdateItemCommand(const LLUUID &itemId, const LLSD &updates, comple
     std::string url = cap + std::string("/item/") + itemId.asString();
 
     invokationFn_t patchFn = boost::bind(
-        // Humans ignore next line.  It is just a cast.
+        // Humans ignore next line.  It is just a cast to specify which LLCoreHttpUtil::HttpCoroutineAdapter routine overload.
         static_cast<LLSD(LLCoreHttpUtil::HttpCoroutineAdapter::*)(LLCore::HttpRequest::ptr_t, const std::string &, const LLSD &, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t)>
         //----
+        // _1 -> httpAdapter
+        // _2 -> httpRequest
+        // _3 -> url
+        // _4 -> body 
+        // _5 -> httpOptions
+        // _6 -> httpHeaders
         (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
-        _1, patchFn, url, itemId, updates, callback));
+        _1, patchFn, url, itemId, updates, callback, UPDATEITEM));
 
     EnqueueAISCommand("UpdateItem", proc);
 }
@@ -262,31 +367,10 @@ void AISAPI::EnqueueAISCommand(const std::string &procName, LLCoprocedureManager
 
 }
 
-/*static*/ 
-std::string AISAPI::getInvCap()
-{
-    if (gAgent.getRegion())
-    {
-        return gAgent.getRegion()->getCapability("InventoryAPIv3");
-    }
-
-    return std::string();
-}
-
-/*static*/ 
-std::string AISAPI::getLibCap()
-{
-    if (gAgent.getRegion())
-    {
-        return gAgent.getRegion()->getCapability("LibraryAPIv3");
-    }
-    return std::string();
-}
-
 /*static*/
 void AISAPI::InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, 
         invokationFn_t invoke, std::string url, 
-        LLUUID targetId, LLSD body, completion_t callback)
+        LLUUID targetId, LLSD body, completion_t callback, COMMAND_TYPE type)
 {
     LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
@@ -313,455 +397,20 @@ void AISAPI::InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t ht
     gInventory.onAISUpdateReceived("AISCommand", result);
 
     if (callback)
-    {   // UUID always null
-        callback(LLUUID::null);
-    }
-
-}
-
-#if 0
-/*static*/
-void AISAPI::CreateInventoryCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID parentId, LLSD newInventory, completion_t callback)
-{
-    std::string cap;
-    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
-    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
-
-    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
-
-    cap = getInvCap();
-    if (cap.empty())
-    {
-        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
-        return;
-    }
-
-    LLUUID tid;
-    tid.generate();
+    {   
+        LLUUID id(LLUUID::null);
 
-    std::string url = cap + std::string("/category/") + parentId.asString() + "?tid=" + tid.asString();
-    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
+        if (result.has("category_id") && (type == COPYLIBRARYCATEGORY))
+	    {
+		    id = result["category_id"];
+	    }
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, newInventory, httpOptions);
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
-    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-
-    if (!status || !result.isMap())
-    {
-        if (!result.isMap())
-        {
-            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
-        }
-        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
-        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
+        callback(id);
     }
 
-    gInventory.onAISUpdateReceived("AISCommand", result);
-
-    if (callback)
-    {   // UUID always null
-        callback(LLUUID::null);
-    }
-
-}
-
-/*static*/
-void AISAPI::SlamFolderCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID folderId, LLSD newInventory, completion_t callback)
-{
-    std::string cap;
-    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
-    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
-
-    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
-
-    cap = getInvCap();
-    if (cap.empty())
-    {
-        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
-        return;
-    }
-
-    LLUUID tid;
-    tid.generate();
-
-    std::string url = cap + std::string("/category/") + folderId.asString() + "/links?tid=" + tid.asString();
-
-    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-
-    LLSD result = httpAdapter->putAndYield(httpRequest, url, newInventory, httpOptions);
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
-    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-
-    if (!status || !result.isMap())
-    {
-        if (!result.isMap())
-        {
-            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
-        }
-        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
-        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
-    }
-
-    gInventory.onAISUpdateReceived("AISCommand", result);
-
-    if (callback)
-    {   // UUID always null
-        callback(LLUUID::null);
-    }
-
-}
-
-void AISAPI::RemoveItemCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID itemId, completion_t callback)
-{
-    std::string cap;
-    LLCore::HttpOptions::ptr_t httpOptions(new LLCore::HttpOptions);
-    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
-
-    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
-
-    cap = getInvCap();
-    if (cap.empty())
-    {
-        LL_WARNS("Inventory") << "Inventory cap not found!" << LL_ENDL;
-        return;
-    }
-
-    std::string url = cap + std::string("/item/") + itemId.asString();
-    LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-
-    LLSD result = httpAdapter->deleteAndYield(httpRequest, url, httpOptions);
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
-    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-
-    if (!status || !result.isMap())
-    {
-        if (!result.isMap())
-        {
-            status = LLCore::HttpStatus(HTTP_INTERNAL_ERROR, "Malformed response contents");
-        }
-        LL_WARNS("Inventory") << "Inventory error: " << status.toString() << LL_ENDL;
-        LL_WARNS("Inventory") << ll_pretty_print_sd(result) << LL_ENDL;
-    }
-
-    gInventory.onAISUpdateReceived("AISCommand", result);
-
-    if (callback)
-    {   // UUID always null
-        callback(LLUUID::null);
-    }
-}
-#endif
-#endif
-///----------------------------------------------------------------------------
-/// Classes for AISv3 support.
-///----------------------------------------------------------------------------
-
-// AISCommand - base class for retry-able HTTP requests using the AISv3 cap.
-AISCommand::AISCommand(LLPointer<LLInventoryCallback> callback):
-	mCommandFunc(NULL),
-	mCallback(callback)
-{
-	mRetryPolicy = new LLAdaptiveRetryPolicy(1.0, 32.0, 2.0, 10);
-}
-
-bool AISCommand::run_command()
-{
-	if (NULL == mCommandFunc)
-	{
-		// This may happen if a command failed to initiate itself.
-		LL_WARNS("Inventory") << "AIS command attempted with null command function" << LL_ENDL;
-		return false;
-	}
-	else
-	{
-		mCommandFunc();
-		return true;
-	}
-}
-
-void AISCommand::setCommandFunc(command_func_type command_func)
-{
-	mCommandFunc = command_func;
-}
-	
-// virtual
-bool AISCommand::getResponseUUID(const LLSD& content, LLUUID& id)
-{
-	return false;
-}
-	
-/* virtual */
-void AISCommand::httpSuccess()
-{
-	// Command func holds a reference to self, need to release it
-	// after a success or final failure.
-	setCommandFunc(no_op);
-		
-	const LLSD& content = getContent();
-	if (!content.isMap())
-	{
-		failureResult(HTTP_INTERNAL_ERROR, "Malformed response contents", content);
-		return;
-	}
-	mRetryPolicy->onSuccess();
-		
-	gInventory.onAISUpdateReceived("AISCommand", content);
-
-	if (mCallback)
-	{
-		LLUUID id; // will default to null if parse fails.
-		getResponseUUID(content,id);
-		mCallback->fire(id);
-	}
-}
-
-/*virtual*/
-void AISCommand::httpFailure()
-{
-	LL_WARNS("Inventory") << dumpResponse() << LL_ENDL;
-	S32 status = getStatus();
-	const LLSD& headers = getResponseHeaders();
-	mRetryPolicy->onFailure(status, headers);
-	F32 seconds_to_wait;
-	if (mRetryPolicy->shouldRetry(seconds_to_wait))
-	{
-		doAfterInterval(boost::bind(&AISCommand::run_command,this),seconds_to_wait);
-	}
-	else
-	{
-		// Command func holds a reference to self, need to release it
-		// after a success or final failure.
-		// *TODO: Notify user?  This seems bad.
-		setCommandFunc(no_op);
-	}
-}
-
-//static
-bool AISCommand::isAPIAvailable()
-{
-	if (gAgent.getRegion())
-	{
-		return gAgent.getRegion()->isCapabilityAvailable("InventoryAPIv3");
-	}
-	return false;
-}
-
-//static
-bool AISCommand::getInvCap(std::string& cap)
-{
-	if (gAgent.getRegion())
-	{
-		cap = gAgent.getRegion()->getCapability("InventoryAPIv3");
-	}
-	if (!cap.empty())
-	{
-		return true;
-	}
-	return false;
-}
-
-//static
-bool AISCommand::getLibCap(std::string& cap)
-{
-	if (gAgent.getRegion())
-	{
-		cap = gAgent.getRegion()->getCapability("LibraryAPIv3");
-	}
-	if (!cap.empty())
-	{
-		return true;
-	}
-	return false;
-}
-
-//static
-void AISCommand::getCapabilityNames(LLSD& capabilityNames)
-{
-	capabilityNames.append("InventoryAPIv3");
-	capabilityNames.append("LibraryAPIv3");
-}
-
-// RemoveItemCommand::RemoveItemCommand(const LLUUID& item_id,
-// 									 LLPointer<LLInventoryCallback> callback):
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	std::string url = cap + std::string("/item/") + item_id.asString();
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LLHTTPClient::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// RemoveCategoryCommand::RemoveCategoryCommand(const LLUUID& item_id,
-// 											 LLPointer<LLInventoryCallback> callback):
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	std::string url = cap + std::string("/category/") + item_id.asString();
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LLHTTPClient::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// PurgeDescendentsCommand::PurgeDescendentsCommand(const LLUUID& item_id,
-// 												 LLPointer<LLInventoryCallback> callback):
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	std::string url = cap + std::string("/category/") + item_id.asString() + "/children";
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LLCurl::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::del, url, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// UpdateItemCommand::UpdateItemCommand(const LLUUID& item_id,
-// 									 const LLSD& updates,
-// 									 LLPointer<LLInventoryCallback> callback):
-// 	mUpdates(updates),
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	std::string url = cap + std::string("/item/") + item_id.asString();
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LL_DEBUGS("Inventory") << "request: " << ll_pretty_print_sd(mUpdates) << LL_ENDL;
-// 	LLCurl::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	headers["Content-Type"] = "application/llsd+xml";
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// UpdateCategoryCommand::UpdateCategoryCommand(const LLUUID& cat_id,
-// 											 const LLSD& updates,
-// 											 LLPointer<LLInventoryCallback> callback):
-// 	mUpdates(updates),
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	std::string url = cap + std::string("/category/") + cat_id.asString();
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LLCurl::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	headers["Content-Type"] = "application/llsd+xml";
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::patch, url, mUpdates, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// CreateInventoryCommand::CreateInventoryCommand(const LLUUID& parent_id,
-// 							 				   const LLSD& new_inventory,
-// 							 				   LLPointer<LLInventoryCallback> callback):
-// 	mNewInventory(new_inventory),
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	LLUUID tid;
-// 	tid.generate();
-// 	std::string url = cap + std::string("/category/") + parent_id.asString() + "?tid=" + tid.asString();
-// 	LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
-// 	LLCurl::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	headers["Content-Type"] = "application/llsd+xml";
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::post, url, mNewInventory, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-// SlamFolderCommand::SlamFolderCommand(const LLUUID& folder_id, const LLSD& contents, LLPointer<LLInventoryCallback> callback):
-// 	mContents(contents),
-// 	AISCommand(callback)
-// {
-// 	std::string cap;
-// 	if (!getInvCap(cap))
-// 	{
-// 		LL_WARNS() << "No cap found" << LL_ENDL;
-// 		return;
-// 	}
-// 	LLUUID tid;
-// 	tid.generate();
-// 	std::string url = cap + std::string("/category/") + folder_id.asString() + "/links?tid=" + tid.asString();
-// 	LL_INFOS() << url << LL_ENDL;
-// 	LLCurl::ResponderPtr responder = this;
-// 	LLSD headers;
-// 	headers["Content-Type"] = "application/llsd+xml";
-// 	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-// 	command_func_type cmd = boost::bind(&LLHTTPClient::put, url, mContents, responder, headers, timeout);
-// 	setCommandFunc(cmd);
-// }
-
-CopyLibraryCategoryCommand::CopyLibraryCategoryCommand(const LLUUID& source_id,
-													   const LLUUID& dest_id,
-													   LLPointer<LLInventoryCallback> callback):
-	AISCommand(callback)
-{
-	std::string cap;
-	if (!getLibCap(cap))
-	{
-		LL_WARNS() << "No cap found" << LL_ENDL;
-		return;
-	}
-	LL_DEBUGS("Inventory") << "Copying library category: " << source_id << " => " << dest_id << LL_ENDL;
-	LLUUID tid;
-	tid.generate();
-	std::string url = cap + std::string("/category/") + source_id.asString() + "?tid=" + tid.asString();
-	LL_INFOS() << url << LL_ENDL;
-	LLCurl::ResponderPtr responder = this;
-	LLSD headers;
-	F32 timeout = HTTP_REQUEST_EXPIRY_SECS;
-	command_func_type cmd = boost::bind(&LLHTTPClient::copy, url, dest_id.asString(), responder, headers, timeout);
-	setCommandFunc(cmd);
-}
-
-bool CopyLibraryCategoryCommand::getResponseUUID(const LLSD& content, LLUUID& id)
-{
-	if (content.has("category_id"))
-	{
-		id = content["category_id"];
-		return true;
-	}
-	return false;
 }
 
+//-------------------------------------------------------------------------
 AISUpdate::AISUpdate(const LLSD& update)
 {
 	parseUpdate(update);
diff --git a/indra/newview/llaisapi.h b/indra/newview/llaisapi.h
index ebb952a3ec..fc2bedc9ec 100755
--- a/indra/newview/llaisapi.h
+++ b/indra/newview/llaisapi.h
@@ -38,21 +38,38 @@
 #include "llcorehttputil.h"
 #include "llcoproceduremanager.h"
 
-#if 1
 class AISAPI
 {
 public:
     typedef boost::function<void(const LLUUID &invItem)>    completion_t;
 
-    static void CreateInventoryCommand(const LLUUID& parentId, const LLSD& newInventory, completion_t callback);
-    static void SlamFolderCommand(const LLUUID& folderId, const LLSD& newInventory, completion_t callback);
-    static void RemoveCategoryCommand(const LLUUID &categoryId, completion_t callback);
-    static void RemoveItemCommand(const LLUUID &itemId, completion_t callback);
-    static void PurgeDescendentsCommand(const LLUUID &categoryId, completion_t callback);
-    static void UpdateCategoryCommand(const LLUUID &categoryId, const LLSD &updates, completion_t callback);
-    static void UpdateItemCommand(const LLUUID &itemId, const LLSD &updates, completion_t callback);
+    static bool isAvailable();
+    static void getCapNames(LLSD& capNames);
+
+    static void CreateInventory(const LLUUID& parentId, const LLSD& newInventory, completion_t callback);
+    static void SlamFolder(const LLUUID& folderId, const LLSD& newInventory, completion_t callback);
+    static void RemoveCategory(const LLUUID &categoryId, completion_t callback);
+    static void RemoveItem(const LLUUID &itemId, completion_t callback);
+    static void PurgeDescendents(const LLUUID &categoryId, completion_t callback);
+    static void UpdateCategory(const LLUUID &categoryId, const LLSD &updates, completion_t callback);
+    static void UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t callback);
+    static void CopyLibraryCategory(const LLUUID& sourceId, const LLUUID& destId, completion_t callback);
 
 private:
+    typedef enum {
+        COPYINVENTORY,
+        SLAMFOLDER,
+        REMOVECATEGORY,
+        REMOVEITEM,
+        PURGEDESCENDENTS,
+        UPDATECATEGORY,
+        UPDATEITEM,
+        COPYLIBRARYCATEGORY
+    } COMMAND_TYPE;
+
+    static const std::string INVENTORY_CAP_NAME;
+    static const std::string LIBRARY_CAP_NAME;
+
     typedef boost::function < LLSD (LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t, LLCore::HttpRequest::ptr_t,
         const std::string, LLSD, LLCore::HttpOptions::ptr_t, LLCore::HttpHeaders::ptr_t) > invokationFn_t;
 
@@ -61,118 +78,11 @@ private:
     static std::string getInvCap();
     static std::string getLibCap();
 
-    static void InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, invokationFn_t invoke, std::string url, LLUUID targetId, LLSD body, completion_t callback);
+    static void InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, 
+        invokationFn_t invoke, std::string url, LLUUID targetId, LLSD body, 
+        completion_t callback, COMMAND_TYPE type);
 
-#if 0
-    static void CreateInventoryCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t adapter, LLUUID parentId, LLSD newInventory, completion_t callback);
-    static void SlamFolderCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID folderId, LLSD newInventory, completion_t callback);
-    static void RemoveItemCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t httpAdapter, LLUUID itemId, completion_t callback);
-#endif
 };
-#endif 
-
-class AISCommand: public LLHTTPClient::Responder
-{
-public:
-	typedef boost::function<void()> command_func_type;
-
-	AISCommand(LLPointer<LLInventoryCallback> callback);
-
-	virtual ~AISCommand() {}
-
-	bool run_command();
-
-	void setCommandFunc(command_func_type command_func);
-	
-	// Need to do command-specific parsing to get an id here, for
-	// LLInventoryCallback::fire().  May or may not need to bother,
-	// since most LLInventoryCallbacks do their work in the
-	// destructor.
-	
-	/* virtual */ void httpSuccess();
-	/* virtual */ void httpFailure();
-
-	static bool isAPIAvailable();
-	static bool getInvCap(std::string& cap);
-	static bool getLibCap(std::string& cap);
-	static void getCapabilityNames(LLSD& capabilityNames);
-
-protected:
-	virtual bool getResponseUUID(const LLSD& content, LLUUID& id);
-
-private:
-	command_func_type mCommandFunc;
-	LLPointer<LLHTTPRetryPolicy> mRetryPolicy;
-	LLPointer<LLInventoryCallback> mCallback;
-};
-
-// class RemoveItemCommand: public AISCommand
-// {
-// public:
-// 	RemoveItemCommand(const LLUUID& item_id,
-// 					  LLPointer<LLInventoryCallback> callback);
-// };
-
-// class RemoveCategoryCommand: public AISCommand
-// {
-// public:
-// 	RemoveCategoryCommand(const LLUUID& item_id,
-// 						  LLPointer<LLInventoryCallback> callback);
-// };
-
-// class PurgeDescendentsCommand: public AISCommand
-// {
-// public:
-// 	PurgeDescendentsCommand(const LLUUID& item_id,
-// 							LLPointer<LLInventoryCallback> callback);
-// };
-
-// class UpdateItemCommand: public AISCommand
-// {
-// public:
-// 	UpdateItemCommand(const LLUUID& item_id,
-// 					  const LLSD& updates,
-// 					  LLPointer<LLInventoryCallback> callback);
-// private:
-// 	LLSD mUpdates;
-// };
-
-// class UpdateCategoryCommand: public AISCommand
-// {
-// public:
-// 	UpdateCategoryCommand(const LLUUID& cat_id,
-// 						  const LLSD& updates,
-// 						  LLPointer<LLInventoryCallback> callback);
-// private:
-// 	LLSD mUpdates;
-// };
-
-// class SlamFolderCommand: public AISCommand
-// {
-// public:
-// 	SlamFolderCommand(const LLUUID& folder_id, const LLSD& contents, LLPointer<LLInventoryCallback> callback);
-// 	
-// private:
-// 	LLSD mContents;
-// };
-
-class CopyLibraryCategoryCommand: public AISCommand
-{
-public:
-	CopyLibraryCategoryCommand(const LLUUID& source_id, const LLUUID& dest_id, LLPointer<LLInventoryCallback> callback);
-
-protected:
-	/* virtual */ bool getResponseUUID(const LLSD& content, LLUUID& id);
-};
-
-// class CreateInventoryCommand: public AISCommand
-// {
-// public:
-// 	CreateInventoryCommand(const LLUUID& parent_id, const LLSD& new_inventory, LLPointer<LLInventoryCallback> callback);
-// 
-// private:
-// 	LLSD mNewInventory;
-// };
 
 class AISUpdate
 {
diff --git a/indra/newview/llappearancemgr.cpp b/indra/newview/llappearancemgr.cpp
index ff420a3600..2883886fa1 100755
--- a/indra/newview/llappearancemgr.cpp
+++ b/indra/newview/llappearancemgr.cpp
@@ -63,6 +63,17 @@
 #pragma warning (disable:4702)
 #endif
 
+#if 1
+// *TODO$: LLInventoryCallback should be deprecated to conform to the new boost::bind/coroutine model.
+// temp code in transition
+void doAppearanceCb(LLPointer<LLInventoryCallback> cb, LLUUID id)
+{
+    if (cb.notNull())
+        cb->fire(id);
+}
+#endif
+
+
 std::string self_av_string()
 {
 	// On logout gAgentAvatarp can already be invalid
@@ -2457,8 +2468,7 @@ void LLAppearanceMgr::wearInventoryCategory(LLInventoryCategory* category, bool
 			 << " )" << LL_ENDL;
 
 	// If we are copying from library, attempt to use AIS to copy the category.
-	bool ais_ran=false;
-	if (copy && AISCommand::isAPIAvailable())
+    if (copy && AISAPI::isAvailable())
 	{
 		LLUUID parent_id;
 		parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
@@ -2470,11 +2480,11 @@ void LLAppearanceMgr::wearInventoryCategory(LLInventoryCategory* category, bool
 		LLPointer<LLInventoryCallback> copy_cb = new LLWearCategoryAfterCopy(append);
 		LLPointer<LLInventoryCallback> track_cb = new LLTrackPhaseWrapper(
 													std::string("wear_inventory_category_callback"), copy_cb);
-		LLPointer<AISCommand> cmd_ptr = new CopyLibraryCategoryCommand(category->getUUID(), parent_id, track_cb);
-		ais_ran=cmd_ptr->run_command();
-	}
 
-	if (!ais_ran)
+        AISAPI::completion_t cr = boost::bind(&doAppearanceCb, track_cb, _1);
+        AISAPI::CopyLibraryCategory(category->getUUID(), parent_id, cr);
+	}
+    else
 	{
 		selfStartPhase("wear_inventory_category_fetch");
 		callAfterCategoryFetch(category->getUUID(),boost::bind(&LLAppearanceMgr::wearCategoryFinal,
@@ -3602,7 +3612,7 @@ void LLAppearanceMgr::makeNewOutfitLinks(const std::string& new_folder_name, boo
 
 	// First, make a folder in the My Outfits directory.
 	const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
-	if (AISCommand::isAPIAvailable())
+    if (AISAPI::isAvailable())
 	{
 		// cap-based category creation was buggy until recently. use
 		// existence of AIS as an indicator the fix is present. Does
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index 729af3c8ed..ac19d84a5e 100755
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -80,6 +80,7 @@ static const char * const LOG_LOCAL("InventoryLocalize");
 static const char * const LOG_NOTECARD("copy_inventory_from_notecard");
 
 #if 1
+// *TODO$: LLInventoryCallback should be deprecated to conform to the new boost::bind/coroutine model.
 // temp code in transition
 void doInventoryCb(LLPointer<LLInventoryCallback> cb, LLUUID id)
 {
@@ -1289,21 +1290,14 @@ void link_inventory_array(const LLUUID& category,
 #endif
 	}
 
-	bool ais_ran = false;
-	if (AISCommand::isAPIAvailable())
+    if (AISAPI::isAvailable())
 	{
 		LLSD new_inventory = LLSD::emptyMap();
 		new_inventory["links"] = links;
-#if 1
         AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-        AISAPI::CreateInventoryCommand(category, new_inventory, cr);
-#else
- 		LLPointer<AISCommand> cmd_ptr = new CreateInventoryCommand(category, new_inventory, cb);
- 		ais_ran = cmd_ptr->run_command();
-#endif
+        AISAPI::CreateInventory(category, new_inventory, cr);
 	}
-
-	if (!ais_ran)
+    else
 	{
 		LLMessageSystem* msg = gMessageSystem;
 		for (LLSD::array_iterator iter = links.beginArray(); iter != links.endArray(); ++iter )
@@ -1360,8 +1354,7 @@ void update_inventory_item(
 	LLPointer<LLInventoryCallback> cb)
 {
 	const LLUUID& item_id = update_item->getUUID();
-	bool ais_ran = false;
-	if (AISCommand::isAPIAvailable())
+    if (AISAPI::isAvailable())
 	{
 		LLSD updates = update_item->asLLSD();
 		// Replace asset_id and/or shadow_id with transaction_id (hash_id)
@@ -1375,15 +1368,10 @@ void update_inventory_item(
 			updates.erase("shadow_id");
 			updates["hash_id"] = update_item->getTransactionID();
 		}
-#if 1
         AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-        AISAPI::UpdateItemCommand(item_id, updates, cr);
-#else
-		LLPointer<AISCommand> cmd_ptr = new UpdateItemCommand(item_id, updates, cb);
-		ais_ran = cmd_ptr->run_command();
-#endif
+        AISAPI::UpdateItem(item_id, updates, cr);
 	}
-	if (!ais_ran)
+    else
 	{
 		LLPointer<LLViewerInventoryItem> obj = gInventory.getItem(item_id);
 		LL_DEBUGS(LOG_INV) << "item_id: [" << item_id << "] name " << (update_item ? update_item->getName() : "(NOT FOUND)") << LL_ENDL;
@@ -1419,18 +1407,12 @@ void update_inventory_item(
 	const LLSD& updates,
 	LLPointer<LLInventoryCallback> cb)
 {
-	bool ais_ran = false;
-	if (AISCommand::isAPIAvailable())
+    if (AISAPI::isAvailable())
 	{
-#if 1
         AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-        AISAPI::UpdateItemCommand(item_id, updates, cr);
-#else
-		LLPointer<AISCommand> cmd_ptr = new UpdateItemCommand(item_id, updates, cb);
-		ais_ran = cmd_ptr->run_command();
-#endif
+        AISAPI::UpdateItem(item_id, updates, cr);
 	}
-	if (!ais_ran)
+    else
 	{
 		LLPointer<LLViewerInventoryItem> obj = gInventory.getItem(item_id);
 		LL_DEBUGS(LOG_INV) << "item_id: [" << item_id << "] name " << (obj ? obj->getName() : "(NOT FOUND)") << LL_ENDL;
@@ -1480,16 +1462,11 @@ void update_inventory_category(
 		LLPointer<LLViewerInventoryCategory> new_cat = new LLViewerInventoryCategory(obj);
 		new_cat->fromLLSD(updates);
 		// FIXME - restore this once the back-end work has been done.
-		if (AISCommand::isAPIAvailable())
+        if (AISAPI::isAvailable())
 		{
 			LLSD new_llsd = new_cat->asLLSD();
-#if 1
             AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-            AISAPI::UpdateCategoryCommand(cat_id, new_llsd, cr);
-#else
-			LLPointer<AISCommand> cmd_ptr = new UpdateCategoryCommand(cat_id, new_llsd, cb);
-			cmd_ptr->run_command();
-#endif
+            AISAPI::UpdateCategory(cat_id, new_llsd, cr);
 		}
 		else // no cap
 		{
@@ -1551,15 +1528,10 @@ void remove_inventory_item(
 	{
 		const LLUUID item_id(obj->getUUID());
 		LL_DEBUGS(LOG_INV) << "item_id: [" << item_id << "] name " << obj->getName() << LL_ENDL;
-		if (AISCommand::isAPIAvailable())
+        if (AISAPI::isAvailable())
 		{
-#if 1
             AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-            AISAPI::RemoveItemCommand(item_id, cr);
-#else
-			LLPointer<AISCommand> cmd_ptr = new RemoveItemCommand(item_id, cb);
-			cmd_ptr->run_command();
-#endif
+            AISAPI::RemoveItem(item_id, cr);
 
 			if (immediate_delete)
 			{
@@ -1632,15 +1604,10 @@ void remove_inventory_category(
 			LLNotificationsUtil::add("CannotRemoveProtectedCategories");
 			return;
 		}
-		if (AISCommand::isAPIAvailable())
+        if (AISAPI::isAvailable())
 		{
-#if 1
             AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-            AISAPI::RemoveCategoryCommand(cat_id, cr);
-#else
-			LLPointer<AISCommand> cmd_ptr = new RemoveCategoryCommand(cat_id, cb);
-			cmd_ptr->run_command();
-#endif
+            AISAPI::RemoveCategory(cat_id, cr);
 		}
 		else // no cap
 		{
@@ -1740,15 +1707,10 @@ void purge_descendents_of(const LLUUID& id, LLPointer<LLInventoryCallback> cb)
 		}
 		else
 		{
-			if (AISCommand::isAPIAvailable())
+            if (AISAPI::isAvailable())
 			{
-#if 1
                 AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-                AISAPI::PurgeDescendentsCommand(id, cr);
-#else
-                LLPointer<AISCommand> cmd_ptr = new PurgeDescendentsCommand(id, cb);
-				cmd_ptr->run_command();
-#endif
+                AISAPI::PurgeDescendents(id, cr);
 			}
 			else // no cap
 			{
@@ -1895,17 +1857,13 @@ void slam_inventory_folder(const LLUUID& folder_id,
 						   const LLSD& contents,
 						   LLPointer<LLInventoryCallback> cb)
 {
-	if (AISCommand::isAPIAvailable())
+    if (AISAPI::isAvailable())
 	{
 		LL_DEBUGS(LOG_INV) << "using AISv3 to slam folder, id " << folder_id
 						   << " new contents: " << ll_pretty_print_sd(contents) << LL_ENDL;
-#if 1
+
         AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
-        AISAPI::SlamFolderCommand(folder_id, contents, cr);
-#else
-		LLPointer<AISCommand> cmd_ptr = new SlamFolderCommand(folder_id, contents, cb);
-		cmd_ptr->run_command();
-#endif
+        AISAPI::SlamFolder(folder_id, contents, cr);
 	}
 	else // no cap
 	{
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 5c7071c63d..32b57dae25 100755
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -2822,7 +2822,7 @@ void LLViewerRegionImpl::buildCapabilityNames(LLSD& capabilityNames)
 	capabilityNames.append("FetchInventory2");
 	capabilityNames.append("FetchInventoryDescendents2");
 	capabilityNames.append("IncrementCOFVersion");
-	AISCommand::getCapabilityNames(capabilityNames);
+	AISAPI::getCapNames(capabilityNames);
 
 	capabilityNames.append("GetDisplayNames");
 	capabilityNames.append("GetExperiences");
-- 
cgit v1.3


From 02c3262ac8e7f27b0effb546ad235e103c9581cf Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 28 Aug 2015 10:05:15 -0700
Subject: MAINT-5574: Added default parameter for callbalk on AISAPI interface.
 Better check on callback exsit in coroutine Don't create AISAPI::completion_t
 if there is no call back passed.

---
 indra/newview/llaisapi.cpp          |  2 +-
 indra/newview/llaisapi.h            | 16 ++++++++--------
 indra/newview/llviewerinventory.cpp | 16 ++++++++--------
 3 files changed, 17 insertions(+), 17 deletions(-)

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index 5d2c48a1b4..da2f69126a 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -400,7 +400,7 @@ void AISAPI::InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t ht
 
     gInventory.onAISUpdateReceived("AISCommand", result);
 
-    if (callback)
+    if (callback && !callback.empty())
     {   
         LLUUID id(LLUUID::null);
 
diff --git a/indra/newview/llaisapi.h b/indra/newview/llaisapi.h
index cc6bda3c7f..2de8003c2f 100755
--- a/indra/newview/llaisapi.h
+++ b/indra/newview/llaisapi.h
@@ -46,14 +46,14 @@ public:
     static bool isAvailable();
     static void getCapNames(LLSD& capNames);
 
-    static void CreateInventory(const LLUUID& parentId, const LLSD& newInventory, completion_t callback);
-    static void SlamFolder(const LLUUID& folderId, const LLSD& newInventory, completion_t callback);
-    static void RemoveCategory(const LLUUID &categoryId, completion_t callback);
-    static void RemoveItem(const LLUUID &itemId, completion_t callback);
-    static void PurgeDescendents(const LLUUID &categoryId, completion_t callback);
-    static void UpdateCategory(const LLUUID &categoryId, const LLSD &updates, completion_t callback);
-    static void UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t callback);
-    static void CopyLibraryCategory(const LLUUID& sourceId, const LLUUID& destId, bool copySubfolders, completion_t callback);
+    static void CreateInventory(const LLUUID& parentId, const LLSD& newInventory, completion_t callback = completion_t());
+    static void SlamFolder(const LLUUID& folderId, const LLSD& newInventory, completion_t callback = completion_t());
+    static void RemoveCategory(const LLUUID &categoryId, completion_t callback = completion_t());
+    static void RemoveItem(const LLUUID &itemId, completion_t callback = completion_t());
+    static void PurgeDescendents(const LLUUID &categoryId, completion_t callback = completion_t());
+    static void UpdateCategory(const LLUUID &categoryId, const LLSD &updates, completion_t callback = completion_t());
+    static void UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t callback = completion_t());
+    static void CopyLibraryCategory(const LLUUID& sourceId, const LLUUID& destId, bool copySubfolders, completion_t callback = completion_t());
 
 private:
     typedef enum {
diff --git a/indra/newview/llviewerinventory.cpp b/indra/newview/llviewerinventory.cpp
index ac19d84a5e..573791aca3 100755
--- a/indra/newview/llviewerinventory.cpp
+++ b/indra/newview/llviewerinventory.cpp
@@ -1294,7 +1294,7 @@ void link_inventory_array(const LLUUID& category,
 	{
 		LLSD new_inventory = LLSD::emptyMap();
 		new_inventory["links"] = links;
-        AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+        AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
         AISAPI::CreateInventory(category, new_inventory, cr);
 	}
     else
@@ -1368,7 +1368,7 @@ void update_inventory_item(
 			updates.erase("shadow_id");
 			updates["hash_id"] = update_item->getTransactionID();
 		}
-        AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+        AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
         AISAPI::UpdateItem(item_id, updates, cr);
 	}
     else
@@ -1409,7 +1409,7 @@ void update_inventory_item(
 {
     if (AISAPI::isAvailable())
 	{
-        AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+        AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
         AISAPI::UpdateItem(item_id, updates, cr);
 	}
     else
@@ -1465,7 +1465,7 @@ void update_inventory_category(
         if (AISAPI::isAvailable())
 		{
 			LLSD new_llsd = new_cat->asLLSD();
-            AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+            AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
             AISAPI::UpdateCategory(cat_id, new_llsd, cr);
 		}
 		else // no cap
@@ -1530,7 +1530,7 @@ void remove_inventory_item(
 		LL_DEBUGS(LOG_INV) << "item_id: [" << item_id << "] name " << obj->getName() << LL_ENDL;
         if (AISAPI::isAvailable())
 		{
-            AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+            AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
             AISAPI::RemoveItem(item_id, cr);
 
 			if (immediate_delete)
@@ -1606,7 +1606,7 @@ void remove_inventory_category(
 		}
         if (AISAPI::isAvailable())
 		{
-            AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+            AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
             AISAPI::RemoveCategory(cat_id, cr);
 		}
 		else // no cap
@@ -1709,7 +1709,7 @@ void purge_descendents_of(const LLUUID& id, LLPointer<LLInventoryCallback> cb)
 		{
             if (AISAPI::isAvailable())
 			{
-                AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+                AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
                 AISAPI::PurgeDescendents(id, cr);
 			}
 			else // no cap
@@ -1862,7 +1862,7 @@ void slam_inventory_folder(const LLUUID& folder_id,
 		LL_DEBUGS(LOG_INV) << "using AISv3 to slam folder, id " << folder_id
 						   << " new contents: " << ll_pretty_print_sd(contents) << LL_ENDL;
 
-        AISAPI::completion_t cr = boost::bind(&doInventoryCb, cb, _1);
+        AISAPI::completion_t cr = (cb) ? boost::bind(&doInventoryCb, cb, _1) : AISAPI::completion_t();
         AISAPI::SlamFolder(folder_id, contents, cr);
 	}
 	else // no cap
-- 
cgit v1.3


From 97236a42ca08979897d5c7b0826312345754cd67 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 14 Sep 2015 11:15:23 -0700
Subject: MAINT-5507: Remove HTTPClient and related cruft.

---
 indra/llmessage/CMakeLists.txt               |   3 -
 indra/llmessage/llcorehttputil.cpp           |   4 +
 indra/llmessage/llcorehttputil.h             |   1 +
 indra/llmessage/llexperiencecache.cpp        |   1 -
 indra/llmessage/llhttpclient.cpp             | 677 ---------------------------
 indra/llmessage/llhttpclient.h               | 201 --------
 indra/llmessage/llhttpclientinterface.h      |  45 --
 indra/llmessage/message.cpp                  |   1 -
 indra/newview/CMakeLists.txt                 |   7 -
 indra/newview/llaisapi.cpp                   |   2 +-
 indra/newview/llaisapi.h                     |   1 -
 indra/newview/llappviewer.cpp                |   3 -
 indra/newview/lleventpoll.h                  |   1 -
 indra/newview/llfloaterexperienceprofile.cpp |   1 -
 indra/newview/llfloaterexperiences.cpp       |   1 -
 indra/newview/llgroupmgr.cpp                 |   1 -
 indra/newview/llmarketplacefunctions.cpp     |   1 -
 indra/newview/llmeshrepository.h             |   1 +
 indra/newview/llpanelexperiencepicker.cpp    |   1 -
 indra/newview/llpanelgroupexperiences.cpp    |   1 -
 indra/newview/llsecapi.cpp                   |  41 --
 indra/newview/llsecapi.h                     |   3 -
 indra/newview/llsidepanelinventory.cpp       |   1 -
 indra/newview/llstartup.cpp                  |   1 -
 indra/newview/lltranslate.cpp                |  22 -
 indra/newview/lltranslate.h                  |   2 -
 indra/newview/lluploadfloaterobservers.h     |   1 -
 indra/newview/llviewermenufile.cpp           |   1 -
 indra/newview/llviewerregion.cpp             |   1 -
 indra/newview/tests/lltranslate_test.cpp     | 340 --------------
 30 files changed, 7 insertions(+), 1360 deletions(-)
 delete mode 100755 indra/llmessage/llhttpclient.cpp
 delete mode 100755 indra/llmessage/llhttpclient.h
 delete mode 100755 indra/llmessage/llhttpclientinterface.h
 delete mode 100755 indra/newview/tests/lltranslate_test.cpp

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/llmessage/CMakeLists.txt b/indra/llmessage/CMakeLists.txt
index 41b618f8c3..aa00faf3f7 100755
--- a/indra/llmessage/CMakeLists.txt
+++ b/indra/llmessage/CMakeLists.txt
@@ -48,7 +48,6 @@ set(llmessage_SOURCE_FILES
     llexperiencecache.cpp
     llfiltersd2xmlrpc.cpp
     llhost.cpp
-    llhttpclient.cpp
     llhttpconstants.cpp
     llhttpnode.cpp
     llhttpsdhandler.cpp
@@ -140,8 +139,6 @@ set(llmessage_HEADER_FILES
     llfiltersd2xmlrpc.h
     llfollowcamparams.h
     llhost.h
-    llhttpclient.h
-    llhttpclientinterface.h
     llhttpconstants.h
     llhttpnode.h
     llhttpnodeadapter.h
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 4c2e2c5ee7..106df15bf1 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -46,6 +46,10 @@ using namespace LLCore;
 
 namespace LLCoreHttpUtil
 {
+
+const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
+
+
 void logMessageSuccess(std::string logAuth, std::string url, std::string message)
 {
     LL_INFOS() << logAuth << " Success '" << message << "' for " << url << LL_ENDL;
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 6599a4f01a..94800b1a5b 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -57,6 +57,7 @@
 ///
 namespace LLCoreHttpUtil
 {
+    extern const F32 HTTP_REQUEST_EXPIRY_SECS;
 
 /// Attempt to convert a response object's contents to LLSD.
 /// It is expected that the response body will be of non-zero
diff --git a/indra/llmessage/llexperiencecache.cpp b/indra/llmessage/llexperiencecache.cpp
index 0fd6836948..ff5f7e793d 100644
--- a/indra/llmessage/llexperiencecache.cpp
+++ b/indra/llmessage/llexperiencecache.cpp
@@ -26,7 +26,6 @@
 #include "llexperiencecache.h"
 
 #include "llavatarname.h"
-#include "llhttpclient.h"
 #include "llsdserialize.h"
 #include "llcoros.h"
 #include "lleventcoro.h"
diff --git a/indra/llmessage/llhttpclient.cpp b/indra/llmessage/llhttpclient.cpp
deleted file mode 100755
index b149d24c4b..0000000000
--- a/indra/llmessage/llhttpclient.cpp
+++ /dev/null
@@ -1,677 +0,0 @@
-/** 
- * @file llhttpclient.cpp
- * @brief Implementation of classes for making HTTP requests.
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-#include <openssl/x509_vfy.h>
-#include "llhttpclient.h"
-
-#include "llassetstorage.h"
-#include "lliopipe.h"
-#include "llurlrequest.h"
-#include "llbufferstream.h"
-#include "llsdserialize.h"
-#include "llvfile.h"
-#include "llvfs.h"
-#include "lluri.h"
-
-#include "message.h"
-#include "httpcommon.h"
-#include "httprequest.h"
-#include "httpoptions.h"
-
-#include <curl/curl.h>
-
-
-const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
-LLURLRequest::SSLCertVerifyCallback LLHTTPClient::mCertVerifyCallback = NULL;
-
-////////////////////////////////////////////////////////////////////////////
-
-// Responder class moved to LLCurl
-
-namespace
-{
-	class LLHTTPClientURLAdaptor : public LLURLRequestComplete
-	{
-	public:
-		LLHTTPClientURLAdaptor(LLCurl::ResponderPtr responder)
-			: LLURLRequestComplete(), mResponder(responder), mStatus(HTTP_INTERNAL_ERROR),
-			  mReason("LLURLRequest complete w/no status")
-		{
-		}
-		
-		~LLHTTPClientURLAdaptor()
-		{
-		}
-
-		virtual void httpStatus(S32 status, const std::string& reason)
-		{
-			LLURLRequestComplete::httpStatus(status,reason);
-
-			mStatus = status;
-			mReason = reason;
-		}
-
-		virtual void complete(const LLChannelDescriptors& channels,
-							  const buffer_ptr_t& buffer)
-		{
-			// *TODO: Re-interpret mRequestStatus codes?
-			//        Would like to detect curl errors, such as
-			//        connection errors, write erros, etc.
-			if (mResponder.get())
-			{
-				mResponder->setResult(mStatus, mReason);
-				mResponder->completedRaw(channels, buffer);
-			}
-		}
-		virtual void header(const std::string& header, const std::string& value)
-		{
-			if (mResponder.get())
-			{
-				mResponder->setResponseHeader(header, value);
-			}
-		}
-
-	private:
-		LLCurl::ResponderPtr mResponder;
-		S32 mStatus;
-		std::string mReason;
-	};
-	
-	class Injector : public LLIOPipe
-	{
-	public:
-		virtual const std::string& contentType() = 0;
-	};
-
-	class LLSDInjector : public Injector
-	{
-	public:
-		LLSDInjector(const LLSD& sd) : mSD(sd) {}
-		virtual ~LLSDInjector() {}
-
-		const std::string& contentType() { return HTTP_CONTENT_LLSD_XML; }
-
-		virtual EStatus process_impl(const LLChannelDescriptors& channels,
-			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
-		{
-			LLBufferStream ostream(channels, buffer.get());
-			LLSDSerialize::toXML(mSD, ostream);
-			eos = true;
-			return STATUS_DONE;
-		}
-
-		const LLSD mSD;
-	};
-
-	class RawInjector : public Injector
-	{
-	public:
-		RawInjector(const U8* data, S32 size) : mData(data), mSize(size) {}
-		virtual ~RawInjector() {delete [] mData;}
-
-		const std::string& contentType() { return HTTP_CONTENT_OCTET_STREAM; }
-
-		virtual EStatus process_impl(const LLChannelDescriptors& channels,
-			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
-		{
-			LLBufferStream ostream(channels, buffer.get());
-			ostream.write((const char *)mData, mSize);  // hopefully chars are always U8s
-			eos = true;
-			return STATUS_DONE;
-		}
-
-		const U8* mData;
-		S32 mSize;
-	};
-	
-	class FileInjector : public Injector
-	{
-	public:
-		FileInjector(const std::string& filename) : mFilename(filename) {}
-		virtual ~FileInjector() {}
-
-		const std::string& contentType() { return HTTP_CONTENT_OCTET_STREAM; }
-
-		virtual EStatus process_impl(const LLChannelDescriptors& channels,
-			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
-		{
-			LLBufferStream ostream(channels, buffer.get());
-
-			llifstream fstream(mFilename.c_str(), std::iostream::binary | std::iostream::out);
-			if(fstream.is_open())
-			{
-				fstream.seekg(0, std::ios::end);
-				U32 fileSize = (U32)fstream.tellg();
-				fstream.seekg(0, std::ios::beg);
-				std::vector<char> fileBuffer(fileSize);
-				fstream.read(&fileBuffer[0], fileSize);
-				ostream.write(&fileBuffer[0], fileSize);
-				fstream.close();
-				eos = true;
-				return STATUS_DONE;
-			}
-			
-			return STATUS_ERROR;
-		}
-
-		const std::string mFilename;
-	};
-	
-	class VFileInjector : public Injector
-	{
-	public:
-		VFileInjector(const LLUUID& uuid, LLAssetType::EType asset_type) : mUUID(uuid), mAssetType(asset_type) {}
-		virtual ~VFileInjector() {}
-
-		const std::string& contentType() { return HTTP_CONTENT_OCTET_STREAM; }
-
-		virtual EStatus process_impl(const LLChannelDescriptors& channels,
-			buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
-		{
-			LLBufferStream ostream(channels, buffer.get());
-			
-			LLVFile vfile(gVFS, mUUID, mAssetType, LLVFile::READ);
-			S32 fileSize = vfile.getSize();
-			U8* fileBuffer;
-			fileBuffer = new U8 [fileSize];
-            vfile.read(fileBuffer, fileSize);
-            ostream.write((char*)fileBuffer, fileSize);
-			delete [] fileBuffer;
-			eos = true;
-			return STATUS_DONE;
-		}
-
-		const LLUUID mUUID;
-		LLAssetType::EType mAssetType;
-	};
-
-	
-	LLPumpIO* theClientPump = NULL;
-}
-
-void LLHTTPClient::setCertVerifyCallback(LLURLRequest::SSLCertVerifyCallback callback)
-{
-	LLHTTPClient::mCertVerifyCallback = callback;
-}
-
-static void request(
-	const std::string& url,
-	EHTTPMethod method,
-	Injector* body_injector,
-	LLCurl::ResponderPtr responder,
-	const F32 timeout = HTTP_REQUEST_EXPIRY_SECS,
-	const LLSD& headers = LLSD(),
-	bool follow_redirects = true
-    )
-{
-	if (!LLHTTPClient::hasPump())
-	{
-		if (responder)
-		{
-			responder->completeResult(HTTP_INTERNAL_ERROR, "No pump");
-		}
-		delete body_injector;
-		return;
-	}
-	LLPumpIO::chain_t chain;
-
-	LLURLRequest* req = new LLURLRequest(method, url, follow_redirects);
-	if(!req->isValid())//failed
-	{
-		if (responder)
-		{
-			responder->completeResult(HTTP_INTERNAL_CURL_ERROR, "Internal Error - curl failure");
-		}
-		delete req;
-		delete body_injector;
-		return;
-	}
-
-	req->setSSLVerifyCallback(LLHTTPClient::getCertVerifyCallback(), (void *)req);
-
-	LL_DEBUGS("LLHTTPClient") << httpMethodAsVerb(method) << " " << url << " " << headers << LL_ENDL;
-
-	// Insert custom headers if the caller sent any
-	if (headers.isMap())
-	{
-		if (headers.has(HTTP_OUT_HEADER_COOKIE))
-		{
-			req->allowCookies();
-		}
-
-		LLSD::map_const_iterator iter = headers.beginMap();
-		LLSD::map_const_iterator end  = headers.endMap();
-
-		for (; iter != end; ++iter)
-		{
-			//if the header is "Pragma" with no value
-			//the caller intends to force libcurl to drop
-			//the Pragma header it so gratuitously inserts
-			//Before inserting the header, force libcurl
-			//to not use the proxy (read: llurlrequest.cpp)
-			if ((iter->first == HTTP_OUT_HEADER_PRAGMA) && (iter->second.asString().empty()))
-			{
-				req->useProxy(false);
-			}
-			LL_DEBUGS("LLHTTPClient") << "header = " << iter->first 
-				<< ": " << iter->second.asString() << LL_ENDL;
-			req->addHeader(iter->first, iter->second.asString());
-		}
-	}
-
-	// Check to see if we have already set Accept or not. If no one
-	// set it, set it to application/llsd+xml since that's what we
-	// almost always want.
-	if( method != HTTP_PUT && method != HTTP_POST )
-	{
-		if(!headers.has(HTTP_OUT_HEADER_ACCEPT))
-		{
-			req->addHeader(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_LLSD_XML);
-		}
-	}
-
-	if (responder)
-	{
-		responder->setURL(url);
-		responder->setHTTPMethod(method);
-	}
-
-	req->setCallback(new LLHTTPClientURLAdaptor(responder));
-
-	if (method == HTTP_POST  &&  gMessageSystem)
-	{
-		req->addHeader("X-SecondLife-UDP-Listen-Port", llformat("%d",
-					gMessageSystem->mPort));
-	}
-
-	if (method == HTTP_PUT || method == HTTP_POST || method == HTTP_PATCH)
-	{
-		if(!headers.has(HTTP_OUT_HEADER_CONTENT_TYPE))
-		{
-			// If the Content-Type header was passed in, it has
-			// already been added as a header through req->addHeader
-			// in the loop above. We defer to the caller's wisdom, but
-			// if they did not specify a Content-Type, then ask the
-			// injector.
-			req->addHeader(HTTP_OUT_HEADER_CONTENT_TYPE, body_injector->contentType());
-		}
-		chain.push_back(LLIOPipe::ptr_t(body_injector));
-	}
-
-	chain.push_back(LLIOPipe::ptr_t(req));
-
-	theClientPump->addChain(chain, timeout);
-}
-
-
-void LLHTTPClient::getByteRange(
-	const std::string& url,
-	S32 offset,
-	S32 bytes,
-	ResponderPtr responder,
-	const LLSD& hdrs,
-	const F32 timeout,
-	bool follow_redirects /* = true */)
-{
-	LLSD headers = hdrs;
-	if(offset > 0 || bytes > 0)
-	{
-		std::string range = llformat("bytes=%d-%d", offset, offset+bytes-1);
-		headers[HTTP_OUT_HEADER_RANGE] = range;
-	}
-    request(url,HTTP_GET, NULL, responder, timeout, headers, follow_redirects);
-}
-
-void LLHTTPClient::head(
-	const std::string& url,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout,
-	bool follow_redirects /* = true */)
-{
-	request(url, HTTP_HEAD, NULL, responder, timeout, headers, follow_redirects);
-}
-
-void LLHTTPClient::get(const std::string& url, ResponderPtr responder, const LLSD& headers, const F32 timeout,
-					   bool follow_redirects /* = true */)
-{
-	request(url, HTTP_GET, NULL, responder, timeout, headers, follow_redirects);
-}
-void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder, const LLSD& headers,
-								 const F32 timeout, bool follow_redirects /* = true */)
-{
-	request(url, HTTP_HEAD, NULL, responder, timeout, headers, follow_redirects);
-}
-void LLHTTPClient::getHeaderOnly(const std::string& url, ResponderPtr responder, const F32 timeout,
-								 bool follow_redirects /* = true */)
-{
-	getHeaderOnly(url, responder, LLSD(), timeout, follow_redirects);
-}
-
-void LLHTTPClient::get(const std::string& url, const LLSD& query, ResponderPtr responder, const LLSD& headers,
-					   const F32 timeout, bool follow_redirects /* = true */)
-{
-	LLURI uri;
-	
-	uri = LLURI::buildHTTP(url, LLSD::emptyArray(), query);
-	get(uri.asString(), responder, headers, timeout, follow_redirects);
-}
-
-// A simple class for managing data returned from a curl http request.
-class LLHTTPBuffer
-{
-public:
-	LLHTTPBuffer() { }
-
-	static size_t curl_write( void *ptr, size_t size, size_t nmemb, void *user_data)
-	{
-		LLHTTPBuffer* self = (LLHTTPBuffer*)user_data;
-		
-		size_t bytes = (size * nmemb);
-		self->mBuffer.append((char*)ptr,bytes);
-		return nmemb;
-	}
-
-	LLSD asLLSD()
-	{
-		LLSD content;
-
-		if (mBuffer.empty()) return content;
-		
-		std::istringstream istr(mBuffer);
-		LLSDSerialize::fromXML(content, istr);
-		return content;
-	}
-
-	const std::string& asString()
-	{
-		return mBuffer;
-	}
-
-private:
-	std::string mBuffer;
-};
-
-// These calls are blocking! This is usually bad, unless you're a dataserver. Then it's awesome.
-
-/**
-	@brief does a blocking request on the url, returning the data or bad status.
-
-	@param url URI to verb on.
-	@param method the verb to hit the URI with.
-	@param body the body of the call (if needed - for instance not used for GET and DELETE, but is for POST and PUT)
-	@param headers HTTP headers to use for the request.
-	@param timeout Curl timeout to use. Defaults to 5. Rationale:
-	Without this timeout, blockingGet() calls have been observed to take
-	up to 90 seconds to complete.  Users of blockingGet() already must 
-	check the HTTP return code for validity, so this will not introduce
-	new errors.  A 5 second timeout will succeed > 95% of the time (and 
-	probably > 99% of the time) based on my statistics. JC
-
-	@returns an LLSD map: {status: integer, body: map}
-  */
-static LLSD blocking_request(
-	const std::string& url,
-	EHTTPMethod method,
-	const LLSD& body,
-	const LLSD& headers = LLSD(),
-	const F32 timeout = 5
-)
-{
-	LL_DEBUGS() << "blockingRequest of " << url << LL_ENDL;
-	char curl_error_buffer[CURL_ERROR_SIZE] = "\0";
-	CURL* curlp = LLCurl::newEasyHandle();
-	llassert_always(curlp != NULL) ;
-
-	LLHTTPBuffer http_buffer;
-	std::string body_str;
-	
-	// other request method checks root cert first, we skip?
-
-	// Apply configured proxy settings
-	LLProxy::getInstance()->applyProxySettings(curlp);
-	
-	// * Set curl handle options
-	curl_easy_setopt(curlp, CURLOPT_NOSIGNAL, 1);	// don't use SIGALRM for timeouts
-	curl_easy_setopt(curlp, CURLOPT_TIMEOUT, timeout);	// seconds, see warning at top of function.
-	curl_easy_setopt(curlp, CURLOPT_WRITEFUNCTION, LLHTTPBuffer::curl_write);
-	curl_easy_setopt(curlp, CURLOPT_WRITEDATA, &http_buffer);
-	curl_easy_setopt(curlp, CURLOPT_URL, url.c_str());
-	curl_easy_setopt(curlp, CURLOPT_ERRORBUFFER, curl_error_buffer);
-
-	// * Setup headers (don't forget to free them after the call!)
-	curl_slist* headers_list = NULL;
-	if (headers.isMap())
-	{
-		LLSD::map_const_iterator iter = headers.beginMap();
-		LLSD::map_const_iterator end  = headers.endMap();
-		for (; iter != end; ++iter)
-		{
-			std::ostringstream header;
-			header << iter->first << ": " << iter->second.asString() ;
-			LL_DEBUGS() << "header = " << header.str() << LL_ENDL;
-			headers_list = curl_slist_append(headers_list, header.str().c_str());
-		}
-	}
-	
-	// * Setup specific method / "verb" for the URI (currently only GET and POST supported + poppy)
-	if (method == HTTP_GET)
-	{
-		curl_easy_setopt(curlp, CURLOPT_HTTPGET, 1);
-	}
-	else if (method == HTTP_POST)
-	{
-		curl_easy_setopt(curlp, CURLOPT_POST, 1);
-		//serialize to ostr then copy to str - need to because ostr ptr is unstable :(
-		std::ostringstream ostr;
-		LLSDSerialize::toXML(body, ostr);
-		body_str = ostr.str();
-		curl_easy_setopt(curlp, CURLOPT_POSTFIELDS, body_str.c_str());
-		//copied from PHP libs, correct?
-		headers_list = curl_slist_append(headers_list, 
-				llformat("%s: %s", HTTP_OUT_HEADER_CONTENT_TYPE.c_str(), HTTP_CONTENT_LLSD_XML.c_str()).c_str());
-
-		// copied from llurlrequest.cpp
-		// it appears that apache2.2.3 or django in etch is busted. If
-		// we do not clear the expect header, we get a 500. May be
-		// limited to django/mod_wsgi.
-		headers_list = curl_slist_append(headers_list, llformat("%s:", HTTP_OUT_HEADER_EXPECT.c_str()).c_str());
-	}
-	
-	// * Do the action using curl, handle results
-	LL_DEBUGS() << "HTTP body: " << body_str << LL_ENDL;
-	headers_list = curl_slist_append(headers_list,
-				llformat("%s: %s", HTTP_OUT_HEADER_ACCEPT.c_str(), HTTP_CONTENT_LLSD_XML.c_str()).c_str());
-	CURLcode curl_result = curl_easy_setopt(curlp, CURLOPT_HTTPHEADER, headers_list);
-	if ( curl_result != CURLE_OK )
-	{
-		LL_INFOS() << "Curl is hosed - can't add headers" << LL_ENDL;
-	}
-
-	LLSD response = LLSD::emptyMap();
-	S32 curl_success = curl_easy_perform(curlp);
-	S32 http_status = HTTP_INTERNAL_ERROR;
-	curl_easy_getinfo(curlp, CURLINFO_RESPONSE_CODE, &http_status);
-	response["status"] = http_status;
-	// if we get a non-404 and it's not a 200 OR maybe it is but you have error bits,
-	if ( http_status != HTTP_NOT_FOUND && (http_status != HTTP_OK || curl_success != 0) )
-	{
-		// We expect 404s, don't spam for them.
-		LL_WARNS() << "CURL REQ URL: " << url << LL_ENDL;
-		LL_WARNS() << "CURL REQ METHOD TYPE: " << method << LL_ENDL;
-		LL_WARNS() << "CURL REQ HEADERS: " << headers.asString() << LL_ENDL;
-		LL_WARNS() << "CURL REQ BODY: " << body_str << LL_ENDL;
-		LL_WARNS() << "CURL HTTP_STATUS: " << http_status << LL_ENDL;
-		LL_WARNS() << "CURL ERROR: " << curl_error_buffer << LL_ENDL;
-		LL_WARNS() << "CURL ERROR BODY: " << http_buffer.asString() << LL_ENDL;
-		response["body"] = http_buffer.asString();
-	}
-	else
-	{
-		response["body"] = http_buffer.asLLSD();
-		LL_DEBUGS() << "CURL response: " << http_buffer.asString() << LL_ENDL;
-	}
-	
-	if(headers_list)
-	{	// free the header list  
-		curl_slist_free_all(headers_list); 
-	}
-
-	// * Cleanup
-	LLCurl::deleteEasyHandle(curlp);
-	return response;
-}
-
-LLSD LLHTTPClient::blockingGet(const std::string& url)
-{
-	return blocking_request(url, HTTP_GET, LLSD());
-}
-
-LLSD LLHTTPClient::blockingPost(const std::string& url, const LLSD& body)
-{
-	return blocking_request(url, HTTP_POST, body);
-}
-
-void LLHTTPClient::put(
-	const std::string& url,
-	const LLSD& body,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_PUT, new LLSDInjector(body), responder, timeout, headers);
-}
-
-void LLHTTPClient::patch(
-	const std::string& url,
-	const LLSD& body,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_PATCH, new LLSDInjector(body), responder, timeout, headers);
-}
-
-void LLHTTPClient::putRaw(
-    const std::string& url,
-    const U8* data,
-    S32 size,
-    ResponderPtr responder,
-    const LLSD& headers,
-    const F32 timeout)
-{
-	request(url, HTTP_PUT, new RawInjector(data, size), responder, timeout, headers);
-}
-
-void LLHTTPClient::post(
-	const std::string& url,
-	const LLSD& body,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_POST, new LLSDInjector(body), responder, timeout, headers);
-}
-
-void LLHTTPClient::postRaw(
-	const std::string& url,
-	const U8* data,
-	S32 size,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_POST, new RawInjector(data, size), responder, timeout, headers);
-}
-
-void LLHTTPClient::postFile(
-	const std::string& url,
-	const std::string& filename,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_POST, new FileInjector(filename), responder, timeout, headers);
-}
-
-void LLHTTPClient::postFile(
-	const std::string& url,
-	const LLUUID& uuid,
-	LLAssetType::EType asset_type,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_POST, new VFileInjector(uuid, asset_type), responder, timeout, headers);
-}
-
-// static
-void LLHTTPClient::del(
-	const std::string& url,
-	ResponderPtr responder,
-	const LLSD& headers,
-	const F32 timeout)
-{
-	request(url, HTTP_DELETE, NULL, responder, timeout, headers);
-}
-
-// static
-void LLHTTPClient::move(
-	const std::string& url,
-	const std::string& destination,
-	ResponderPtr responder,
-	const LLSD& hdrs,
-	const F32 timeout)
-{
-	LLSD headers = hdrs;
-	headers[HTTP_OUT_HEADER_DESTINATION] = destination;
-	request(url, HTTP_MOVE, NULL, responder, timeout, headers);
-}
-
-// static
-void LLHTTPClient::copy(
-	const std::string& url,
-	const std::string& destination,
-	ResponderPtr responder,
-	const LLSD& hdrs,
-	const F32 timeout)
-{
-	LLSD headers = hdrs;
-	headers[HTTP_OUT_HEADER_DESTINATION] = destination;
-	request(url, HTTP_COPY, NULL, responder, timeout, headers);
-}
-
-
-void LLHTTPClient::setPump(LLPumpIO& pump)
-{
-	theClientPump = &pump;
-}
-
-bool LLHTTPClient::hasPump()
-{
-	return theClientPump != NULL;
-}
diff --git a/indra/llmessage/llhttpclient.h b/indra/llmessage/llhttpclient.h
deleted file mode 100755
index fd48b4a743..0000000000
--- a/indra/llmessage/llhttpclient.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/** 
- * @file llhttpclient.h
- * @brief Declaration of classes for making HTTP client requests.
- *
- * $LicenseInfo:firstyear=2006&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLHTTPCLIENT_H
-#define LL_LLHTTPCLIENT_H
-
-/**
- * These classes represent the HTTP client framework.
- */
-
-#include <string>
-
-#include <boost/intrusive_ptr.hpp>
-#include <openssl/x509_vfy.h>
-#include "llurlrequest.h"
-#include "llassettype.h"
-#include "llcurl.h"
-#include "lliopipe.h"
-
-extern const F32 HTTP_REQUEST_EXPIRY_SECS;
-
-class LLUUID;
-class LLPumpIO;
-class LLSD;
-
-
-class LLHTTPClient
-{
-public:
-	// class Responder moved to LLCurl
-
-	// For convenience
-	typedef LLCurl::Responder Responder;
-	typedef LLCurl::ResponderPtr ResponderPtr;
-
-	
-	/** @name non-blocking API */
-	//@{
-	static void head(
-		const std::string& url,
-		ResponderPtr,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS,
-		bool follow_redirects = true);
-	static void getByteRange(const std::string& url, S32 offset, S32 bytes, ResponderPtr,
-							 const LLSD& headers=LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS,
-							 bool follow_redirects = true);
-	static void get(const std::string& url, ResponderPtr, const LLSD& headers = LLSD(),
-					const F32 timeout=HTTP_REQUEST_EXPIRY_SECS, bool follow_redirects = true);
-	static void get(const std::string& url, const LLSD& query, ResponderPtr, const LLSD& headers = LLSD(),
-					const F32 timeout=HTTP_REQUEST_EXPIRY_SECS, bool follow_redirects = true);
-
-	static void put(
-		const std::string& url,
-		const LLSD& body,
-		ResponderPtr,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void putRaw(
-        const std::string& url,
-        const U8* data,
-        S32 size,
-        ResponderPtr responder,
-        const LLSD& headers = LLSD(),
-        const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-    
-
-	static void patch(
-		const std::string& url,
-		const LLSD& body,
-		ResponderPtr,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-
-	static void getHeaderOnly(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS,
-							  bool follow_redirects = true);
-	static void getHeaderOnly(const std::string& url, ResponderPtr, const LLSD& headers,
-							  const F32 timeout=HTTP_REQUEST_EXPIRY_SECS, bool follow_redirects = true);
-
-	static void post(
-		const std::string& url,
-		const LLSD& body,
-		ResponderPtr,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	/** Takes ownership of data and deletes it when sent */
-	static void postRaw(
-		const std::string& url,
-		const U8* data,
-		S32 size,
-		ResponderPtr responder,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void postFile(
-		const std::string& url,
-		const std::string& filename,
-		ResponderPtr,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-	static void postFile(
-		const std::string& url,
-		const LLUUID& uuid,
-		LLAssetType::EType asset_type,
-		ResponderPtr responder,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-
-	static void del(
-		const std::string& url,
-		ResponderPtr responder,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-		///< sends a DELETE method, but we can't call it delete in c++
-
-	/**
-	 * @brief Send a MOVE webdav method
-	 *
-	 * @param url The complete serialized (and escaped) url to get.
-	 * @param destination The complete serialized destination url.
-	 * @param responder The responder that will handle the result.
-	 * @param headers A map of key:value headers to pass to the request
-	 * @param timeout The number of seconds to give the server to respond.
-	 */
-	static void move(
-		const std::string& url,
-		const std::string& destination,
-		ResponderPtr responder,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-
-	/**
-	 * @brief Send a COPY webdav method
-	 *
-	 * @param url The complete serialized (and escaped) url to get.
-	 * @param destination The complete serialized destination url.
-	 * @param responder The responder that will handle the result.
-	 * @param headers A map of key:value headers to pass to the request
-	 * @param timeout The number of seconds to give the server to respond.
-	 */
-	static void copy(
-		const std::string& url,
-		const std::string& destination,
-		ResponderPtr responder,
-		const LLSD& headers = LLSD(),
-		const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-
-	//@}
-
-	/**
-	 * @brief Blocking HTTP get that returns an LLSD map of status and body.
-	 *
-	 * @param url the complete serialized (and escaped) url to get
-	 * @return An LLSD of { 'status':status, 'body':payload }
-	 */
-	static LLSD blockingGet(const std::string& url);
-
-	/**
-	 * @brief Blocking HTTP POST that returns an LLSD map of status and body.
-	 *
-	 * @param url the complete serialized (and escaped) url to get
-	 * @param body the LLSD post body
-	 * @return An LLSD of { 'status':status (an int), 'body':payload (an LLSD) }
-	 */
-	static LLSD blockingPost(const std::string& url, const LLSD& body);
-
-	
-	static void setPump(LLPumpIO& pump);
-		///< must be called before any of the above calls are made
-	static bool hasPump();
-
-	static void setCertVerifyCallback(LLURLRequest::SSLCertVerifyCallback callback);
-	static  LLURLRequest::SSLCertVerifyCallback getCertVerifyCallback() { return mCertVerifyCallback; }
-
-protected:
-	static LLURLRequest::SSLCertVerifyCallback mCertVerifyCallback;
-};
-
-#endif // LL_LLHTTPCLIENT_H
diff --git a/indra/llmessage/llhttpclientinterface.h b/indra/llmessage/llhttpclientinterface.h
deleted file mode 100755
index 9c1c8e7c11..0000000000
--- a/indra/llmessage/llhttpclientinterface.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/** 
- * @file llhttpclientinterface.h
- * @brief 
- *
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLHTTPCLIENTINTERFACE_H
-#define LL_LLHTTPCLIENTINTERFACE_H
-
-#include "linden_common.h"
-#include "llcurl.h"
-
-#include <string>
-
-// class LLHTTPClientInterface
-// {
-// public:
-// 	virtual ~LLHTTPClientInterface() {}
-// 	virtual void get(const std::string& url, LLCurl::ResponderPtr responder) = 0;
-// 	virtual void get(const std::string& url, LLCurl::ResponderPtr responder, const LLSD& headers) = 0;
-// 	virtual void put(const std::string& url, const LLSD& body, LLCurl::ResponderPtr responder) = 0;
-// };
-
-#endif // LL_LLHTTPCLIENTINTERFACE_H
-
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index 10dbbef046..4f9aa5d2de 100755
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -50,7 +50,6 @@
 #include "lldir.h"
 #include "llerror.h"
 #include "llfasttimer.h"
-#include "llhttpclient.h"
 #include "llhttpnodeadapter.h"
 #include "llmd5.h"
 #include "llmessagebuilder.h"
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 7eb4174b7f..af51c6dc36 100755
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -2224,7 +2224,6 @@ if (LL_TESTS)
 #    llmediadataclient.cpp
     lllogininstance.cpp
 #    llremoteparcelrequest.cpp
-#    lltranslate.cpp
     llviewerhelputil.cpp
     llversioninfo.cpp
     llworldmap.cpp
@@ -2245,12 +2244,6 @@ if (LL_TESTS)
     ${CURL_LIBRARIES}
     )
 
-#  set_source_files_properties(
-#    lltranslate.cpp
-#    PROPERTIES
-#    LL_TEST_ADDITIONAL_LIBRARIES "${test_libs}"
-#  )
-
   set_source_files_properties(
     llmediadataclient.cpp
     PROPERTIES
diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index da2f69126a..2d877f6a47 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -380,7 +380,7 @@ void AISAPI::InvokeAISCommandCoro(LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t ht
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest());
     LLCore::HttpHeaders::ptr_t httpHeaders;
 
-    httpOptions->setTimeout(HTTP_REQUEST_EXPIRY_SECS);
+    httpOptions->setTimeout(LLCoreHttpUtil::HTTP_REQUEST_EXPIRY_SECS);
 
     LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
 
diff --git a/indra/newview/llaisapi.h b/indra/newview/llaisapi.h
index 2de8003c2f..48c081991a 100755
--- a/indra/newview/llaisapi.h
+++ b/indra/newview/llaisapi.h
@@ -32,7 +32,6 @@
 #include <set>
 #include <string>
 #include "llcurl.h"
-#include "llhttpclient.h"
 #include "llhttpretrypolicy.h"
 #include "llviewerinventory.h"
 #include "llcorehttputil.h"
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index e13a9d96c7..16dac4a9e5 100755
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -1160,8 +1160,6 @@ bool LLAppViewer::init()
 	{
 	  LLNotificationsUtil::add("CorruptedProtectedDataStore");
 	}
-	LLHTTPClient::setCertVerifyCallback(secapiSSLCertVerifyCallback);
-
 
 	gGLActive = FALSE;
 
@@ -1315,7 +1313,6 @@ bool LLAppViewer::mainLoop()
 		
 		// Create IO Pump to use for HTTP Requests.
 		gServicePump = new LLPumpIO(gAPRPoolp);
-		LLHTTPClient::setPump(*gServicePump);
 		LLCurl::setCAFile(gDirUtilp->getCAFile());
 		
 		// Note: this is where gLocalSpeakerMgr and gActiveSpeakerMgr used to be instantiated.
diff --git a/indra/newview/lleventpoll.h b/indra/newview/lleventpoll.h
index e32b4ed322..e2afd9226b 100755
--- a/indra/newview/lleventpoll.h
+++ b/indra/newview/lleventpoll.h
@@ -27,7 +27,6 @@
 #ifndef LL_LLEVENTPOLL_H
 #define LL_LLEVENTPOLL_H
 
-#include "llhttpclient.h"
 #include "boost/move/unique_ptr.hpp"
 
 namespace boost
diff --git a/indra/newview/llfloaterexperienceprofile.cpp b/indra/newview/llfloaterexperienceprofile.cpp
index dd1c6dce0a..d44eb4310d 100644
--- a/indra/newview/llfloaterexperienceprofile.cpp
+++ b/indra/newview/llfloaterexperienceprofile.cpp
@@ -36,7 +36,6 @@
 #include "llexpandabletextbox.h"
 #include "llexperiencecache.h"
 #include "llfloaterreg.h"
-#include "llhttpclient.h"
 #include "lllayoutstack.h"
 #include "lllineeditor.h"
 #include "llnotificationsutil.h"
diff --git a/indra/newview/llfloaterexperiences.cpp b/indra/newview/llfloaterexperiences.cpp
index 14fbdb3a8f..bdab9ed868 100644
--- a/indra/newview/llfloaterexperiences.cpp
+++ b/indra/newview/llfloaterexperiences.cpp
@@ -32,7 +32,6 @@
 #include "llevents.h"
 #include "llexperiencecache.h"
 #include "llfloaterregioninfo.h"
-#include "llhttpclient.h"
 #include "llnotificationsutil.h"
 #include "llpanelexperiencelog.h"
 #include "llpanelexperiencepicker.h"
diff --git a/indra/newview/llgroupmgr.cpp b/indra/newview/llgroupmgr.cpp
index eda9e51d23..b218f4f756 100755
--- a/indra/newview/llgroupmgr.cpp
+++ b/indra/newview/llgroupmgr.cpp
@@ -41,7 +41,6 @@
 #include "llui.h"
 #include "message.h"
 #include "roles_constants.h"
-#include "llhttpclient.h"
 #include "lltransactiontypes.h"
 #include "llstatusbar.h"
 #include "lleconomy.h"
diff --git a/indra/newview/llmarketplacefunctions.cpp b/indra/newview/llmarketplacefunctions.cpp
index cff8446545..b0cd1dd23e 100755
--- a/indra/newview/llmarketplacefunctions.cpp
+++ b/indra/newview/llmarketplacefunctions.cpp
@@ -30,7 +30,6 @@
 
 #include "llagent.h"
 #include "llbufferstream.h"
-#include "llhttpclient.h"
 #include "llinventoryfunctions.h"
 #include "llinventoryobserver.h"
 #include "llnotificationsutil.h"
diff --git a/indra/newview/llmeshrepository.h b/indra/newview/llmeshrepository.h
index 55157cc040..ed20641312 100755
--- a/indra/newview/llmeshrepository.h
+++ b/indra/newview/llmeshrepository.h
@@ -38,6 +38,7 @@
 #include "httpoptions.h"
 #include "httpheaders.h"
 #include "httphandler.h"
+#include "llthread.h"
 
 #define LLCONVEXDECOMPINTER_STATIC 1
 
diff --git a/indra/newview/llpanelexperiencepicker.cpp b/indra/newview/llpanelexperiencepicker.cpp
index d71ced443b..dcc5f4f234 100644
--- a/indra/newview/llpanelexperiencepicker.cpp
+++ b/indra/newview/llpanelexperiencepicker.cpp
@@ -42,7 +42,6 @@
 #include "llviewercontrol.h"
 #include "llfloater.h"
 #include "lltrans.h"
-#include "llhttpclient.h"  // *TODO: Rider, remove when converting
 
 #define BTN_FIND		"find"
 #define BTN_OK			"ok_btn"
diff --git a/indra/newview/llpanelgroupexperiences.cpp b/indra/newview/llpanelgroupexperiences.cpp
index 9b4c67a120..a88a55ab22 100644
--- a/indra/newview/llpanelgroupexperiences.cpp
+++ b/indra/newview/llpanelgroupexperiences.cpp
@@ -31,7 +31,6 @@
 #include "lluictrlfactory.h"
 #include "roles_constants.h"
 
-#include "llhttpclient.h"
 #include "llagent.h"
 #include "llviewerregion.h"
 #include "llflatlistview.h"
diff --git a/indra/newview/llsecapi.cpp b/indra/newview/llsecapi.cpp
index 43bb7b1596..4f9f83b6f2 100755
--- a/indra/newview/llsecapi.cpp
+++ b/indra/newview/llsecapi.cpp
@@ -32,7 +32,6 @@
 #include <openssl/evp.h>
 #include <openssl/err.h>
 #include <map>
-#include "llhttpclient.h"
 
 
 
@@ -99,46 +98,6 @@ std::ostream& operator <<(std::ostream& s, const LLCredential& cred)
 	return s << (std::string)cred;
 }
 
-	
-// secapiSSLCertVerifyCallback
-// basic callback called when a cert verification is requested.
-// calls SECAPI to validate the context
-// not initialized in the above initialization function, due to unit tests
-// see llappviewer
-
-int secapiSSLCertVerifyCallback(X509_STORE_CTX *ctx, void *param)
-{
-	LLURLRequest *req = (LLURLRequest *)param;
-	LLPointer<LLCertificateStore> store = gSecAPIHandler->getCertificateStore("");
-	LLPointer<LLCertificateChain> chain = gSecAPIHandler->getCertificateChain(ctx);
-	LLSD validation_params = LLSD::emptyMap();
-	LLURI uri(req->getURL());
-	validation_params[CERT_HOSTNAME] = uri.hostName();
-	try
-	{
-		// we rely on libcurl to validate the hostname, as libcurl does more extensive validation
-		// leaving our hostname validation call mechanism for future additions with respect to
-		// OS native (Mac keyring, windows CAPI) validation.
-		store->validate(VALIDATION_POLICY_SSL & (~VALIDATION_POLICY_HOSTNAME), chain, validation_params);
-	}
-	catch (LLCertValidationTrustException& cert_exception)
-	{
-		LL_WARNS("AppInit") << "Cert not trusted: " << cert_exception.getMessage() << LL_ENDL;
-		return 0;		
-	}
-	catch (LLCertException& cert_exception)
-	{
-		LL_WARNS("AppInit") << "cert error " << cert_exception.getMessage() << LL_ENDL;
-		return 0;
-	}
-	catch (...)
-	{
-		LL_WARNS("AppInit") << "cert error " << LL_ENDL;
-		return 0;
-	}
-	return 1;
-}
-
 LLSD LLCredential::getLoginParams()
 {
 	LLSD result = LLSD::emptyMap();
diff --git a/indra/newview/llsecapi.h b/indra/newview/llsecapi.h
index c01d318f56..6fe3ee31cf 100755
--- a/indra/newview/llsecapi.h
+++ b/indra/newview/llsecapi.h
@@ -489,7 +489,4 @@ void registerSecHandler(const std::string& handler_type,
 extern LLPointer<LLSecAPIHandler> gSecAPIHandler;
 
 
-int secapiSSLCertVerifyCallback(X509_STORE_CTX *ctx, void *param);
-
-
 #endif // LL_SECAPI_H
diff --git a/indra/newview/llsidepanelinventory.cpp b/indra/newview/llsidepanelinventory.cpp
index 0e23e2ad10..67ac875428 100755
--- a/indra/newview/llsidepanelinventory.cpp
+++ b/indra/newview/llsidepanelinventory.cpp
@@ -37,7 +37,6 @@
 #include "llfloatersidepanelcontainer.h"
 #include "llfoldertype.h"
 #include "llfolderview.h"
-#include "llhttpclient.h"
 #include "llinventorybridge.h"
 #include "llinventoryfunctions.h"
 #include "llinventorymodel.h"
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 4246f72202..047e23cefc 100755
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -112,7 +112,6 @@
 #include "llgroupmgr.h"
 #include "llhudeffecttrail.h"
 #include "llhudmanager.h"
-#include "llhttpclient.h"
 #include "llimagebmp.h"
 #include "llinventorybridge.h"
 #include "llinventorymodel.h"
diff --git a/indra/newview/lltranslate.cpp b/indra/newview/lltranslate.cpp
index 1ca2011a70..5390573f7b 100755
--- a/indra/newview/lltranslate.cpp
+++ b/indra/newview/lltranslate.cpp
@@ -574,25 +574,3 @@ LLTranslationAPIHandler& LLTranslate::getHandler(EService service)
 
 	return bing;
 }
-
-// static
-void LLTranslate::sendRequest(const std::string& url, LLHTTPClient::ResponderPtr responder)
-{
-	static const float REQUEST_TIMEOUT = 5;
-	static LLSD sHeader;
-
-	if (!sHeader.size())
-	{
-	    std::string user_agent = llformat("%s %d.%d.%d (%d)",
-			LLVersionInfo::getChannel().c_str(),
-			LLVersionInfo::getMajor(),
-			LLVersionInfo::getMinor(),
-			LLVersionInfo::getPatch(),
-			LLVersionInfo::getBuild());
-
-		sHeader.insert(HTTP_OUT_HEADER_ACCEPT, HTTP_CONTENT_TEXT_PLAIN);
-		sHeader.insert(HTTP_OUT_HEADER_USER_AGENT, user_agent);
-	}
-
-	LLHTTPClient::get(url, responder, sHeader, REQUEST_TIMEOUT);
-}
diff --git a/indra/newview/lltranslate.h b/indra/newview/lltranslate.h
index 49a0105dbb..bf431cdfbb 100755
--- a/indra/newview/lltranslate.h
+++ b/indra/newview/lltranslate.h
@@ -27,7 +27,6 @@
 #ifndef LL_LLTRANSLATE_H
 #define LL_LLTRANSLATE_H
 
-#include "llhttpclient.h"
 #include "llbufferstream.h"
 #include <boost/function.hpp>
 
@@ -95,7 +94,6 @@ public :
 private:
 	static LLTranslationAPIHandler& getPreferredHandler();
 	static LLTranslationAPIHandler& getHandler(EService service);
-	static void sendRequest(const std::string& url, LLHTTPClient::ResponderPtr responder);
 };
 
 #endif
diff --git a/indra/newview/lluploadfloaterobservers.h b/indra/newview/lluploadfloaterobservers.h
index 02baf8f1c0..15c3dad38e 100755
--- a/indra/newview/lluploadfloaterobservers.h
+++ b/indra/newview/lluploadfloaterobservers.h
@@ -28,7 +28,6 @@
 #define LL_LLUPLOADFLOATEROBSERVERS_H
 
 #include "llfloater.h"
-#include "llhttpclient.h"
 #include "llhandle.h"
 
 class LLUploadPermissionsObserver
diff --git a/indra/newview/llviewermenufile.cpp b/indra/newview/llviewermenufile.cpp
index 782a27a846..4f24dfafac 100755
--- a/indra/newview/llviewermenufile.cpp
+++ b/indra/newview/llviewermenufile.cpp
@@ -66,7 +66,6 @@
 
 // linden libraries
 #include "lleconomy.h"
-#include "llhttpclient.h"
 #include "llnotificationsutil.h"
 #include "llsdserialize.h"
 #include "llsdutil.h"
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 57548b6e8f..4ed90d26b7 100755
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -34,7 +34,6 @@
 #include "llavatarnamecache.h"		// name lookup cap url
 #include "llfloaterreg.h"
 #include "llmath.h"
-#include "llhttpclient.h"
 #include "llregionflags.h"
 #include "llregionhandle.h"
 #include "llsurface.h"
diff --git a/indra/newview/tests/lltranslate_test.cpp b/indra/newview/tests/lltranslate_test.cpp
deleted file mode 100755
index 5e73dbb981..0000000000
--- a/indra/newview/tests/lltranslate_test.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-/** 
- * @file lltranslate_test.cpp
- *
- * $LicenseInfo:firstyear=2011&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2011, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "../test/lltut.h"
-#include "../lltranslate.h"
-#include "../llversioninfo.h"
-#include "../llviewercontrol.h"
-
-#include "llbufferstream.h"
-#include "lltrans.h"
-#include "llui.h"
-
-#include "../../llmessage/llhttpconstants.cpp"
-
-static const std::string GOOGLE_VALID_RESPONSE1 =
-"{\
- \"data\": {\
-  \"translations\": [\
-   {\
-    \"translatedText\": \"привет\",\
-    \"detectedSourceLanguage\": \"es\"\
-   }\
-  ]\
- }\
-}";
-
-static const std::string GOOGLE_VALID_RESPONSE2 =
-"{\
- \"data\": {\
-  \"translations\": [\
-   {\
-    \"translatedText\": \"привет\"\
-   }\
-  ]\
- }\
-}\
-";
-
-static const std::string GOOGLE_VALID_RESPONSE3 =
-"{\
- \"error\": {\
-  \"errors\": [\
-   {\
-    \"domain\": \"global\",\
-    \"reason\": \"invalid\",\
-    \"message\": \"Invalid Value\"\
-   }\
-  ],\
-  \"code\": 400,\
-  \"message\": \"Invalid Value\"\
- }\
-}";
-
-static const std::string BING_VALID_RESPONSE1 =
-"<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">Привет</string>";
-
-static const std::string BING_VALID_RESPONSE2 =
-"<html><body><h1>Argument Exception</h1><p>Method: Translate()</p><p>Parameter: </p>\
-<p>Message: 'from' must be a valid language</p><code></code>\
-<p>message id=3743.V2_Rest.Translate.58E8454F</p></body></html>";
-
-static const std::string BING_VALID_RESPONSE3 =
-"<html><body><h1>Argument Exception</h1><p>Method: Translate()</p>\
-<p>Parameter: appId</p><p>Message: Invalid appId&#xD;\nParameter name: appId</p>\
-<code></code><p>message id=3737.V2_Rest.Translate.56016759</p></body></html>";
-
-namespace tut
-{
-	class translate_test
-	{
-	protected:
-		void test_translation(
-			LLTranslationAPIHandler& handler,
-			int status, const std::string& resp,
-			const std::string& exp_trans, const std::string& exp_lang, const std::string& exp_err)
-		{
-			std::string translation, detected_lang, err_msg;
-			bool rc = handler.parseResponse(status, resp, translation, detected_lang, err_msg);
-			ensure_equals("rc", rc, (status == 200));
-			ensure_equals("err_msg", err_msg, exp_err);
-			ensure_equals("translation", translation, exp_trans);
-			ensure_equals("detected_lang", detected_lang,  exp_lang);
-		}
-
-		LLGoogleTranslationHandler mGoogle;
-		LLBingTranslationHandler mBing;
-	};
-
-	typedef test_group<translate_test> translate_test_group_t;
-	typedef translate_test_group_t::object translate_test_object_t;
-	tut::translate_test_group_t tut_translate("LLTranslate");
-
-	template<> template<>
-	void translate_test_object_t::test<1>()
-	{
-		test_translation(mGoogle, 200, GOOGLE_VALID_RESPONSE1, "привет", "es", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<2>()
-	{
-		test_translation(mGoogle, 200, GOOGLE_VALID_RESPONSE2, "привет", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<3>()
-	{
-		test_translation(mGoogle, 400, GOOGLE_VALID_RESPONSE3, "", "", "Invalid Value");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<4>()
-	{
-		test_translation(mGoogle, 400,
-			"",
-			"", "", "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<5>()
-	{
-		test_translation(mGoogle, 400,
-			"[]",
-			"", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<6>()
-	{
-		test_translation(mGoogle, 400,
-			"{\"oops\": \"invalid\"}",
-			"", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<7>()
-	{
-		test_translation(mGoogle, 400,
-			"{\"data\": {}}",
-			"", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<8>()
-	{
-		test_translation(mGoogle, 400,
-				"{\"data\": { \"translations\": [ {} ] }}",
-			"", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<9>()
-	{
-		test_translation(mGoogle, 400,
-				"{\"data\": { \"translations\": [ { \"translatedTextZZZ\": \"привет\", \"detectedSourceLanguageZZZ\": \"es\" } ] }}",
-			"", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<10>()
-	{
-		test_translation(mBing, 200, BING_VALID_RESPONSE1, "Привет", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<11>()
-	{
-		test_translation(mBing, 400, BING_VALID_RESPONSE2, "", "", "'from' must be a valid language");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<12>()
-	{
-		test_translation(mBing, 400, BING_VALID_RESPONSE3, "", "", "Invalid appId\nParameter name: appId");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<13>()
-	{
-		test_translation(mBing, 200,
-			"Привет</string>",
-			"Привет", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<14>()
-	{
-		test_translation(mBing, 200,
-			"<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">Привет",
-			"Привет", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<15>()
-	{
-		test_translation(mBing, 200,
-			"Привет",
-			"Привет", "", "");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<16>()
-	{
-		test_translation(mBing, 400,
-			"Message: some error</p>",
-			"", "", "some error");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<17>()
-	{
-		test_translation(mBing, 400,
-			"Message: some error",
-			"", "", "some error");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<18>()
-	{
-		test_translation(mBing, 400,
-			"some error</p>",
-			"", "", "some error");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<19>()
-	{
-		test_translation(mBing, 400,
-			"some error",
-			"", "", "some error");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<20>()
-	{
-		std::string url;
-		mBing.getTranslateURL(url, "en", "es", "hi");
-		ensure_equals("bing URL", url,
-			"http://api.microsofttranslator.com/v2/Http.svc/Translate?appId=dummy&text=hi&to=es&from=en");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<21>()
-	{
-		std::string url;
-		mBing.getTranslateURL(url, "", "es", "hi");
-		ensure_equals("bing URL", url,
-			"http://api.microsofttranslator.com/v2/Http.svc/Translate?appId=dummy&text=hi&to=es");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<22>()
-	{
-		std::string url;
-		mGoogle.getTranslateURL(url, "en", "es", "hi");
-		ensure_equals("google URL", url,
-			"https://www.googleapis.com/language/translate/v2?key=dummy&q=hi&target=es&source=en");
-	}
-
-	template<> template<>
-	void translate_test_object_t::test<23>()
-	{
-		std::string url;
-		mGoogle.getTranslateURL(url, "", "es", "hi");
-		ensure_equals("google URL", url,
-			"https://www.googleapis.com/language/translate/v2?key=dummy&q=hi&target=es");
-	}
-}
-
-//== Misc stubs ===============================================================
-LLControlGroup gSavedSettings("test");
-
-std::string LLUI::getLanguage() { return "en"; }
-std::string LLTrans::getString(const std::string &xml_desc, const LLStringUtil::format_map_t& args) { return "dummy"; }
-
-LLControlGroup::LLControlGroup(const std::string& name) : LLInstanceTracker<LLControlGroup, std::string>(name) {}
-std::string LLControlGroup::getString(const std::string& name) { return "dummy"; }
-LLControlGroup::~LLControlGroup() {}
-
-LLCurl::Responder::Responder() {}
-void LLCurl::Responder::httpFailure() { }
-void LLCurl::Responder::httpSuccess() { }
-void LLCurl::Responder::httpCompleted() { }
-void LLCurl::Responder::completedRaw(LLChannelDescriptors const &,boost::shared_ptr<LLBufferArray> const &) { }
-LLCurl::Responder::~Responder() {}
-
-void LLHTTPClient::get(const std::string&, const LLSD&, ResponderPtr, const LLSD&, const F32, bool) {}
-void LLHTTPClient::get(const std::string&, LLPointer<LLCurl::Responder>, const LLSD&, const F32, bool) {}
-
-LLBufferStream::LLBufferStream(const LLChannelDescriptors& channels, LLBufferArray* buffer)
-:	std::iostream(&mStreamBuf), mStreamBuf(channels, buffer) {}
-LLBufferStream::~LLBufferStream() {}
-
-LLBufferStreamBuf::LLBufferStreamBuf(const LLChannelDescriptors&, LLBufferArray*) {}
-#if( LL_WINDOWS || __GNUC__ > 2)
-LLBufferStreamBuf::pos_type LLBufferStreamBuf::seekoff(
-	off_type off,
-	std::ios::seekdir way,
-	std::ios::openmode which)
-#else
-streampos LLBufferStreamBuf::seekoff(
-	streamoff off,
-	std::ios::seekdir way,
-	std::ios::openmode which)
-#endif
-{ return 0; }
-int LLBufferStreamBuf::sync() {return 0;}
-int LLBufferStreamBuf::underflow() {return 0;}
-int LLBufferStreamBuf::overflow(int) {return 0;}
-LLBufferStreamBuf::~LLBufferStreamBuf() {}
-
-S32 LLVersionInfo::getBuild() { return 0; }
-const std::string& LLVersionInfo::getChannel() {static std::string dummy; return dummy;}
-S32 LLVersionInfo::getMajor() { return 0; }
-S32 LLVersionInfo::getMinor() { return 0; }
-S32 LLVersionInfo::getPatch() { return 0; }
-- 
cgit v1.3


From 75c6549fde060e974c90636685962ee373f94202 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 18 Sep 2015 11:39:22 -0700
Subject: Set consistent terminology for yield/wait -> suspend for coroutines.

---
 indra/llcommon/lleventcoro.cpp                     |  32 +++---
 indra/llcommon/lleventcoro.h                       |  86 +++++++--------
 indra/llcommon/llprocess.cpp                       |   8 +-
 indra/llcommon/tests/lleventcoro_test.cpp          |  50 ++++-----
 indra/llmessage/llavatarnamecache.cpp              |   2 +-
 indra/llmessage/llcoproceduremanager.cpp           |   8 +-
 indra/llmessage/llcorehttputil.cpp                 | 108 +++++++++----------
 indra/llmessage/llcorehttputil.h                   | 120 ++++++++++-----------
 indra/llmessage/llexperiencecache.cpp              |  24 ++---
 indra/llmessage/message.cpp                        |   2 +-
 indra/newview/llaccountingcostmanager.cpp          |   2 +-
 indra/newview/llaisapi.cpp                         |  18 ++--
 indra/newview/llavatarrenderinfoaccountant.cpp     |   4 +-
 indra/newview/llestateinfomodel.cpp                |   2 +-
 indra/newview/lleventpoll.cpp                      |   6 +-
 indra/newview/llfacebookconnect.cpp                |  14 +--
 indra/newview/llfeaturemanager.cpp                 |   2 +-
 indra/newview/llflickrconnect.cpp                  |  12 +--
 indra/newview/llfloateravatarpicker.cpp            |   2 +-
 indra/newview/llfloaterexperiences.cpp             |   4 +-
 indra/newview/llfloatermodeluploadbase.cpp         |   2 +-
 indra/newview/llfloaterperms.cpp                   |   2 +-
 indra/newview/llfloaterscriptlimits.cpp            |   8 +-
 indra/newview/llfloatertos.cpp                     |   2 +-
 indra/newview/llfloaterurlentry.cpp                |   2 +-
 indra/newview/llgroupmgr.cpp                       |   6 +-
 indra/newview/llimview.cpp                         |   4 +-
 indra/newview/llinventorymodel.cpp                 |   2 +-
 indra/newview/llmarketplacefunctions.cpp           |  18 ++--
 indra/newview/llpathfindingmanager.cpp             |  18 ++--
 indra/newview/llproductinforequest.cpp             |   2 +-
 indra/newview/llremoteparcelrequest.cpp            |   2 +-
 indra/newview/llspeakers.cpp                       |   2 +-
 indra/newview/llsyntaxid.cpp                       |   2 +-
 indra/newview/lltranslate.cpp                      |   4 +-
 indra/newview/lltwitterconnect.cpp                 |  12 +--
 indra/newview/llviewerassetupload.cpp              |   6 +-
 indra/newview/llviewermedia.cpp                    |   8 +-
 indra/newview/llviewerobjectlist.cpp               |   4 +-
 indra/newview/llviewerregion.cpp                   |   6 +-
 indra/newview/llvoavatarself.cpp                   |   2 +-
 indra/newview/llvoicechannel.cpp                   |   2 +-
 indra/newview/llvoicevivox.cpp                     |   4 +-
 indra/newview/llwebprofile.cpp                     |   6 +-
 indra/newview/llwlhandlers.cpp                     |   4 +-
 indra/viewer_components/login/lllogin.cpp          |   8 +-
 .../viewer_components/updater/llupdatechecker.cpp  |   2 +-
 47 files changed, 323 insertions(+), 323 deletions(-)

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/llcommon/lleventcoro.cpp b/indra/llcommon/lleventcoro.cpp
index 66cc7cada0..031c2cffb0 100755
--- a/indra/llcommon/lleventcoro.cpp
+++ b/indra/llcommon/lleventcoro.cpp
@@ -45,14 +45,14 @@ namespace
 {
 
 /**
- * waitForEventOn() permits a coroutine to temporarily listen on an
+ * suspendUntilEventOn() permits a coroutine to temporarily listen on an
  * LLEventPump any number of times. We don't really want to have to ask
  * the caller to label each such call with a distinct string; the whole
- * point of waitForEventOn() is to present a nice sequential interface to
+ * point of suspendUntilEventOn() is to present a nice sequential interface to
  * the underlying LLEventPump-with-named-listeners machinery. So we'll use
  * LLEventPump::inventName() to generate a distinct name for each
  * temporary listener. On the other hand, because a given coroutine might
- * call waitForEventOn() any number of times, we don't really want to
+ * call suspendUntilEventOn() any number of times, we don't really want to
  * consume an arbitrary number of generated inventName()s: that namespace,
  * though large, is nonetheless finite. So we memoize an invented name for
  * each distinct coroutine instance.
@@ -73,7 +73,7 @@ std::string listenerNameForCoro()
 }
 
 /**
- * Implement behavior described for postAndWait()'s @a replyPumpNamePath
+ * Implement behavior described for postEventAndSuspend()'s @a replyPumpNamePath
  * parameter:
  *
  * * If <tt>path.isUndefined()</tt>, do nothing.
@@ -145,15 +145,15 @@ void storeToLLSDPath(LLSD& dest, const LLSD& rawPath, const LLSD& value)
 
 } // anonymous
 
-void llcoro::yield()
+void llcoro::suspend()
 {
     // By viewer convention, we post an event on the "mainloop" LLEventPump
     // each iteration of the main event-handling loop. So waiting for a single
-    // event on "mainloop" gives us a one-frame yield.
-    waitForEventOn("mainloop");
+    // event on "mainloop" gives us a one-frame suspend.
+    suspendUntilEventOn("mainloop");
 }
 
-LLSD llcoro::postAndWait(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
+LLSD llcoro::postEventAndSuspend(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
                  const LLEventPumpOrPumpName& replyPump, const LLSD& replyPumpNamePath)
 {
     // declare the future
@@ -171,7 +171,7 @@ LLSD llcoro::postAndWait(const LLSD& event, const LLEventPumpOrPumpName& request
         // request event.
         LLSD modevent(event);
         storeToLLSDPath(modevent, replyPumpNamePath, replyPump.getPump().getName());
-        LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
+        LL_DEBUGS("lleventcoro") << "postEventAndSuspend(): coroutine " << listenerName
                                  << " posting to " << requestPump.getPump().getName()
                                  << LL_ENDL;
 
@@ -179,7 +179,7 @@ LLSD llcoro::postAndWait(const LLSD& event, const LLEventPumpOrPumpName& request
         //                         << ": " << modevent << LL_ENDL;
         requestPump.getPump().post(modevent);
     }
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
+    LL_DEBUGS("lleventcoro") << "postEventAndSuspend(): coroutine " << listenerName
                              << " about to wait on LLEventPump " << replyPump.getPump().getName()
                              << LL_ENDL;
     // trying to dereference ("resolve") the future makes us wait for it
@@ -189,7 +189,7 @@ LLSD llcoro::postAndWait(const LLSD& event, const LLEventPumpOrPumpName& request
         llcoro::Suspending suspended;
         value = *future;
     } // destroy Suspending as soon as we're back
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << listenerName
+    LL_DEBUGS("lleventcoro") << "postEventAndSuspend(): coroutine " << listenerName
                              << " resuming with " << value << LL_ENDL;
     // returning should disconnect the connection
     return value;
@@ -199,7 +199,7 @@ namespace
 {
 
 /**
- * This helper is specifically for the two-pump version of waitForEventOn().
+ * This helper is specifically for the two-pump version of suspendUntilEventOn().
  * We use a single future object, but we want to listen on two pumps with it.
  * Since we must still adapt from (the callable constructed by)
  * boost::dcoroutines::make_callback() (void return) to provide an event
@@ -242,7 +242,7 @@ WaitForEventOnHelper<LISTENER> wfeoh(const LISTENER& listener, int discriminator
 namespace llcoro
 {
 
-LLEventWithID postAndWait2(const LLSD& event,
+LLEventWithID postEventAndSuspend2(const LLSD& event,
                            const LLEventPumpOrPumpName& requestPump,
                            const LLEventPumpOrPumpName& replyPump0,
                            const LLEventPumpOrPumpName& replyPump1,
@@ -270,12 +270,12 @@ LLEventWithID postAndWait2(const LLSD& event,
                         replyPump0.getPump().getName());
         storeToLLSDPath(modevent, replyPump1NamePath,
                         replyPump1.getPump().getName());
-        LL_DEBUGS("lleventcoro") << "postAndWait2(): coroutine " << name
+        LL_DEBUGS("lleventcoro") << "postEventAndSuspend2(): coroutine " << name
                                  << " posting to " << requestPump.getPump().getName()
                                  << ": " << modevent << LL_ENDL;
         requestPump.getPump().post(modevent);
     }
-    LL_DEBUGS("lleventcoro") << "postAndWait2(): coroutine " << name
+    LL_DEBUGS("lleventcoro") << "postEventAndSuspend2(): coroutine " << name
                              << " about to wait on LLEventPumps " << replyPump0.getPump().getName()
                              << ", " << replyPump1.getPump().getName() << LL_ENDL;
     // trying to dereference ("resolve") the future makes us wait for it
@@ -285,7 +285,7 @@ LLEventWithID postAndWait2(const LLSD& event,
         llcoro::Suspending suspended;
         value = *future;
     } // destroy Suspending as soon as we're back
-    LL_DEBUGS("lleventcoro") << "postAndWait(): coroutine " << name
+    LL_DEBUGS("lleventcoro") << "postEventAndSuspend(): coroutine " << name
                              << " resuming with (" << value.first << ", " << value.second << ")"
                              << LL_ENDL;
     // returning should disconnect both connections
diff --git a/indra/llcommon/lleventcoro.h b/indra/llcommon/lleventcoro.h
index 8f3ee38fb4..a09759c9cf 100755
--- a/indra/llcommon/lleventcoro.h
+++ b/indra/llcommon/lleventcoro.h
@@ -106,33 +106,33 @@ VoidListener<LISTENER> voidlistener(const LISTENER& listener)
  * runs without suspending for nontrivial time, sprinkle in calls to this
  * function to avoid stalling the rest of the viewer processing.
  */
-void yield();
+void suspend();
 
 /**
- * Post specified LLSD event on the specified LLEventPump, then wait for a
+ * Post specified LLSD event on the specified LLEventPump, then suspend for a
  * response on specified other LLEventPump. This is more than mere
  * convenience: the difference between this function and the sequence
  * @code
  * requestPump.post(myEvent);
- * LLSD reply = waitForEventOn(replyPump);
+ * LLSD reply = suspendUntilEventOn(replyPump);
  * @endcode
  * is that the sequence above fails if the reply is posted immediately on
  * @a replyPump, that is, before <tt>requestPump.post()</tt> returns. In the
  * sequence above, the running coroutine isn't even listening on @a replyPump
- * until <tt>requestPump.post()</tt> returns and @c waitForEventOn() is
+ * until <tt>requestPump.post()</tt> returns and @c suspendUntilEventOn() is
  * entered. Therefore, the coroutine completely misses an immediate reply
- * event, making it wait indefinitely.
+ * event, making it suspend indefinitely.
  *
- * By contrast, postAndWait() listens on the @a replyPump @em before posting
+ * By contrast, postEventAndSuspend() listens on the @a replyPump @em before posting
  * the specified LLSD event on the specified @a requestPump.
  *
  * @param event LLSD data to be posted on @a requestPump
  * @param requestPump an LLEventPump on which to post @a event. Pass either
  * the LLEventPump& or its string name. However, if you pass a
  * default-constructed @c LLEventPumpOrPumpName, we skip the post() call.
- * @param replyPump an LLEventPump on which postAndWait() will listen for a
+ * @param replyPump an LLEventPump on which postEventAndSuspend() will listen for a
  * reply. Pass either the LLEventPump& or its string name. The calling
- * coroutine will wait until that reply arrives. (If you're concerned about a
+ * coroutine will suspend until that reply arrives. (If you're concerned about a
  * reply that might not arrive, please see also LLEventTimeout.)
  * @param replyPumpNamePath specifies the location within @a event in which to
  * store <tt>replyPump.getName()</tt>. This is a strictly optional convenience
@@ -155,21 +155,21 @@ void yield();
  *   @a replyPumpNamePath specifies the entry in the lowest-level structure in
  *   @a event into which to store <tt>replyPump.getName()</tt>.
  */
-LLSD postAndWait(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
+LLSD postEventAndSuspend(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
                  const LLEventPumpOrPumpName& replyPump, const LLSD& replyPumpNamePath=LLSD());
 
 /// Wait for the next event on the specified LLEventPump. Pass either the
 /// LLEventPump& or its string name.
 inline
-LLSD waitForEventOn(const LLEventPumpOrPumpName& pump)
+LLSD suspendUntilEventOn(const LLEventPumpOrPumpName& pump)
 {
-    // This is now a convenience wrapper for postAndWait().
-    return postAndWait(LLSD(), LLEventPumpOrPumpName(), pump);
+    // This is now a convenience wrapper for postEventAndSuspend().
+    return postEventAndSuspend(LLSD(), LLEventPumpOrPumpName(), pump);
 }
 
 } // namespace llcoro
 
-/// return type for two-pump variant of waitForEventOn()
+/// return type for two-pump variant of suspendUntilEventOn()
 typedef std::pair<LLSD, int> LLEventWithID;
 
 namespace llcoro
@@ -177,7 +177,7 @@ namespace llcoro
 
 /**
  * This function waits for a reply on either of two specified LLEventPumps.
- * Otherwise, it closely resembles postAndWait(); please see the documentation
+ * Otherwise, it closely resembles postAndSuspend(); please see the documentation
  * for that function for detailed parameter info.
  *
  * While we could have implemented the single-pump variant in terms of this
@@ -192,19 +192,19 @@ namespace llcoro
  * the index of the pump on which it arrived (0 or 1).
  *
  * @note
- * I'd have preferred to overload the name postAndWait() for both signatures.
+ * I'd have preferred to overload the name postAndSuspend() for both signatures.
  * But consider the following ambiguous call:
  * @code
- * postAndWait(LLSD(), requestPump, replyPump, "someString");
+ * postAndSuspend(LLSD(), requestPump, replyPump, "someString");
  * @endcode
  * "someString" could be converted to either LLSD (@a replyPumpNamePath for
  * the single-pump function) or LLEventOrPumpName (@a replyPump1 for two-pump
  * function).
  *
- * It seems less burdensome to write postAndWait2() than to write either
+ * It seems less burdensome to write postEventAndSuspend2() than to write either
  * LLSD("someString") or LLEventOrPumpName("someString").
  */
-LLEventWithID postAndWait2(const LLSD& event,
+LLEventWithID postEventAndSuspend2(const LLSD& event,
                            const LLEventPumpOrPumpName& requestPump,
                            const LLEventPumpOrPumpName& replyPump0,
                            const LLEventPumpOrPumpName& replyPump1,
@@ -216,17 +216,17 @@ LLEventWithID postAndWait2(const LLSD& event,
  */
 inline
 LLEventWithID
-waitForEventOn(const LLEventPumpOrPumpName& pump0, const LLEventPumpOrPumpName& pump1)
+suspendUntilEventOn(const LLEventPumpOrPumpName& pump0, const LLEventPumpOrPumpName& pump1)
 {
-    // This is now a convenience wrapper for postAndWait2().
-    return postAndWait2(LLSD(), LLEventPumpOrPumpName(), pump0, pump1);
+    // This is now a convenience wrapper for postEventAndSuspend2().
+    return postEventAndSuspend2(LLSD(), LLEventPumpOrPumpName(), pump0, pump1);
 }
 
 /**
- * Helper for the two-pump variant of waitForEventOn(), e.g.:
+ * Helper for the two-pump variant of suspendUntilEventOn(), e.g.:
  *
  * @code
- * LLSD reply = errorException(waitForEventOn(replyPump, errorPump),
+ * LLSD reply = errorException(suspendUntilEventOn(replyPump, errorPump),
  *                             "error response from login.cgi");
  * @endcode
  *
@@ -286,7 +286,7 @@ LL_COMMON_API LLSD errorLog(const LLEventWithID& result, const std::string& desc
  * 2. Provide its actual name to the event API in question as the name of the
  *    reply LLEventPump.
  * 3. Initiate the request to the event API.
- * 4. Call your LLEventTempStream's wait() method to wait for the reply.
+ * 4. Call your LLEventTempStream's suspend() method to suspend for the reply.
  * 5. Let the LLCoroEventPump go out of scope.
  */
 class LL_COMMON_API LLCoroEventPump
@@ -304,15 +304,15 @@ public:
     /**
      * Wait for an event on this LLEventPump.
      */
-    LLSD wait()
+    LLSD suspend()
     {
-        return llcoro::waitForEventOn(mPump);
+        return llcoro::suspendUntilEventOn(mPump);
     }
 
-    LLSD postAndWait(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
+    LLSD postAndSuspend(const LLSD& event, const LLEventPumpOrPumpName& requestPump,
                      const LLSD& replyPumpNamePath=LLSD())
     {
-        return llcoro::postAndWait(event, requestPump, mPump, replyPumpNamePath);
+        return llcoro::postEventAndSuspend(event, requestPump, mPump, replyPumpNamePath);
     }
 
 private:
@@ -348,49 +348,49 @@ public:
     /// request pump 1
     LLEventPump& getPump1() { return mPump1; }
 
-    /// waitForEventOn(either of our two LLEventPumps)
-    LLEventWithID wait()
+    /// suspendUntilEventOn(either of our two LLEventPumps)
+    LLEventWithID suspend()
     {
-        return llcoro::waitForEventOn(mPump0, mPump1);
+        return llcoro::suspendUntilEventOn(mPump0, mPump1);
     }
 
-    /// errorException(wait())
-    LLSD waitWithException()
+    /// errorException(suspend())
+    LLSD suspendWithException()
     {
-        return llcoro::errorException(wait(), std::string("Error event on ") + getName1());
+        return llcoro::errorException(suspend(), std::string("Error event on ") + getName1());
     }
 
-    /// errorLog(wait())
-    LLSD waitWithLog()
+    /// errorLog(suspend())
+    LLSD suspendWithLog()
     {
-        return llcoro::errorLog(wait(), std::string("Error event on ") + getName1());
+        return llcoro::errorLog(suspend(), std::string("Error event on ") + getName1());
     }
 
-    LLEventWithID postAndWait(const LLSD& event,
+    LLEventWithID postAndSuspend(const LLSD& event,
                               const LLEventPumpOrPumpName& requestPump,
                               const LLSD& replyPump0NamePath=LLSD(),
                               const LLSD& replyPump1NamePath=LLSD())
     {
-        return llcoro::postAndWait2(event, requestPump, mPump0, mPump1,
+        return llcoro::postEventAndSuspend2(event, requestPump, mPump0, mPump1,
                                     replyPump0NamePath, replyPump1NamePath);
     }
 
-    LLSD postAndWaitWithException(const LLSD& event,
+    LLSD postAndSuspendWithException(const LLSD& event,
                                   const LLEventPumpOrPumpName& requestPump,
                                   const LLSD& replyPump0NamePath=LLSD(),
                                   const LLSD& replyPump1NamePath=LLSD())
     {
-        return llcoro::errorException(postAndWait(event, requestPump,
+        return llcoro::errorException(postAndSuspend(event, requestPump,
                                                   replyPump0NamePath, replyPump1NamePath),
                                       std::string("Error event on ") + getName1());
     }
 
-    LLSD postAndWaitWithLog(const LLSD& event,
+    LLSD postAndSuspendWithLog(const LLSD& event,
                             const LLEventPumpOrPumpName& requestPump,
                             const LLSD& replyPump0NamePath=LLSD(),
                             const LLSD& replyPump1NamePath=LLSD())
     {
-        return llcoro::errorLog(postAndWait(event, requestPump,
+        return llcoro::errorLog(postAndSuspend(event, requestPump,
                                             replyPump0NamePath, replyPump1NamePath),
                                 std::string("Error event on ") + getName1());
     }
diff --git a/indra/llcommon/llprocess.cpp b/indra/llcommon/llprocess.cpp
index 715df36f39..a8a772b7df 100755
--- a/indra/llcommon/llprocess.cpp
+++ b/indra/llcommon/llprocess.cpp
@@ -710,7 +710,7 @@ LLProcess::LLProcess(const LLSDOrParams& params):
 
 		// Tie the lifespan of this child process to the lifespan of our APR
 		// pool: on destruction of the pool, forcibly kill the process. Tell
-		// APR to try SIGTERM and wait 3 seconds. If that didn't work, use
+		// APR to try SIGTERM and suspend 3 seconds. If that didn't work, use
 		// SIGKILL.
 		apr_pool_note_subprocess(gAPRPoolp, &mProcess, APR_KILL_AFTER_TIMEOUT);
 |*==========================================================================*/
@@ -986,9 +986,9 @@ void LLProcess::handle_status(int reason, int status)
 //	wi->rv = apr_proc_wait(wi->child, &wi->rc, &wi->why, APR_NOWAIT);
 	// It's just wrong to call apr_proc_wait() here. The only way APR knows to
 	// call us with APR_OC_REASON_DEATH is that it's already reaped this child
-	// process, so calling wait() will only produce "huh?" from the OS. We
+	// process, so calling suspend() will only produce "huh?" from the OS. We
 	// must rely on the status param passed in, which unfortunately comes
-	// straight from the OS wait() call, which means we have to decode it by
+	// straight from the OS suspend() call, which means we have to decode it by
 	// hand.
 	mStatus = interpret_status(status);
 	LL_INFOS("LLProcess") << getStatusString() << LL_ENDL;
@@ -1231,7 +1231,7 @@ static std::string WindowsErrorString(const std::string& operation)
 #include <signal.h>
 #include <fcntl.h>
 #include <errno.h>
-#include <sys/wait.h>
+#include <sys/suspend.h>
 
 void LLProcess::autokill()
 {
diff --git a/indra/llcommon/tests/lleventcoro_test.cpp b/indra/llcommon/tests/lleventcoro_test.cpp
index 00be5035f2..5cced69670 100755
--- a/indra/llcommon/tests/lleventcoro_test.cpp
+++ b/indra/llcommon/tests/lleventcoro_test.cpp
@@ -129,8 +129,8 @@ typedef coroutine<std::string::iterator(void)> match_coroutine_type;
 *****************************************************************************/
 /// Simulate an event API whose response is immediate: sent on receipt of the
 /// initial request, rather than after some delay. This is the case that
-/// distinguishes postAndWait() from calling post(), then calling
-/// waitForEventOn().
+/// distinguishes postEventAndSuspend() from calling post(), then calling
+/// suspendUntilEventOn().
 class ImmediateAPI
 {
 public:
@@ -241,13 +241,13 @@ namespace tut
 
             // declare the future
             boost::dcoroutines::future<LLSD> future(self);
-            // tell the future what to wait for
+            // tell the future what to suspend for
             LLTempBoundListener connection(
                 LLEventPumps::instance().obtain("source").listen("coro", voidlistener(boost::dcoroutines::make_callback(future))));
             ensure("Not yet", ! future);
             // attempting to dereference ("resolve") the future causes the calling
-            // coroutine to wait for it
-            debug("about to wait");
+            // coroutine to suspend for it
+            debug("about to suspend");
             result = *future;
             ensure("Got it", future);
         }
@@ -269,9 +269,9 @@ namespace tut
         coro(std::nothrow);
         // When the coroutine waits for the event pump, it returns here.
         debug("about to send");
-        // Satisfy the wait.
+        // Satisfy the suspend.
         LLEventPumps::instance().obtain("source").post("received");
-        // Now wait for the coroutine to complete.
+        // Now suspend for the coroutine to complete.
         ensure("coroutine complete", ! coro);
         // ensure the coroutine ran and woke up again with the intended result
         ensure_equals(result.asString(), "received");
@@ -281,7 +281,7 @@ namespace tut
     {
         BEGIN
         {
-            result = waitForEventOn("source");
+            result = suspendUntilEventOn("source");
         }
         END
     }
@@ -303,7 +303,7 @@ namespace tut
     {
         BEGIN
         {
-            LLEventWithID pair = waitForEventOn("reply", "error");
+            LLEventWithID pair = suspendUntilEventOn("reply", "error");
             result = pair.first;
             which  = pair.second;
             debug(STRINGIZE("result = " << result << ", which = " << which));
@@ -347,7 +347,7 @@ namespace tut
         {
             LLCoroEventPump waiter;
             replyName = waiter.getName();
-            result = waiter.wait();
+            result = waiter.suspend();
         }
         END
     }
@@ -372,7 +372,7 @@ namespace tut
             LLCoroEventPumps waiter;
             replyName = waiter.getName0();
             errorName = waiter.getName1();
-            LLEventWithID pair(waiter.wait());
+            LLEventWithID pair(waiter.suspend());
             result = pair.first;
             which  = pair.second;
         }
@@ -414,7 +414,7 @@ namespace tut
             LLCoroEventPumps waiter;
             replyName = waiter.getName0();
             errorName = waiter.getName1();
-            result = waiter.waitWithException();
+            result = waiter.suspendWithException();
         }
         END
     }
@@ -441,7 +441,7 @@ namespace tut
             errorName = waiter.getName1();
             try
             {
-                result = waiter.waitWithException();
+                result = waiter.suspendWithException();
                 debug("no exception");
             }
             catch (const LLErrorEvent& e)
@@ -474,7 +474,7 @@ namespace tut
             LLCoroEventPumps waiter;
             replyName = waiter.getName0();
             errorName = waiter.getName1();
-            result = waiter.waitWithLog();
+            result = waiter.suspendWithLog();
         }
         END
     }
@@ -502,7 +502,7 @@ namespace tut
             WrapLLErrs capture;
             try
             {
-                result = waiter.waitWithLog();
+                result = waiter.suspendWithLog();
                 debug("no exception");
             }
             catch (const WrapLLErrs::FatalException& e)
@@ -532,7 +532,7 @@ namespace tut
     {
         BEGIN
         {
-            result = postAndWait(LLSDMap("value", 17),       // request event
+            result = postEventAndSuspend(LLSDMap("value", 17),       // request event
                                  immediateAPI.getPump(),     // requestPump
                                  "reply1",                   // replyPump
                                  "reply");                   // request["reply"] = name
@@ -554,7 +554,7 @@ namespace tut
     {
         BEGIN
         {
-            LLEventWithID pair = ::postAndWait2(LLSDMap("value", 18),
+            LLEventWithID pair = ::postEventAndSuspend2(LLSDMap("value", 18),
                                                 immediateAPI.getPump(),
                                                 "reply2",
                                                 "error2",
@@ -582,7 +582,7 @@ namespace tut
     {
         BEGIN
         {
-            LLEventWithID pair = ::postAndWait2(LLSDMap("value", 18)("fail", LLSD()),
+            LLEventWithID pair = ::postEventAndSuspend2(LLSDMap("value", 18)("fail", LLSD()),
                                                 immediateAPI.getPump(),
                                                 "reply2",
                                                 "error2",
@@ -611,7 +611,7 @@ namespace tut
         BEGIN
         {
             LLCoroEventPump waiter;
-            result = waiter.postAndWait(LLSDMap("value", 17),
+            result = waiter.postAndSuspend(LLSDMap("value", 17),
                                         immediateAPI.getPump(), "reply");
         }
         END
@@ -632,7 +632,7 @@ namespace tut
         BEGIN
         {
             LLCoroEventPumps waiter;
-            LLEventWithID pair(waiter.postAndWait(LLSDMap("value", 23),
+            LLEventWithID pair(waiter.postAndSuspend(LLSDMap("value", 23),
                                                   immediateAPI.getPump(), "reply", "error"));
             result = pair.first;
             which  = pair.second;
@@ -657,7 +657,7 @@ namespace tut
         {
             LLCoroEventPumps waiter;
             LLEventWithID pair(
-                waiter.postAndWait(LLSDMap("value", 23)("fail", LLSD()),
+                waiter.postAndSuspend(LLSDMap("value", 23)("fail", LLSD()),
                                    immediateAPI.getPump(), "reply", "error"));
             result = pair.first;
             which  = pair.second;
@@ -681,7 +681,7 @@ namespace tut
         BEGIN
         {
             LLCoroEventPumps waiter;
-            result = waiter.postAndWaitWithException(LLSDMap("value", 8),
+            result = waiter.postAndSuspendWithException(LLSDMap("value", 8),
                                                      immediateAPI.getPump(), "reply", "error");
         }
         END
@@ -704,7 +704,7 @@ namespace tut
             LLCoroEventPumps waiter;
             try
             {
-                result = waiter.postAndWaitWithException(
+                result = waiter.postAndSuspendWithException(
                     LLSDMap("value", 9)("fail", LLSD()),
                     immediateAPI.getPump(), "reply", "error");
                 debug("no exception");
@@ -734,7 +734,7 @@ namespace tut
         BEGIN
         {
             LLCoroEventPumps waiter;
-            result = waiter.postAndWaitWithLog(LLSDMap("value", 30),
+            result = waiter.postAndSuspendWithLog(LLSDMap("value", 30),
                                                immediateAPI.getPump(), "reply", "error");
         }
         END
@@ -758,7 +758,7 @@ namespace tut
             WrapLLErrs capture;
             try
             {
-                result = waiter.postAndWaitWithLog(
+                result = waiter.postAndSuspendWithLog(
                     LLSDMap("value", 31)("fail", LLSD()),
                     immediateAPI.getPump(), "reply", "error");
                 debug("no exception");
diff --git a/indra/llmessage/llavatarnamecache.cpp b/indra/llmessage/llavatarnamecache.cpp
index d262862c80..61f18ed63e 100755
--- a/indra/llmessage/llavatarnamecache.cpp
+++ b/indra/llmessage/llavatarnamecache.cpp
@@ -195,7 +195,7 @@ void LLAvatarNameCache::requestAvatarNameCache_(std::string url, std::vector<LLU
         bool success = true;
 
         LLCoreHttpUtil::HttpCoroutineAdapter httpAdapter("NameCache", LLAvatarNameCache::sHttpPolicy);
-        LLSD results = httpAdapter.getAndYield(sHttpRequest, url);
+        LLSD results = httpAdapter.getAndSuspend(sHttpRequest, url);
         LLSD httpResults;
 
         LL_DEBUGS() << results << LL_ENDL;
diff --git a/indra/llmessage/llcoproceduremanager.cpp b/indra/llmessage/llcoproceduremanager.cpp
index 10519d990e..f0fe1ab01b 100644
--- a/indra/llmessage/llcoproceduremanager.cpp
+++ b/indra/llmessage/llcoproceduremanager.cpp
@@ -58,7 +58,7 @@ public:
     LLUUID enqueueCoprocedure(const std::string &name, CoProcedure_t proc);
 
     /// Cancel a coprocedure. If the coprocedure is already being actively executed 
-    /// this method calls cancelYieldingOperation() on the associated HttpAdapter
+    /// this method calls cancelSuspendedOperation() on the associated HttpAdapter
     /// If it has not yet been dequeued it is simply removed from the queue.
     bool cancelCoprocedure(const LLUUID &id);
 
@@ -316,7 +316,7 @@ void LLCoprocedurePool::shutdown(bool hardShutdown)
         }
         if ((*it).second)
         {
-            (*it).second->cancelYieldingOperation();
+            (*it).second->cancelSuspendedOperation();
         }
     }
 
@@ -345,7 +345,7 @@ bool LLCoprocedurePool::cancelCoprocedure(const LLUUID &id)
     if (itActive != mActiveCoprocs.end())
     {
         LL_INFOS() << "Found and canceling active coprocedure with id=" << id.asString() << " in pool \"" << mPoolName << "\"" << LL_ENDL;
-        (*itActive).second->cancelYieldingOperation();
+        (*itActive).second->cancelSuspendedOperation();
         mActiveCoprocs.erase(itActive);
         return true;
     }
@@ -371,7 +371,7 @@ void LLCoprocedurePool::coprocedureInvokerCoro(LLCoreHttpUtil::HttpCoroutineAdap
 
     while (!mShutdown)
     {
-        llcoro::waitForEventOn(mWakeupTrigger);
+        llcoro::suspendUntilEventOn(mWakeupTrigger);
         if (mShutdown)
             break;
         
diff --git a/indra/llmessage/llcorehttputil.cpp b/indra/llmessage/llcorehttputil.cpp
index 106df15bf1..d964ff7100 100644
--- a/indra/llmessage/llcorehttputil.cpp
+++ b/indra/llmessage/llcorehttputil.cpp
@@ -567,20 +567,20 @@ HttpCoroutineAdapter::HttpCoroutineAdapter(const std::string &name,
 
 HttpCoroutineAdapter::~HttpCoroutineAdapter()
 {
-    cancelYieldingOperation();
+    cancelSuspendedOperation();
 }
 
-LLSD HttpCoroutineAdapter::postAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName, true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return postAndYield_(request, url, body, options, headers, httpHandler);
+    return postAndSuspend_(request, url, body, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::postAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -601,35 +601,35 @@ LLSD HttpCoroutineAdapter::postAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::postAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, LLCore::BufferArray::ptr_t rawbody,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName, true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return postAndYield_(request, url, rawbody, options, headers, httpHandler);
+    return postAndSuspend_(request, url, rawbody, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::postRawAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postRawAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, LLCore::BufferArray::ptr_t rawbody,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName, true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroRawHandler(replyPump));
 
-    return postAndYield_(request, url, rawbody, options, headers, httpHandler);
+    return postAndSuspend_(request, url, rawbody, options, headers, httpHandler);
 }
 
 // *TODO: This functionality could be moved into the LLCore::Http library itself 
 // by having the CURL layer read the file directly.
-LLSD HttpCoroutineAdapter::postFileAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, std::string fileName,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -653,12 +653,12 @@ LLSD HttpCoroutineAdapter::postFileAndYield(LLCore::HttpRequest::ptr_t request,
         }
     }
 
-    return postAndYield(request, url, fileData, options, headers);
+    return postAndSuspend(request, url, fileData, options, headers);
 }
 
 // *TODO: This functionality could be moved into the LLCore::Http library itself 
 // by having the CURL layer read the file directly.
-LLSD HttpCoroutineAdapter::postFileAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -678,10 +678,10 @@ LLSD HttpCoroutineAdapter::postFileAndYield(LLCore::HttpRequest::ptr_t request,
         delete[] fileBuffer;
     }
 
-    return postAndYield(request, url, fileData, options, headers);
+    return postAndSuspend(request, url, fileData, options, headers);
 }
 
-LLSD HttpCoroutineAdapter::postJsonAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::postJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -700,11 +700,11 @@ LLSD HttpCoroutineAdapter::postJsonAndYield(LLCore::HttpRequest::ptr_t request,
         outs << writer.write(root);
     }
 
-    return postAndYield_(request, url, rawbody, options, headers, httpHandler);
+    return postAndSuspend_(request, url, rawbody, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::postAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -724,23 +724,23 @@ LLSD HttpCoroutineAdapter::postAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::putAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::putAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return putAndYield_(request, url, body, options, headers, httpHandler);
+    return putAndSuspend_(request, url, body, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::putJsonAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::putJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -758,10 +758,10 @@ LLSD HttpCoroutineAdapter::putJsonAndYield(LLCore::HttpRequest::ptr_t request,
         outs << writer.write(root);
     }
 
-    return putAndYield_(request, url, rawbody, options, headers, httpHandler);
+    return putAndSuspend_(request, url, rawbody, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::putAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -782,13 +782,13 @@ LLSD HttpCoroutineAdapter::putAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::putAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, const LLCore::BufferArray::ptr_t & rawbody,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -808,44 +808,44 @@ LLSD HttpCoroutineAdapter::putAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
 
-LLSD HttpCoroutineAdapter::getAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::getAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return getAndYield_(request, url, options, headers, httpHandler);
+    return getAndSuspend_(request, url, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::getRawAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::getRawAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroRawHandler(replyPump));
 
-    return getAndYield_(request, url, options, headers, httpHandler);
+    return getAndSuspend_(request, url, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::getJsonAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::getJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroJSONHandler(replyPump));
 
-    return getAndYield_(request, url, options, headers, httpHandler);
+    return getAndSuspend_(request, url, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::getAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::getAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers, 
     HttpCoroHandler::ptr_t &handler)
@@ -864,35 +864,35 @@ LLSD HttpCoroutineAdapter::getAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
 
-LLSD HttpCoroutineAdapter::deleteAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::deleteAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return deleteAndYield_(request, url, options, headers, httpHandler);
+    return deleteAndSuspend_(request, url, options, headers, httpHandler);
 }
 
-LLSD HttpCoroutineAdapter::deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::deleteJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, 
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroJSONHandler(replyPump));
 
-    return deleteAndYield_(request, url, options, headers, httpHandler);
+    return deleteAndSuspend_(request, url, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::deleteAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, LLCore::HttpOptions::ptr_t &options, 
     LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler)
 {
@@ -910,24 +910,24 @@ LLSD HttpCoroutineAdapter::deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::patchAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::patchAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
     LLEventStream  replyPump(mAdapterName + "Reply", true);
     HttpCoroHandler::ptr_t httpHandler(new HttpCoroLLSDHandler(replyPump));
 
-    return patchAndYield_(request, url, body, options, headers, httpHandler);
+    return patchAndSuspend_(request, url, body, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::patchAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::patchAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, const LLSD & body,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -948,13 +948,13 @@ LLSD HttpCoroutineAdapter::patchAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::copyAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::copyAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const std::string dest,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -965,11 +965,11 @@ LLSD HttpCoroutineAdapter::copyAndYield(LLCore::HttpRequest::ptr_t request,
         headers.reset(new LLCore::HttpHeaders);
     headers->append(HTTP_OUT_HEADER_DESTINATION, dest);
 
-    return copyAndYield_(request, url, options, headers, httpHandler);
+    return copyAndSuspend_(request, url, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::copyAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url, 
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -990,13 +990,13 @@ LLSD HttpCoroutineAdapter::copyAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
 }
 
-LLSD HttpCoroutineAdapter::moveAndYield(LLCore::HttpRequest::ptr_t request,
+LLSD HttpCoroutineAdapter::moveAndSuspend(LLCore::HttpRequest::ptr_t request,
     const std::string & url, const std::string dest,
     LLCore::HttpOptions::ptr_t options, LLCore::HttpHeaders::ptr_t headers)
 {
@@ -1007,11 +1007,11 @@ LLSD HttpCoroutineAdapter::moveAndYield(LLCore::HttpRequest::ptr_t request,
         headers.reset(new LLCore::HttpHeaders);
     headers->append(HTTP_OUT_HEADER_DESTINATION, dest);
 
-    return moveAndYield_(request, url, options, headers, httpHandler);
+    return moveAndSuspend_(request, url, options, headers, httpHandler);
 }
 
 
-LLSD HttpCoroutineAdapter::moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+LLSD HttpCoroutineAdapter::moveAndSuspend_(LLCore::HttpRequest::ptr_t &request,
     const std::string & url,
     LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
     HttpCoroHandler::ptr_t &handler)
@@ -1032,7 +1032,7 @@ LLSD HttpCoroutineAdapter::moveAndYield_(LLCore::HttpRequest::ptr_t &request,
     }
 
     saveState(hhandle, request, handler);
-    LLSD results = llcoro::waitForEventOn(handler->getReplyPump());
+    LLSD results = llcoro::suspendUntilEventOn(handler->getReplyPump());
     cleanState();
 
     return results;
@@ -1059,7 +1059,7 @@ void HttpCoroutineAdapter::checkDefaultHeaders(LLCore::HttpHeaders::ptr_t &heade
 }
 
 
-void HttpCoroutineAdapter::cancelYieldingOperation()
+void HttpCoroutineAdapter::cancelSuspendedOperation()
 {
     LLCore::HttpRequest::ptr_t request = mWeakRequest.lock();
     HttpCoroHandler::ptr_t handler = mWeakHandler.lock();
@@ -1144,7 +1144,7 @@ void HttpCoroutineAdapter::trivialGetCoro(std::string url, LLCore::HttpRequest::
 
     LL_INFOS("HttpCoroutineAdapter", "genericGetCoro") << "Generic GET for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url, httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -1195,7 +1195,7 @@ void HttpCoroutineAdapter::trivialPostCoro(std::string url, LLCore::HttpRequest:
 
     LL_INFOS("HttpCoroutineAdapter", "genericPostCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/llmessage/llcorehttputil.h b/indra/llmessage/llcorehttputil.h
index 94800b1a5b..9328427c34 100644
--- a/indra/llmessage/llcorehttputil.h
+++ b/indra/llmessage/llcorehttputil.h
@@ -330,80 +330,80 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, body,
+        return postAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postAndYield(request, url, rawbody,
+        return postAndSuspend(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postRawAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::BufferArray::ptr_t rawbody,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postRawAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postRawAndYield(request, url, rawbody,
+        return postRawAndSuspend(request, url, rawbody,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, std::string fileName,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, std::string fileName,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, fileName,
+        return postFileAndSuspend(request, url, fileName,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD postFileAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postFileAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLUUID assetId, LLAssetType::EType assetType,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postFileAndYield(request, url, assetId, assetType,
+        return postFileAndSuspend(request, url, assetId, assetType,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD postJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD postJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD postJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return postJsonAndYield(request, url, body,
+        return postJsonAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -414,28 +414,28 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
 
-    LLSD putAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t headers)
     {
-        return putAndYield(request, url, body,
+        return putAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
-    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD putJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD putJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD putJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return putJsonAndYield(request, url, body,
+        return putJsonAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -445,42 +445,42 @@ public:
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
     /// 
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getAndYield(request, url,
+        return getAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getRawAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getRawAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getRawAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getRawAndYield(request, url,
+        return getRawAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    /// These methods have the same behavior as @getAndYield() however they are 
+    /// These methods have the same behavior as @getAndSuspend() however they are 
     /// expecting the server to return the results formatted in a JSON string. 
     /// On a successful GET call the JSON results will be converted into LLSD 
     /// before being returned to the caller.
-    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD getJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD getJsonAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD getJsonAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpHeaders::ptr_t &headers)
     {
-        return getJsonAndYield(request, url,
+        return getJsonAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -491,30 +491,30 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD deleteAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::HttpHeaders::ptr_t headers)
     {
-        return deleteAndYield(request, url,
+        return deleteAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
 
-    /// These methods have the same behavior as @deleteAndYield() however they are 
+    /// These methods have the same behavior as @deleteAndSuspend() however they are 
     /// expecting the server to return any results formatted in a JSON string. 
     /// On a successful DELETE call the JSON results will be converted into LLSD 
     /// before being returned to the caller.
-    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD deleteJsonAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD deleteJsonAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, LLCore::HttpHeaders::ptr_t headers)
     {
-        return deleteJsonAndYield(request, url,
+        return deleteJsonAndSuspend(request, url,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
             headers);
     }
@@ -525,15 +525,15 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD patchAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD patchAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD patchAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD patchAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return patchAndYield(request, url, body,
+        return patchAndSuspend(request, url, body,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -545,15 +545,15 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD copyAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD copyAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const std::string dest,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD copyAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD copyAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const std::string & dest,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return copyAndYield(request, url, dest,
+        return copyAndSuspend(request, url, dest,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
@@ -565,20 +565,20 @@ public:
     /// 
     /// @Note: the request's smart pointer is passed by value so that it will
     /// not be deallocated during the yield.
-    LLSD moveAndYield(LLCore::HttpRequest::ptr_t request,
+    LLSD moveAndSuspend(LLCore::HttpRequest::ptr_t request,
         const std::string & url, const std::string dest,
         LLCore::HttpOptions::ptr_t options = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()),
         LLCore::HttpHeaders::ptr_t headers = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders()));
-    LLSD moveAndYield(LLCore::HttpRequest::ptr_t &request,
+    LLSD moveAndSuspend(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const std::string & dest,
         LLCore::HttpHeaders::ptr_t &headers)
     {
-        return moveAndYield(request, url, dest,
+        return moveAndSuspend(request, url, dest,
             LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions()), headers);
     }
 
     ///
-    void cancelYieldingOperation();
+    void cancelSuspendedOperation();
 
     static LLCore::HttpStatus getStatusFromLLSD(const LLSD &httpResults);
 
@@ -616,45 +616,45 @@ private:
             HttpCoroHandler::ptr_t &handler);
     void cleanState();
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD postAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD postAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::BufferArray::ptr_t &rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD putAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD putAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLCore::BufferArray::ptr_t & rawbody,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD getAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD getAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options, 
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD deleteAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD deleteAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, LLCore::HttpOptions::ptr_t &options,
         LLCore::HttpHeaders::ptr_t &headers, HttpCoroHandler::ptr_t &handler);
 
-    LLSD patchAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD patchAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, const LLSD & body,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD copyAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD copyAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url, 
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
 
-    LLSD moveAndYield_(LLCore::HttpRequest::ptr_t &request,
+    LLSD moveAndSuspend_(LLCore::HttpRequest::ptr_t &request,
         const std::string & url,
         LLCore::HttpOptions::ptr_t &options, LLCore::HttpHeaders::ptr_t &headers,
         HttpCoroHandler::ptr_t &handler);
diff --git a/indra/llmessage/llexperiencecache.cpp b/indra/llmessage/llexperiencecache.cpp
index ff5f7e793d..3265608582 100644
--- a/indra/llmessage/llexperiencecache.cpp
+++ b/indra/llmessage/llexperiencecache.cpp
@@ -248,7 +248,7 @@ void LLExperienceCache::requestExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdap
 
     //LL_INFOS("requestExperiencesCoro") << "url: " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
         
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -401,7 +401,7 @@ void LLExperienceCache::idleCoro()
     do 
     {
         timeout.eventAfter(SECS_BETWEEN_REQUESTS, LLSD());
-        llcoro::waitForEventOn(timeout);
+        llcoro::suspendUntilEventOn(timeout);
 
         if (mEraseExpiredTimer.checkExpirationAndReset(ERASE_EXPIRED_TIMEOUT))
         {
@@ -564,7 +564,7 @@ void LLExperienceCache::fetchAssociatedExperienceCoro(LLCoreHttpUtil::HttpCorout
     data["item-id"] = itemId;
     data["fields"] = fields;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, data);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, data);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -612,7 +612,7 @@ void LLExperienceCache::findExperienceByNameCoro(LLCoreHttpUtil::HttpCoroutineAd
 
     url << mCapability("FindExperienceByName")  << "?page=" << page << "&page_size=" << SEARCH_PAGE_SIZE << "&query=" << LLURI::escape(text);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url.str());
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url.str());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -661,7 +661,7 @@ void LLExperienceCache::getGroupExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAda
 
     url += "?" + groupId.asString();
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -704,9 +704,9 @@ void LLExperienceCache::regionExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAdapt
 
     LLSD result;
     if (update)
-        result = httpAdapter->postAndYield(httpRequest, url, experiences);
+        result = httpAdapter->postAndSuspend(httpRequest, url, experiences);
     else
-        result = httpAdapter->getAndYield(httpRequest, url);
+        result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -740,7 +740,7 @@ void LLExperienceCache::getExperiencePermission(const LLUUID &experienceId, Expe
         // _1 -> httpAdapter
         // _2 -> httpRequest
         // _3 -> url
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::getAndYield), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::getAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
     LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
@@ -770,7 +770,7 @@ void LLExperienceCache::setExperiencePermission(const LLUUID &experienceId, cons
         // _1 -> httpAdapter
         // _2 -> httpRequest
         // _3 -> url
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndYield), _1, _2, _3, data, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndSuspend), _1, _2, _3, data, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
     LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
@@ -795,7 +795,7 @@ void LLExperienceCache::forgetExperiencePermission(const LLUUID &experienceId, E
         // _1 -> httpAdapter
         // _2 -> httpRequest
         // _3 -> url
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
     LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
@@ -845,7 +845,7 @@ void LLExperienceCache::getExperienceAdminCoro(LLCoreHttpUtil::HttpCoroutineAdap
     }
     url += "?experience_id=" + experienceId.asString();
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 //     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
 //     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
 
@@ -880,7 +880,7 @@ void LLExperienceCache::updateExperienceCoro(LLCoreHttpUtil::HttpCoroutineAdapte
     updateData.erase(LLExperienceCache::EXPIRES);
     updateData.erase(LLExperienceCache::AGENT_ID);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, updateData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, updateData);
 
     fn(result);
 }
diff --git a/indra/llmessage/message.cpp b/indra/llmessage/message.cpp
index 4f9aa5d2de..2f4b47286d 100755
--- a/indra/llmessage/message.cpp
+++ b/indra/llmessage/message.cpp
@@ -4023,7 +4023,7 @@ void LLMessageSystem::sendUntrustedSimulatorMessageCoro(std::string url, std::st
     postData["message"] = message;
     postData["body"] = body;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llaccountingcostmanager.cpp b/indra/newview/llaccountingcostmanager.cpp
index cd9146ea16..d5027d13fa 100755
--- a/indra/newview/llaccountingcostmanager.cpp
+++ b/indra/newview/llaccountingcostmanager.cpp
@@ -101,7 +101,7 @@ void LLAccountingCostManager::accountingCostCoro(std::string url,
 
         LLCoreHttpUtil::HttpCoroutineAdapter httpAdapter("AccountingCost", mHttpPolicy);
 
-        LLSD results = httpAdapter.postAndYield(mHttpRequest, url, dataToPost);
+        LLSD results = httpAdapter.postAndSuspend(mHttpRequest, url, dataToPost);
 
         LLSD httpResults;
         httpResults = results["http_result"];
diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index 2d877f6a47..5b7380a175 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -99,7 +99,7 @@ void AISAPI::CreateInventory(const LLUUID& parentId, const LLSD& newInventory, c
     LL_DEBUGS("Inventory") << "url: " << url << LL_ENDL;
 
     // I may be suffering from golden hammer here, but the first part of this bind 
-    // is actually a static cast for &HttpCoroutineAdapter::postAndYield so that 
+    // is actually a static cast for &HttpCoroutineAdapter::postAndSuspend so that 
     // the compiler can identify the correct signature to select.
     // 
     // Reads as follows:
@@ -117,7 +117,7 @@ void AISAPI::CreateInventory(const LLUUID& parentId, const LLSD& newInventory, c
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndYield), _1, _2, _3, _4, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndSuspend), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, postFn, url, parentId, newInventory, callback, COPYINVENTORY));
@@ -150,7 +150,7 @@ void AISAPI::SlamFolder(const LLUUID& folderId, const LLSD& newInventory, comple
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndYield), _1, _2, _3, _4, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndSuspend), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, putFn, url, folderId, newInventory, callback, SLAMFOLDER));
@@ -182,7 +182,7 @@ void AISAPI::RemoveCategory(const LLUUID &categoryId, completion_t callback)
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, delFn, url, categoryId, LLSD(), callback, REMOVECATEGORY));
@@ -215,7 +215,7 @@ void AISAPI::RemoveItem(const LLUUID &itemId, completion_t callback)
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, delFn, url, itemId, LLSD(), callback, REMOVEITEM));
@@ -258,7 +258,7 @@ void AISAPI::CopyLibraryCategory(const LLUUID& sourceId, const LLUUID& destId, b
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::copyAndYield), _1, _2, _3, destination, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::copyAndSuspend), _1, _2, _3, destination, _5, _6);
          
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, copyFn, url, destId, LLSD(), callback, COPYLIBRARYCATEGORY));
@@ -291,7 +291,7 @@ void AISAPI::PurgeDescendents(const LLUUID &categoryId, completion_t callback)
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndYield), _1, _2, _3, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, delFn, url, categoryId, LLSD(), callback, PURGEDESCENDENTS));
@@ -323,7 +323,7 @@ void AISAPI::UpdateCategory(const LLUUID &categoryId, const LLSD &updates, compl
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndSuspend), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, patchFn, url, categoryId, updates, callback, UPDATECATEGORY));
@@ -355,7 +355,7 @@ void AISAPI::UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t
         // _4 -> body 
         // _5 -> httpOptions
         // _6 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndYield), _1, _2, _3, _4, _5, _6);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::patchAndSuspend), _1, _2, _3, _4, _5, _6);
 
     LLCoprocedureManager::CoProcedure_t proc(boost::bind(&AISAPI::InvokeAISCommandCoro,
         _1, patchFn, url, itemId, updates, callback, UPDATEITEM));
diff --git a/indra/newview/llavatarrenderinfoaccountant.cpp b/indra/newview/llavatarrenderinfoaccountant.cpp
index e260142254..470f516db2 100644
--- a/indra/newview/llavatarrenderinfoaccountant.cpp
+++ b/indra/newview/llavatarrenderinfoaccountant.cpp
@@ -67,7 +67,7 @@ void LLAvatarRenderInfoAccountant::avatarRenderInfoGetCoro(std::string url, U64
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("AvatarRenderInfoAccountant", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLViewerRegion * regionp = LLWorld::getInstance()->getRegionFromHandle(regionHandle);
     if (!regionp)
@@ -190,7 +190,7 @@ void LLAvatarRenderInfoAccountant::avatarRenderInfoReportCoro(std::string url, U
 
     report[KEY_AGENTS] = agents;
     regionp = NULL;
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, report);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, report);
 
     regionp = LLWorld::getInstance()->getRegionFromHandle(regionHandle);
     if (!regionp)
diff --git a/indra/newview/llestateinfomodel.cpp b/indra/newview/llestateinfomodel.cpp
index 884d1579e6..8f2eb41307 100755
--- a/indra/newview/llestateinfomodel.cpp
+++ b/indra/newview/llestateinfomodel.cpp
@@ -153,7 +153,7 @@ void LLEstateInfoModel::commitEstateInfoCapsCoro(std::string url)
         << ", sun_hour = " << getSunHour() << LL_ENDL;
     LL_DEBUGS() << body << LL_ENDL;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, body);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, body);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/lleventpoll.cpp b/indra/newview/lleventpoll.cpp
index 0aad1d5ba9..021d17251d 100755
--- a/indra/newview/lleventpoll.cpp
+++ b/indra/newview/lleventpoll.cpp
@@ -127,7 +127,7 @@ namespace Details
         if (adapter)
         {
             // cancel the yielding operation if any.
-            adapter->cancelYieldingOperation();
+            adapter->cancelSuspendedOperation();
         }
     }
 
@@ -154,7 +154,7 @@ namespace Details
 //              << LLSDXMLStreamer(request) << LL_ENDL;
 
             LL_DEBUGS("LLEventPollImpl") << " <" << counter << "> posting and yielding." << LL_ENDL;
-            LLSD result = httpAdapter->postAndYield(mHttpRequest, url, request);
+            LLSD result = httpAdapter->postAndSuspend(mHttpRequest, url, request);
 
 //          LL_DEBUGS("LLEventPollImpl::eventPollCoro") << "<" << counter << "> result = "
 //              << LLSDXMLStreamer(result) << LL_ENDL;
@@ -197,7 +197,7 @@ namespace Details
                         " seconds, error count is now " << errorCount << LL_ENDL;
 
                     timeout.eventAfter(waitToRetry, LLSD());
-                    llcoro::waitForEventOn(timeout);
+                    llcoro::suspendUntilEventOn(timeout);
                     
                     if (mDone)
                         break;
diff --git a/indra/newview/llfacebookconnect.cpp b/indra/newview/llfacebookconnect.cpp
index 7975902f73..1de4102dba 100755
--- a/indra/newview/llfacebookconnect.cpp
+++ b/indra/newview/llfacebookconnect.cpp
@@ -165,7 +165,7 @@ void LLFacebookConnect::facebookConnectCoro(std::string authCode, std::string au
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->putAndYield(httpRequest, getFacebookConnectURL("/connection"), putData, httpOpts, get_headers());
+    LLSD result = httpAdapter->putAndSuspend(httpRequest, getFacebookConnectURL("/connection"), putData, httpOpts, get_headers());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -240,7 +240,7 @@ void LLFacebookConnect::facebookShareCoro(std::string route, LLSD share)
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getFacebookConnectURL(route, true), share, httpOpts, get_headers());
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getFacebookConnectURL(route, true), share, httpOpts, get_headers());
 
     if (testShareStatus(result))
     {
@@ -307,7 +307,7 @@ void LLFacebookConnect::facebookShareImageCoro(std::string route, LLPointer<LLIm
 
     setConnectionState(LLFacebookConnect::FB_POSTING);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getFacebookConnectURL(route, true), raw, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getFacebookConnectURL(route, true), raw, httpOpts, httpHeaders);
 
     if (testShareStatus(result))
     {
@@ -329,7 +329,7 @@ void LLFacebookConnect::facebookDisconnectCoro()
 
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->deleteAndYield(httpRequest, getFacebookConnectURL("/connection"), httpOpts, get_headers());
+    LLSD result = httpAdapter->deleteAndSuspend(httpRequest, getFacebookConnectURL("/connection"), httpOpts, get_headers());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -365,7 +365,7 @@ void LLFacebookConnect::facebookConnectedCheckCoro(bool autoConnect)
 
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getFacebookConnectURL("/connection", true), httpOpts, get_headers());
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getFacebookConnectURL("/connection", true), httpOpts, get_headers());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -413,7 +413,7 @@ void LLFacebookConnect::facebookConnectInfoCoro()
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getFacebookConnectURL("/info", true), httpOpts, get_headers());
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getFacebookConnectURL("/info", true), httpOpts, get_headers());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -456,7 +456,7 @@ void LLFacebookConnect::facebookConnectFriendsCoro()
 
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getFacebookConnectURL("/friends", true), httpOpts, get_headers());
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getFacebookConnectURL("/friends", true), httpOpts, get_headers());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfeaturemanager.cpp b/indra/newview/llfeaturemanager.cpp
index d2f8c68558..f08064d9b5 100755
--- a/indra/newview/llfeaturemanager.cpp
+++ b/indra/newview/llfeaturemanager.cpp
@@ -526,7 +526,7 @@ void LLFeatureManager::fetchFeatureTableCoro(std::string tableName)
 
     LL_INFOS() << "LLFeatureManager fetching " << url << " into " << path << LL_ENDL;
 
-    LLSD result = httpAdapter->getRawAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llflickrconnect.cpp b/indra/newview/llflickrconnect.cpp
index b18149a06c..c0ca5b8cf8 100644
--- a/indra/newview/llflickrconnect.cpp
+++ b/indra/newview/llflickrconnect.cpp
@@ -86,7 +86,7 @@ void LLFlickrConnect::flickrConnectCoro(std::string requestToken, std::string oa
 
     setConnectionState(LLFlickrConnect::FLICKR_CONNECTION_IN_PROGRESS);
 
-    LLSD result = httpAdapter->putAndYield(httpRequest, getFlickrConnectURL("/connection"), body, httpOpts);
+    LLSD result = httpAdapter->putAndSuspend(httpRequest, getFlickrConnectURL("/connection"), body, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -168,7 +168,7 @@ void LLFlickrConnect::flickrShareCoro(LLSD share)
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getFlickrConnectURL("/share/photo", true), share, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getFlickrConnectURL("/share/photo", true), share, httpOpts);
 
     if (testShareStatus(result))
     {
@@ -246,7 +246,7 @@ void LLFlickrConnect::flickrShareImageCoro(LLPointer<LLImageFormatted> image, st
 
     body << "\r\n--" << boundary << "--\r\n";
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getFlickrConnectURL("/share/photo", true), raw, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getFlickrConnectURL("/share/photo", true), raw, httpOpts, httpHeaders);
 
     if (testShareStatus(result))
     {
@@ -269,7 +269,7 @@ void LLFlickrConnect::flickrDisconnectCoro()
     setConnectionState(LLFlickrConnect::FLICKR_DISCONNECTING);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->deleteAndYield(httpRequest, getFlickrConnectURL("/connection"), httpOpts);
+    LLSD result = httpAdapter->deleteAndSuspend(httpRequest, getFlickrConnectURL("/connection"), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -304,7 +304,7 @@ void LLFlickrConnect::flickrConnectedCoro(bool autoConnect)
 
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getFlickrConnectURL("/connection", true), httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getFlickrConnectURL("/connection", true), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -353,7 +353,7 @@ void LLFlickrConnect::flickrInfoCoro()
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getFlickrConnectURL("/info", true), httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getFlickrConnectURL("/info", true), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloateravatarpicker.cpp b/indra/newview/llfloateravatarpicker.cpp
index 2824038f77..72892b47a4 100755
--- a/indra/newview/llfloateravatarpicker.cpp
+++ b/indra/newview/llfloateravatarpicker.cpp
@@ -466,7 +466,7 @@ void LLFloaterAvatarPicker::findCoro(std::string url, LLUUID queryID, std::strin
 
     LL_INFOS("HttpCoroutineAdapter", "genericPostCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloaterexperiences.cpp b/indra/newview/llfloaterexperiences.cpp
index bdab9ed868..fbe00beddd 100644
--- a/indra/newview/llfloaterexperiences.cpp
+++ b/indra/newview/llfloaterexperiences.cpp
@@ -293,7 +293,7 @@ void LLFloaterExperiences::retrieveExperienceList(const std::string &url,
         // _3 -> url
         // _4 -> httpOptions
         // _5 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::getAndYield), _1, _2, _3, _4, _5);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::getAndSuspend), _1, _2, _3, _4, _5);
 
     LLCoros::instance().launch("LLFloaterExperiences::retrieveExperienceList",
         boost::bind(&LLFloaterExperiences::retrieveExperienceListCoro,
@@ -314,7 +314,7 @@ void LLFloaterExperiences::requestNewExperience(const std::string &url,
         // _3 -> url
         // _4 -> httpOptions
         // _5 -> httpHeaders
-        (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndYield), _1, _2, _3, LLSD(), _4, _5);
+        (&LLCoreHttpUtil::HttpCoroutineAdapter::postAndSuspend), _1, _2, _3, LLSD(), _4, _5);
 
     LLCoros::instance().launch("LLFloaterExperiences::requestNewExperience",
         boost::bind(&LLFloaterExperiences::retrieveExperienceListCoro,
diff --git a/indra/newview/llfloatermodeluploadbase.cpp b/indra/newview/llfloatermodeluploadbase.cpp
index e2f84fd990..0fe97fd610 100755
--- a/indra/newview/llfloatermodeluploadbase.cpp
+++ b/indra/newview/llfloatermodeluploadbase.cpp
@@ -70,7 +70,7 @@ void LLFloaterModelUploadBase::requestAgentUploadPermissionsCoro(std::string url
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloaterperms.cpp b/indra/newview/llfloaterperms.cpp
index 16bb449fdb..31c2a6f9aa 100755
--- a/indra/newview/llfloaterperms.cpp
+++ b/indra/newview/llfloaterperms.cpp
@@ -215,7 +215,7 @@ void LLFloaterPermsDefault::updateCapCoro(std::string url)
         LL_CONT << sent_perms_log.str() << LL_ENDL;
     }
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloaterscriptlimits.cpp b/indra/newview/llfloaterscriptlimits.cpp
index 14719a77f9..7b8fc5b35b 100755
--- a/indra/newview/llfloaterscriptlimits.cpp
+++ b/indra/newview/llfloaterscriptlimits.cpp
@@ -220,7 +220,7 @@ void LLPanelScriptLimitsRegionMemory::getLandScriptResourcesCoro(std::string url
 
     postData["parcel_id"] = mParcelId;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -260,7 +260,7 @@ void LLPanelScriptLimitsRegionMemory::getLandScriptSummaryCoro(std::string url)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("getLandScriptSummaryCoro", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -312,7 +312,7 @@ void LLPanelScriptLimitsRegionMemory::getLandScriptDetailsCoro(std::string url)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("getLandScriptDetailsCoro", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -963,7 +963,7 @@ void LLPanelScriptLimitsAttachment::getAttachmentLimitsCoro(std::string url)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("getAttachmentLimitsCoro", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloatertos.cpp b/indra/newview/llfloatertos.cpp
index 6dc08417d7..f6cfaf5522 100755
--- a/indra/newview/llfloatertos.cpp
+++ b/indra/newview/llfloatertos.cpp
@@ -214,7 +214,7 @@ void LLFloaterTOS::testSiteIsAliveCoro(std::string url)
 
     LL_INFOS("HttpCoroutineAdapter", "genericPostCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llfloaterurlentry.cpp b/indra/newview/llfloaterurlentry.cpp
index 6683a6e6e6..f2efef0c33 100755
--- a/indra/newview/llfloaterurlentry.cpp
+++ b/indra/newview/llfloaterurlentry.cpp
@@ -220,7 +220,7 @@ void LLFloaterURLEntry::getMediaTypeCoro(std::string url, LLHandle<LLFloater> pa
 
     LL_INFOS("HttpCoroutineAdapter", "genericPostCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url, httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llgroupmgr.cpp b/indra/newview/llgroupmgr.cpp
index b218f4f756..4559132aeb 100755
--- a/indra/newview/llgroupmgr.cpp
+++ b/indra/newview/llgroupmgr.cpp
@@ -1870,7 +1870,7 @@ void LLGroupMgr::getGroupBanRequestCoro(std::string url, LLUUID groupId)
 
     std::string finalUrl = url + "?group_id=" + groupId.asString();
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, finalUrl);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, finalUrl);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -1921,7 +1921,7 @@ void LLGroupMgr::postGroupBanRequestCoro(std::string url, LLUUID groupId,
 
     LL_WARNS() << "post: " << ll_pretty_print_sd(postData) << LL_ENDL;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, finalUrl, postData, httpOptions, httpHeaders);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, finalUrl, postData, httpOptions, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -2041,7 +2041,7 @@ void LLGroupMgr::groupMembersRequestCoro(std::string url, LLUUID groupId)
     LLSD postData = LLSD::emptyMap();
     postData["group_id"] = groupId;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llimview.cpp b/indra/newview/llimview.cpp
index 74f1cd0673..53b97a58c5 100755
--- a/indra/newview/llimview.cpp
+++ b/indra/newview/llimview.cpp
@@ -402,7 +402,7 @@ void startConfrenceCoro(std::string url,
     postData["session-id"] = tempSessionId;
     postData["params"] = agents;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -441,7 +441,7 @@ void chatterBoxInvitationCoro(std::string url, LLUUID sessionId, LLIMMgr::EInvit
     postData["method"] = "accept invitation";
     postData["session-id"] = sessionId;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llinventorymodel.cpp b/indra/newview/llinventorymodel.cpp
index 175ea22aa0..53a58aff4c 100755
--- a/indra/newview/llinventorymodel.cpp
+++ b/indra/newview/llinventorymodel.cpp
@@ -614,7 +614,7 @@ void LLInventoryModel::createNewCategoryCoro(std::string url, LLSD postData, inv
 
     LL_INFOS("HttpCoroutineAdapter", "genericPostCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llmarketplacefunctions.cpp b/indra/newview/llmarketplacefunctions.cpp
index b0cd1dd23e..e8e56ef0cd 100755
--- a/indra/newview/llmarketplacefunctions.cpp
+++ b/indra/newview/llmarketplacefunctions.cpp
@@ -191,7 +191,7 @@ namespace LLMarketplaceImport
         httpHeaders->append(HTTP_OUT_HEADER_CONTENT_TYPE, HTTP_CONTENT_XML);
         httpHeaders->append(HTTP_OUT_HEADER_USER_AGENT, LLViewerMedia::getCurrentUserAgent());
 
-        LLSD result = httpAdapter->postAndYield(httpRequest, url, LLSD(), httpOpts, httpHeaders);
+        LLSD result = httpAdapter->postAndSuspend(httpRequest, url, LLSD(), httpOpts, httpHeaders);
 
         LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
         LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -260,7 +260,7 @@ namespace LLMarketplaceImport
             httpHeaders = LLViewerMedia::getHttpHeaders();
         }
 
-        LLSD result = httpAdapter->getAndYield(httpRequest, url, httpOpts, httpHeaders);
+        LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
         LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
         LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -755,7 +755,7 @@ void LLMarketplaceData::getMerchantStatusCoro()
         LL_INFOS("Marketplace") << "No marketplace capability on Sim" << LL_ENDL;
     }
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url, httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -820,7 +820,7 @@ void LLMarketplaceData::getSLMListingsCoro(LLUUID folderId)
 
     std::string url = getSLMConnectURL("/listings");
 
-    LLSD result = httpAdapter->getJsonAndYield(httpRequest, url, httpHeaders);
+    LLSD result = httpAdapter->getJsonAndSuspend(httpRequest, url, httpHeaders);
 
     setUpdating(folderId, false);
 
@@ -885,7 +885,7 @@ void LLMarketplaceData::getSingleListingCoro(S32 listingId, LLUUID folderId)
 
     std::string url = getSLMConnectURL("/listing/") + llformat("%d", listingId);
 
-    LLSD result = httpAdapter->getJsonAndYield(httpRequest, url, httpHeaders);
+    LLSD result = httpAdapter->getJsonAndSuspend(httpRequest, url, httpHeaders);
 
     setUpdating(folderId, false);
 
@@ -967,7 +967,7 @@ void LLMarketplaceData::createSLMListingCoro(LLUUID folderId, LLUUID versionId,
 
     std::string url = getSLMConnectURL("/listings");
 
-    LLSD result = httpAdapter->postJsonAndYield(httpRequest, url, postData, httpHeaders);
+    LLSD result = httpAdapter->postJsonAndSuspend(httpRequest, url, postData, httpHeaders);
 
     setUpdating(folderId, false);
 
@@ -1034,7 +1034,7 @@ void LLMarketplaceData::updateSLMListingCoro(LLUUID folderId, S32 listingId, LLU
     postData["listing"] = listing;
 
     std::string url = getSLMConnectURL("/listing/") + llformat("%d", listingId);
-    LLSD result = httpAdapter->putJsonAndYield(httpRequest, url, postData, httpHeaders);
+    LLSD result = httpAdapter->putJsonAndSuspend(httpRequest, url, postData, httpHeaders);
 
     setUpdating(folderId, false);
 
@@ -1116,7 +1116,7 @@ void LLMarketplaceData::associateSLMListingCoro(LLUUID folderId, S32 listingId,
     // Send request
     std::string url = getSLMConnectURL("/associate_inventory/") + llformat("%d", listingId);
 
-    LLSD result = httpAdapter->putJsonAndYield(httpRequest, url, postData, httpHeaders);
+    LLSD result = httpAdapter->putJsonAndSuspend(httpRequest, url, postData, httpHeaders);
 
     setUpdating(folderId, false);
     setUpdating(sourceFolderId, false);
@@ -1190,7 +1190,7 @@ void LLMarketplaceData::deleteSLMListingCoro(S32 listingId)
 
     setUpdating(folderId, true);
 
-    LLSD result = httpAdapter->deleteJsonAndYield(httpRequest, url, httpHeaders);
+    LLSD result = httpAdapter->deleteJsonAndSuspend(httpRequest, url, httpHeaders);
 
     setUpdating(folderId, false);
 
diff --git a/indra/newview/llpathfindingmanager.cpp b/indra/newview/llpathfindingmanager.cpp
index 2e6937a79f..711a869e82 100755
--- a/indra/newview/llpathfindingmanager.cpp
+++ b/indra/newview/llpathfindingmanager.cpp
@@ -464,7 +464,7 @@ void LLPathfindingManager::navMeshStatusRequestCoro(std::string url, U64 regionH
     LLUUID regionUUID = region->getRegionID();
 
     region = NULL;
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     region = LLWorld::getInstance()->getRegionFromHandle(regionHandle);
 
@@ -519,7 +519,7 @@ void LLPathfindingManager::navMeshStatusRequestCoro(std::string url, U64 regionH
     navMeshPtr->handleNavMeshStart(navMeshStatus);
 
     LLSD postData;
-    result = httpAdapter->postAndYield(httpRequest, navMeshURL, postData);
+    result = httpAdapter->postAndSuspend(httpRequest, navMeshURL, postData);
 
     U32 navMeshVersion = navMeshStatus.getVersion();
 
@@ -545,7 +545,7 @@ void LLPathfindingManager::navAgentStateRequestCoro(std::string url)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("NavAgentStateRequest", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -577,7 +577,7 @@ void LLPathfindingManager::navMeshRebakeCoro(std::string url, rebake_navmesh_cal
     LLSD postData = LLSD::emptyMap();
     postData["command"] = "rebuild";
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -606,11 +606,11 @@ void LLPathfindingManager::linksetObjectsCoro(std::string url, LinksetsResponder
 
     if (putData.isUndefined())
     {
-        result = httpAdapter->getAndYield(httpRequest, url);
+        result = httpAdapter->getAndSuspend(httpRequest, url);
     }
     else 
     {
-        result = httpAdapter->putAndYield(httpRequest, url, putData);
+        result = httpAdapter->putAndSuspend(httpRequest, url, putData);
     }
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
@@ -642,11 +642,11 @@ void LLPathfindingManager::linksetTerrainCoro(std::string url, LinksetsResponder
 
     if (putData.isUndefined())
     {
-        result = httpAdapter->getAndYield(httpRequest, url);
+        result = httpAdapter->getAndSuspend(httpRequest, url);
     }
     else 
     {
-        result = httpAdapter->putAndYield(httpRequest, url, putData);
+        result = httpAdapter->putAndSuspend(httpRequest, url, putData);
     }
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
@@ -673,7 +673,7 @@ void LLPathfindingManager::charactersCoro(std::string url, request_id_t requestI
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("LinksetTerrain", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llproductinforequest.cpp b/indra/newview/llproductinforequest.cpp
index 467e9df482..b663df4aae 100755
--- a/indra/newview/llproductinforequest.cpp
+++ b/indra/newview/llproductinforequest.cpp
@@ -73,7 +73,7 @@ void LLProductInfoRequestManager::getLandDescriptionsCoro(std::string url)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("genericPostCoro", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llremoteparcelrequest.cpp b/indra/newview/llremoteparcelrequest.cpp
index 06bf90c7cb..055ccd5818 100755
--- a/indra/newview/llremoteparcelrequest.cpp
+++ b/indra/newview/llremoteparcelrequest.cpp
@@ -200,7 +200,7 @@ void LLRemoteParcelInfoProcessor::regionParcelInfoCoro(std::string url,
         bodyData["region_handle"] = ll_sd_from_U64(regionHandle);
     }
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, bodyData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, bodyData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llspeakers.cpp b/indra/newview/llspeakers.cpp
index 3b060d8343..974029254f 100755
--- a/indra/newview/llspeakers.cpp
+++ b/indra/newview/llspeakers.cpp
@@ -881,7 +881,7 @@ void LLIMSpeakerMgr::moderationActionCoro(std::string url, LLSD action)
 
     LLUUID sessionId = action["session-id"];
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, action, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, action, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llsyntaxid.cpp b/indra/newview/llsyntaxid.cpp
index 7f286044d6..9e54c521b5 100644
--- a/indra/newview/llsyntaxid.cpp
+++ b/indra/newview/llsyntaxid.cpp
@@ -129,7 +129,7 @@ void LLSyntaxIdLSL::fetchKeywordsFileCoro(std::string url, std::string fileSpec)
         return;
     }
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/lltranslate.cpp b/indra/newview/lltranslate.cpp
index 5390573f7b..76fba82ef6 100755
--- a/indra/newview/lltranslate.cpp
+++ b/indra/newview/lltranslate.cpp
@@ -146,7 +146,7 @@ void LLTranslationAPIHandler::verifyKeyCoro(LLTranslate::EService service, std::
         return;
     }
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -187,7 +187,7 @@ void LLTranslationAPIHandler::translateMessageCoro(LanguagePair_t fromTo, std::s
         return;
     }
 
-    LLSD result = httpAdapter->getRawAndYield(httpRequest, url, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/lltwitterconnect.cpp b/indra/newview/lltwitterconnect.cpp
index 86a49cc189..9b7c13b57d 100644
--- a/indra/newview/lltwitterconnect.cpp
+++ b/indra/newview/lltwitterconnect.cpp
@@ -84,7 +84,7 @@ void LLTwitterConnect::twitterConnectCoro(std::string requestToken, std::string
     if (!oauthVerifier.empty())
         body["oauth_verifier"] = oauthVerifier;
 
-    LLSD result = httpAdapter->putAndYield(httpRequest, getTwitterConnectURL("/connection"), body, httpOpts);
+    LLSD result = httpAdapter->putAndSuspend(httpRequest, getTwitterConnectURL("/connection"), body, httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -166,7 +166,7 @@ void LLTwitterConnect::twitterShareCoro(std::string route, LLSD share)
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getTwitterConnectURL(route, true), share, httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getTwitterConnectURL(route, true), share, httpOpts);
 
     if (testShareStatus(result))
     {
@@ -231,7 +231,7 @@ void LLTwitterConnect::twitterShareImageCoro(LLPointer<LLImageFormatted> image,
 
     body << "\r\n--" << boundary << "--\r\n";
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, getTwitterConnectURL("/share/photo", true), raw, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, getTwitterConnectURL("/share/photo", true), raw, httpOpts, httpHeaders);
 
     if (testShareStatus(result))
     {
@@ -253,7 +253,7 @@ void LLTwitterConnect::twitterDisconnectCoro()
 
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->deleteAndYield(httpRequest, getTwitterConnectURL("/connection"), httpOpts);
+    LLSD result = httpAdapter->deleteAndSuspend(httpRequest, getTwitterConnectURL("/connection"), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -287,7 +287,7 @@ void LLTwitterConnect::twitterConnectedCoro(bool autoConnect)
     httpOpts->setFollowRedirects(false);
     setConnectionState(LLTwitterConnect::TWITTER_CONNECTION_IN_PROGRESS);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getTwitterConnectURL("/connection", true), httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getTwitterConnectURL("/connection", true), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -336,7 +336,7 @@ void LLTwitterConnect::twitterInfoCoro()
     httpOpts->setWantHeaders(true);
     httpOpts->setFollowRedirects(false);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, getTwitterConnectURL("/info", true), httpOpts);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, getTwitterConnectURL("/info", true), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index 6c6d3a4f33..e8f9809ee7 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -689,7 +689,7 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoreHttpUtil::HttpCorouti
         return;
     }
 
-    llcoro::yield();
+    llcoro::suspend();
 
     if (uploadInfo->showUploadDialog())
     {
@@ -700,7 +700,7 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoreHttpUtil::HttpCorouti
 
     LLSD body = uploadInfo->generatePostBody();
 
-    result = httpAdapter->postAndYield(httpRequest, url, body);
+    result = httpAdapter->postAndSuspend(httpRequest, url, body);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -718,7 +718,7 @@ void LLViewerAssetUpload::AssetInventoryUploadCoproc(LLCoreHttpUtil::HttpCorouti
     bool success = false;
     if (!uploader.empty() && uploadInfo->getAssetId().notNull())
     {
-        result = httpAdapter->postFileAndYield(httpRequest, uploader, uploadInfo->getAssetId(), uploadInfo->getAssetType());
+        result = httpAdapter->postFileAndSuspend(httpRequest, uploader, uploadInfo->getAssetId(), uploadInfo->getAssetType());
         httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
         status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
 
diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index f332a4e98e..75a201d92f 100755
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -1280,7 +1280,7 @@ void LLViewerMedia::getOpenIDCookieCoro(std::string url)
     LL_DEBUGS("MediaAuth") << "Requesting " << url << LL_ENDL;
     LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL;
     
-    LLSD result = httpAdapter->getRawAndYield(httpRequest, url, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -1347,7 +1347,7 @@ void LLViewerMedia::openIDSetupCoro(std::string openidUrl, std::string openidTok
 
     bas << std::noskipws << openidToken;
 
-    LLSD result = httpAdapter->postRawAndYield(httpRequest, openidUrl, rawbody, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->postRawAndSuspend(httpRequest, openidUrl, rawbody, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -2600,7 +2600,7 @@ void LLViewerMediaImpl::mimeDiscoveryCoro(std::string url)
     httpHeaders->append(HTTP_OUT_HEADER_ACCEPT, "*/*");
     httpHeaders->append(HTTP_OUT_HEADER_COOKIE, "");
 
-    LLSD result = httpAdapter->getRawAndYield(httpRequest, url, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->getRawAndSuspend(httpRequest, url, httpOpts, httpHeaders);
 
     mMimeProbe.reset();
 
@@ -3634,7 +3634,7 @@ void LLViewerMediaImpl::cancelMimeTypeProbe()
     LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t probeAdapter = mMimeProbe.lock();
 
     if (probeAdapter)
-        probeAdapter->cancelYieldingOperation();
+        probeAdapter->cancelSuspendedOperation();
 }
 
 void LLViewerMediaImpl::addObject(LLVOVolume* obj) 
diff --git a/indra/newview/llviewerobjectlist.cpp b/indra/newview/llviewerobjectlist.cpp
index 9b0035d547..e193e8431e 100755
--- a/indra/newview/llviewerobjectlist.cpp
+++ b/indra/newview/llviewerobjectlist.cpp
@@ -1052,7 +1052,7 @@ void LLViewerObjectList::fetchObjectCostsCoro(std::string url)
 
     postData["object_ids"] = idList;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -1181,7 +1181,7 @@ void LLViewerObjectList::fetchPhisicsFlagsCoro(std::string url)
 
     postData["object_ids"] = idList;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llviewerregion.cpp b/indra/newview/llviewerregion.cpp
index 4ed90d26b7..8c4a6935a6 100755
--- a/indra/newview/llviewerregion.cpp
+++ b/indra/newview/llviewerregion.cpp
@@ -273,7 +273,7 @@ void LLViewerRegionImpl::requestBaseCapabilitiesCoro(U64 regionHandle)
             << " (attempt #" << mSeedCapAttempts << ")" << LL_ENDL;
 
         regionp = NULL;
-        result = httpAdapter->postAndYield(httpRequest, url, capabilityNames);
+        result = httpAdapter->postAndSuspend(httpRequest, url, capabilityNames);
 
         regionp = LLWorld::getInstance()->getRegionFromHandle(regionHandle);
         if (!regionp) //region was removed
@@ -363,7 +363,7 @@ void LLViewerRegionImpl::requestBaseCapabilitiesCompleteCoro(U64 regionHandle)
         LL_INFOS("AppInit", "Capabilities") << "Requesting second Seed from " << url << LL_ENDL;
 
         regionp = NULL;
-        result = httpAdapter->postAndYield(httpRequest, url, capabilityNames);
+        result = httpAdapter->postAndSuspend(httpRequest, url, capabilityNames);
 
         LLSD httpResults = result["http_result"];
         LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -462,7 +462,7 @@ void LLViewerRegionImpl::requestSimulatorFeatureCoro(std::string url, U64 region
         }
 
         regionp = NULL;
-        LLSD result = httpAdapter->getAndYield(httpRequest, url);
+        LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
         LLSD httpResults = result["http_result"];
         LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llvoavatarself.cpp b/indra/newview/llvoavatarself.cpp
index fb2171ccc2..e7dee14387 100755
--- a/indra/newview/llvoavatarself.cpp
+++ b/indra/newview/llvoavatarself.cpp
@@ -2203,7 +2203,7 @@ void LLVOAvatarSelf::appearanceChangeMetricsCoro(std::string url)
 
     gPendingMetricsUploads++;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, msg);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, msg);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llvoicechannel.cpp b/indra/newview/llvoicechannel.cpp
index 192d50ae9b..3abb716593 100755
--- a/indra/newview/llvoicechannel.cpp
+++ b/indra/newview/llvoicechannel.cpp
@@ -617,7 +617,7 @@ void LLVoiceChannelGroup::voiceCallCapCoro(std::string url)
 
     LL_INFOS("Voice", "voiceCallCapCoro") << "Generic POST for " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, postData);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, postData);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llvoicevivox.cpp b/indra/newview/llvoicevivox.cpp
index f50ffdeae7..d14fac5fb8 100755
--- a/indra/newview/llvoicevivox.cpp
+++ b/indra/newview/llvoicevivox.cpp
@@ -462,7 +462,7 @@ void LLVivoxVoiceClient::voiceAccountProvisionCoro(std::string url, S32 retries)
 
     httpOpts->setRetries(retries);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, LLSD(), httpOpts);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, LLSD(), httpOpts);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -3941,7 +3941,7 @@ void LLVivoxVoiceClient::parcelVoiceInfoRequestCoro(std::string url)
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
     state requestingState = getState();
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, LLSD());
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, LLSD());
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llwebprofile.cpp b/indra/newview/llwebprofile.cpp
index 2033a5f36a..06ce497510 100755
--- a/indra/newview/llwebprofile.cpp
+++ b/indra/newview/llwebprofile.cpp
@@ -124,7 +124,7 @@ void LLWebProfile::uploadImageCoro(LLPointer<LLImageFormatted> image, std::strin
     httpHeaders = buildDefaultHeaders();
     httpHeaders->append(HTTP_OUT_HEADER_COOKIE, getAuthCookie());
 
-    LLSD result = httpAdapter->getJsonAndYield(httpRequest, configUrl, httpOpts, httpHeaders);
+    LLSD result = httpAdapter->getJsonAndSuspend(httpRequest, configUrl, httpOpts, httpHeaders);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
@@ -150,7 +150,7 @@ void LLWebProfile::uploadImageCoro(LLPointer<LLImageFormatted> image, std::strin
     
     LLCore::BufferArray::ptr_t body = LLWebProfile::buildPostData(data, image, boundary);
 
-    result = httpAdapter->postAndYield(httpRequest, uploadUrl, body, httpOpts, httpHeaders);
+    result = httpAdapter->postAndSuspend(httpRequest, uploadUrl, body, httpOpts, httpHeaders);
 
     body.reset();
     httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
@@ -178,7 +178,7 @@ void LLWebProfile::uploadImageCoro(LLPointer<LLImageFormatted> image, std::strin
 
     LL_DEBUGS("Snapshots") << "Got redirection URL: " << redirUrl << LL_ENDL;
 
-    result = httpAdapter->getRawAndYield(httpRequest, redirUrl, httpOpts, httpHeaders);
+    result = httpAdapter->getRawAndSuspend(httpRequest, redirUrl, httpOpts, httpHeaders);
 
     httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
diff --git a/indra/newview/llwlhandlers.cpp b/indra/newview/llwlhandlers.cpp
index ff15afa598..8ecfeef2dc 100755
--- a/indra/newview/llwlhandlers.cpp
+++ b/indra/newview/llwlhandlers.cpp
@@ -101,7 +101,7 @@ void LLEnvironmentRequest::environmentRequestCoro(std::string url)
             httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("EnvironmentRequest", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     if (requestId != LLEnvironmentRequest::sLastRequest)
     {
@@ -185,7 +185,7 @@ void LLEnvironmentApply::environmentApplyCoro(std::string url, LLSD content)
         httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("EnvironmentApply", httpPolicy));
     LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
 
-    LLSD result = httpAdapter->postAndYield(httpRequest, url, content);
+    LLSD result = httpAdapter->postAndSuspend(httpRequest, url, content);
 
     LLSD notify; // for error reporting.  If there is something to report to user this will be defined.
     /*
diff --git a/indra/viewer_components/login/lllogin.cpp b/indra/viewer_components/login/lllogin.cpp
index 88415ff11a..1feb41faf6 100755
--- a/indra/viewer_components/login/lllogin.cpp
+++ b/indra/viewer_components/login/lllogin.cpp
@@ -175,7 +175,7 @@ void LLLogin::Impl::login_(std::string uri, LLSD login_params)
 		request["op"] = "rewriteURI";
 		request["uri"] = uri;
 		request["reply"] = replyPump.getName();
-		rewrittenURIs = llcoro::postAndWait(request, srv_pump_name, filter);
+		rewrittenURIs = llcoro::postEventAndSuspend(request, srv_pump_name, filter);
 		// EXP-772: If rewrittenURIs fail, try original URI as a fallback.
 		rewrittenURIs.append(uri);
     } // we no longer need the filter
@@ -215,16 +215,16 @@ void LLLogin::Impl::login_(std::string uri, LLSD login_params)
             sendProgressEvent("offline", "authenticating", progress_data);
 
             // We expect zero or more "Downloading" status events, followed by
-            // exactly one event with some other status. Use postAndWait() the
+            // exactly one event with some other status. Use postEventAndSuspend() the
             // first time, because -- at least in unit-test land -- it's
             // possible for the reply to arrive before the post() call
             // returns. Subsequent responses, of course, must be awaited
             // without posting again.
             for (mAuthResponse = validateResponse(loginReplyPump.getName(),
-                     llcoro::postAndWait(request, xmlrpcPump, loginReplyPump, "reply"));
+                     llcoro::postEventAndSuspend(request, xmlrpcPump, loginReplyPump, "reply"));
                  mAuthResponse["status"].asString() == "Downloading";
                  mAuthResponse = validateResponse(loginReplyPump.getName(),
-                                                  llcoro::waitForEventOn(loginReplyPump)))
+                                                  llcoro::suspendUntilEventOn(loginReplyPump)))
             {
                 // Still Downloading -- send progress update.
                 sendProgressEvent("offline", "downloading");
diff --git a/indra/viewer_components/updater/llupdatechecker.cpp b/indra/viewer_components/updater/llupdatechecker.cpp
index e889f83aa9..1bb5e95740 100755
--- a/indra/viewer_components/updater/llupdatechecker.cpp
+++ b/indra/viewer_components/updater/llupdatechecker.cpp
@@ -135,7 +135,7 @@ void LLUpdateChecker::Implementation::checkVersionCoro(std::string url)
 
     LL_INFOS("checkVersionCoro") << "Getting update information from " << url << LL_ENDL;
 
-    LLSD result = httpAdapter->getAndYield(httpRequest, url);
+    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);
 
     LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
     LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-- 
cgit v1.3


From cf835a80cd2bb5d02cc03034009919e0d9eb73b6 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 18 Sep 2015 16:36:49 -0700
Subject: Pref instance() over getInstance()

---
 indra/llmessage/llexperiencecache.cpp | 22 +++++++++++-----------
 indra/newview/llaisapi.cpp            |  2 +-
 indra/newview/llviewerassetupload.cpp |  4 ++--
 3 files changed, 14 insertions(+), 14 deletions(-)

(limited to 'indra/newview/llaisapi.cpp')

diff --git a/indra/llmessage/llexperiencecache.cpp b/indra/llmessage/llexperiencecache.cpp
index 3265608582..92fcd38d3b 100644
--- a/indra/llmessage/llexperiencecache.cpp
+++ b/indra/llmessage/llexperiencecache.cpp
@@ -356,7 +356,7 @@ void LLExperienceCache::requestExperiences()
         
         if (mRequestQueue.empty() || (ostr.tellp() > EXP_URL_SEND_THRESHOLD))
         {   // request is placed in the coprocedure pool for the ExpCache cache.  Throttling is done by the pool itself.
-            LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "RequestExperiences",
+            LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "RequestExperiences",
                 boost::bind(&LLExperienceCache::requestExperiencesCoro, this, _1, ostr.str(), requests) );
 
             ostr.str(std::string());
@@ -542,7 +542,7 @@ void LLExperienceCache::fetchAssociatedExperience(const LLUUID& objectId, const
         return;
     }
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Fetch Associated",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Fetch Associated",
         boost::bind(&LLExperienceCache::fetchAssociatedExperienceCoro, this, _1, objectId, itemId, fn));
 }
 
@@ -600,7 +600,7 @@ void LLExperienceCache::findExperienceByName(const std::string text, int page, E
         return;
     }
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Search Name",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Search Name",
         boost::bind(&LLExperienceCache::findExperienceByNameCoro, this, _1, text, page, fn));
 }
 
@@ -643,7 +643,7 @@ void LLExperienceCache::getGroupExperiences(const LLUUID &groupId, ExperienceGet
         return;
     }
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Group Experiences",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Group Experiences",
         boost::bind(&LLExperienceCache::getGroupExperiencesCoro, this, _1, groupId, fn));
 }
 
@@ -679,13 +679,13 @@ void LLExperienceCache::getGroupExperiencesCoro(LLCoreHttpUtil::HttpCoroutineAda
 //-------------------------------------------------------------------------
 void LLExperienceCache::getRegionExperiences(CapabilityQuery_t regioncaps, ExperienceGetFn_t fn)
 {
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Region Experiences",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Region Experiences",
         boost::bind(&LLExperienceCache::regionExperiencesCoro, this, _1, regioncaps, false, LLSD(), fn));
 }
 
 void LLExperienceCache::setRegionExperiences(CapabilityQuery_t regioncaps, const LLSD &experiences, ExperienceGetFn_t fn)
 {
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Region Experiences",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Region Experiences",
         boost::bind(&LLExperienceCache::regionExperiencesCoro, this, _1, regioncaps, true, experiences, fn));
 }
 
@@ -743,7 +743,7 @@ void LLExperienceCache::getExperiencePermission(const LLUUID &experienceId, Expe
         (&LLCoreHttpUtil::HttpCoroutineAdapter::getAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
         boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
 }
 
@@ -773,7 +773,7 @@ void LLExperienceCache::setExperiencePermission(const LLUUID &experienceId, cons
         (&LLCoreHttpUtil::HttpCoroutineAdapter::putAndSuspend), _1, _2, _3, data, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
         boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
 }
 
@@ -798,7 +798,7 @@ void LLExperienceCache::forgetExperiencePermission(const LLUUID &experienceId, E
         (&LLCoreHttpUtil::HttpCoroutineAdapter::deleteAndSuspend), _1, _2, _3, LLCore::HttpOptions::ptr_t(), LLCore::HttpHeaders::ptr_t()));
 
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "Preferences Set",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "Preferences Set",
         boost::bind(&LLExperienceCache::experiencePermissionCoro, this, _1, invoker, url, fn));
 }
 
@@ -829,7 +829,7 @@ void LLExperienceCache::getExperienceAdmin(const LLUUID &experienceId, Experienc
         return;
     }
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "IsAdmin",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "IsAdmin",
         boost::bind(&LLExperienceCache::getExperienceAdminCoro, this, _1, experienceId, fn));
 }
 
@@ -861,7 +861,7 @@ void LLExperienceCache::updateExperience(LLSD updateData, ExperienceGetFn_t fn)
         return;
     }
 
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("ExpCache", "IsAdmin",
+    LLCoprocedureManager::instance().enqueueCoprocedure("ExpCache", "IsAdmin",
         boost::bind(&LLExperienceCache::updateExperienceCoro, this, _1, updateData, fn));
 }
 
diff --git a/indra/newview/llaisapi.cpp b/indra/newview/llaisapi.cpp
index 5b7380a175..afc6e208e6 100755
--- a/indra/newview/llaisapi.cpp
+++ b/indra/newview/llaisapi.cpp
@@ -367,7 +367,7 @@ void AISAPI::UpdateItem(const LLUUID &itemId, const LLSD &updates, completion_t
 void AISAPI::EnqueueAISCommand(const std::string &procName, LLCoprocedureManager::CoProcedure_t proc)
 {
     std::string procFullName = "AIS(" + procName + ")";
-    LLCoprocedureManager::getInstance()->enqueueCoprocedure("AIS", procFullName, proc);
+    LLCoprocedureManager::instance().enqueueCoprocedure("AIS", procFullName, proc);
 
 }
 
diff --git a/indra/newview/llviewerassetupload.cpp b/indra/newview/llviewerassetupload.cpp
index e8f9809ee7..ea3d81c2f6 100644
--- a/indra/newview/llviewerassetupload.cpp
+++ b/indra/newview/llviewerassetupload.cpp
@@ -174,7 +174,7 @@ S32 LLResourceUploadInfo::getEconomyUploadCost()
         getAssetType() == LLAssetType::AT_ANIMATION ||
         getAssetType() == LLAssetType::AT_MESH)
     {
-        return LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
+        return LLGlobalEconomy::Singleton::instance().getPriceUpload();
     }
 
     return 0;
@@ -666,7 +666,7 @@ LLUUID LLViewerAssetUpload::EnqueueInventoryUpload(const std::string &url, const
 {
     std::string procName("LLViewerAssetUpload::AssetInventoryUploadCoproc(");
     
-    LLUUID queueId = LLCoprocedureManager::getInstance()->enqueueCoprocedure("Upload", 
+    LLUUID queueId = LLCoprocedureManager::instance().enqueueCoprocedure("Upload", 
         procName + LLAssetType::lookup(uploadInfo->getAssetType()) + ")",
         boost::bind(&LLViewerAssetUpload::AssetInventoryUploadCoproc, _1, _2, url, uploadInfo));
 
-- 
cgit v1.3